The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net80211/ieee80211_amrr.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $OpenBSD: ieee80211_amrr.c,v 1.1 2006/06/17 19:07:19 damien Exp $       */
    2 
    3 /*-
    4  * Copyright (c) 2010 Rui Paulo <rpaulo@FreeBSD.org>
    5  * Copyright (c) 2006
    6  *      Damien Bergamini <damien.bergamini@free.fr>
    7  *
    8  * Permission to use, copy, modify, and distribute this software for any
    9  * purpose with or without fee is hereby granted, provided that the above
   10  * copyright notice and this permission notice appear in all copies.
   11  *
   12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   19  */
   20 
   21 #include <sys/cdefs.h>
   22 __FBSDID("$FreeBSD$");
   23 
   24 /*-
   25  * Naive implementation of the Adaptive Multi Rate Retry algorithm:
   26  *
   27  * "IEEE 802.11 Rate Adaptation: A Practical Approach"
   28  *  Mathieu Lacage, Hossein Manshaei, Thierry Turletti
   29  *  INRIA Sophia - Projet Planete
   30  *  http://www-sop.inria.fr/rapports/sophia/RR-5208.html
   31  */
   32 #include "opt_wlan.h"
   33 
   34 #include <sys/param.h>
   35 #include <sys/kernel.h>
   36 #include <sys/malloc.h>
   37 #include <sys/module.h>
   38 #include <sys/sbuf.h>
   39 #include <sys/socket.h>
   40 #include <sys/sysctl.h>
   41 
   42 #include <net/if.h>
   43 #include <net/if_var.h>
   44 #include <net/if_media.h>
   45 #include <net/ethernet.h>
   46 
   47 #ifdef INET
   48 #include <netinet/in.h>
   49 #include <netinet/if_ether.h>
   50 #endif
   51 
   52 #include <net80211/ieee80211_var.h>
   53 #include <net80211/ieee80211_ht.h>
   54 #include <net80211/ieee80211_amrr.h>
   55 #include <net80211/ieee80211_ratectl.h>
   56 
   57 #define is_success(amn) \
   58         ((amn)->amn_retrycnt < (amn)->amn_txcnt / 10)
   59 #define is_failure(amn) \
   60         ((amn)->amn_retrycnt > (amn)->amn_txcnt / 3)
   61 #define is_enough(amn)          \
   62         ((amn)->amn_txcnt > 10)
   63 
   64 static void     amrr_setinterval(const struct ieee80211vap *, int);
   65 static void     amrr_init(struct ieee80211vap *);
   66 static void     amrr_deinit(struct ieee80211vap *);
   67 static void     amrr_node_init(struct ieee80211_node *);
   68 static void     amrr_node_deinit(struct ieee80211_node *);
   69 static int      amrr_update(struct ieee80211_amrr *,
   70                         struct ieee80211_amrr_node *, struct ieee80211_node *);
   71 static int      amrr_rate(struct ieee80211_node *, void *, uint32_t);
   72 static void     amrr_tx_complete(const struct ieee80211_node *,
   73                         const struct ieee80211_ratectl_tx_status *);
   74 static void     amrr_tx_update_cb(void *, struct ieee80211_node *);
   75 static void     amrr_tx_update(struct ieee80211vap *vap,
   76                         struct ieee80211_ratectl_tx_stats *);
   77 static void     amrr_sysctlattach(struct ieee80211vap *,
   78                         struct sysctl_ctx_list *, struct sysctl_oid *);
   79 static void     amrr_node_stats(struct ieee80211_node *ni, struct sbuf *s);
   80 
   81 /* number of references from net80211 layer */
   82 static  int nrefs = 0;
   83 
   84 static const struct ieee80211_ratectl amrr = {
   85         .ir_name        = "amrr",
   86         .ir_attach      = NULL,
   87         .ir_detach      = NULL,
   88         .ir_init        = amrr_init,
   89         .ir_deinit      = amrr_deinit,
   90         .ir_node_init   = amrr_node_init,
   91         .ir_node_deinit = amrr_node_deinit,
   92         .ir_rate        = amrr_rate,
   93         .ir_tx_complete = amrr_tx_complete,
   94         .ir_tx_update   = amrr_tx_update,
   95         .ir_setinterval = amrr_setinterval,
   96         .ir_node_stats  = amrr_node_stats,
   97 };
   98 IEEE80211_RATECTL_MODULE(amrr, 1);
   99 IEEE80211_RATECTL_ALG(amrr, IEEE80211_RATECTL_AMRR, amrr);
  100 
  101 static void
  102 amrr_setinterval(const struct ieee80211vap *vap, int msecs)
  103 {
  104         struct ieee80211_amrr *amrr = vap->iv_rs;
  105 
  106         if (!amrr)
  107                 return;
  108 
  109         if (msecs < 100)
  110                 msecs = 100;
  111         amrr->amrr_interval = msecs_to_ticks(msecs);
  112 }
  113 
  114 static void
  115 amrr_init(struct ieee80211vap *vap)
  116 {
  117         struct ieee80211_amrr *amrr;
  118 
  119         KASSERT(vap->iv_rs == NULL, ("%s called multiple times", __func__));
  120 
  121         nrefs++;                /* XXX locking */
  122         amrr = vap->iv_rs = IEEE80211_MALLOC(sizeof(struct ieee80211_amrr),
  123             M_80211_RATECTL, IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
  124         if (amrr == NULL) {
  125                 if_printf(vap->iv_ifp, "couldn't alloc ratectl structure\n");
  126                 return;
  127         }
  128         amrr->amrr_min_success_threshold = IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD;
  129         amrr->amrr_max_success_threshold = IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD;
  130         amrr_setinterval(vap, 500 /* ms */);
  131         amrr_sysctlattach(vap, vap->iv_sysctl, vap->iv_oid);
  132 }
  133 
  134 static void
  135 amrr_deinit(struct ieee80211vap *vap)
  136 {
  137         IEEE80211_FREE(vap->iv_rs, M_80211_RATECTL);
  138         KASSERT(nrefs > 0, ("imbalanced attach/detach"));
  139         nrefs--;                /* XXX locking */
  140 }
  141 
  142 /*
  143  * Return whether 11n rates are possible.
  144  *
  145  * Some 11n devices may return HT information but no HT rates.
  146  * Thus, we shouldn't treat them as an 11n node.
  147  */
  148 static int
  149 amrr_node_is_11n(struct ieee80211_node *ni)
  150 {
  151 
  152         if (ni->ni_chan == NULL)
  153                 return (0);
  154         if (ni->ni_chan == IEEE80211_CHAN_ANYC)
  155                 return (0);
  156         if (IEEE80211_IS_CHAN_HT(ni->ni_chan) && ni->ni_htrates.rs_nrates == 0)
  157                 return (0);
  158         return (IEEE80211_IS_CHAN_HT(ni->ni_chan));
  159 }
  160 
  161 static void
  162 amrr_node_init(struct ieee80211_node *ni)
  163 {
  164         const struct ieee80211_rateset *rs = NULL;
  165         struct ieee80211vap *vap = ni->ni_vap;
  166         struct ieee80211_amrr *amrr = vap->iv_rs;
  167         struct ieee80211_amrr_node *amn;
  168         uint8_t rate;
  169 
  170         if (!amrr) {
  171                 if_printf(vap->iv_ifp, "ratectl structure was not allocated, "
  172                     "per-node structure allocation skipped\n");
  173                 return;
  174         }
  175 
  176         if (ni->ni_rctls == NULL) {
  177                 ni->ni_rctls = amn = IEEE80211_MALLOC(sizeof(struct ieee80211_amrr_node),
  178                     M_80211_RATECTL, IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
  179                 if (amn == NULL) {
  180                         if_printf(vap->iv_ifp, "couldn't alloc per-node ratectl "
  181                             "structure\n");
  182                         return;
  183                 }
  184         } else
  185                 amn = ni->ni_rctls;
  186         amn->amn_amrr = amrr;
  187         amn->amn_success = 0;
  188         amn->amn_recovery = 0;
  189         amn->amn_txcnt = amn->amn_retrycnt = 0;
  190         amn->amn_success_threshold = amrr->amrr_min_success_threshold;
  191 
  192         /* 11n or not? Pick the right rateset */
  193         if (amrr_node_is_11n(ni)) {
  194                 /* XXX ew */
  195                 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
  196                     "%s: 11n node", __func__);
  197                 rs = (struct ieee80211_rateset *) &ni->ni_htrates;
  198         } else {
  199                 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
  200                     "%s: non-11n node", __func__);
  201                 rs = &ni->ni_rates;
  202         }
  203 
  204         /* Initial rate - lowest */
  205         rate = rs->rs_rates[0];
  206 
  207         /* XXX clear the basic rate flag if it's not 11n */
  208         if (! amrr_node_is_11n(ni))
  209                 rate &= IEEE80211_RATE_VAL;
  210 
  211         /* pick initial rate from the rateset - HT or otherwise */
  212         /* Pick something low that's likely to succeed */
  213         for (amn->amn_rix = rs->rs_nrates - 1; amn->amn_rix > 0;
  214             amn->amn_rix--) {
  215                 /* legacy - anything < 36mbit, stop searching */
  216                 /* 11n - stop at MCS4 */
  217                 if (amrr_node_is_11n(ni)) {
  218                         if ((rs->rs_rates[amn->amn_rix] & 0x1f) < 4)
  219                                 break;
  220                 } else if ((rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL) <= 72)
  221                         break;
  222         }
  223         rate = rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL;
  224 
  225         /* if the rate is an 11n rate, ensure the MCS bit is set */
  226         if (amrr_node_is_11n(ni))
  227                 rate |= IEEE80211_RATE_MCS;
  228 
  229         /* Assign initial rate from the rateset */
  230         ni->ni_txrate = rate;
  231         amn->amn_ticks = ticks;
  232 
  233         /* XXX TODO: we really need a rate-to-string method */
  234         /* XXX TODO: non-11n rate should be divided by two.. */
  235         IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
  236             "AMRR: nrates=%d, initial rate %s%d",
  237             rs->rs_nrates,
  238             amrr_node_is_11n(ni) ? "MCS " : "",
  239             rate & IEEE80211_RATE_VAL);
  240 }
  241 
  242 static void
  243 amrr_node_deinit(struct ieee80211_node *ni)
  244 {
  245         IEEE80211_FREE(ni->ni_rctls, M_80211_RATECTL);
  246 }
  247 
  248 static int
  249 amrr_update(struct ieee80211_amrr *amrr, struct ieee80211_amrr_node *amn,
  250     struct ieee80211_node *ni)
  251 {
  252         int rix = amn->amn_rix;
  253         const struct ieee80211_rateset *rs = NULL;
  254 
  255         KASSERT(is_enough(amn), ("txcnt %d", amn->amn_txcnt));
  256 
  257         /* 11n or not? Pick the right rateset */
  258         if (amrr_node_is_11n(ni)) {
  259                 /* XXX ew */
  260                 rs = (struct ieee80211_rateset *) &ni->ni_htrates;
  261         } else {
  262                 rs = &ni->ni_rates;
  263         }
  264 
  265         /* XXX TODO: we really need a rate-to-string method */
  266         /* XXX TODO: non-11n rate should be divided by two.. */
  267         IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
  268             "AMRR: current rate %d, txcnt=%d, retrycnt=%d",
  269             rs->rs_rates[rix] & IEEE80211_RATE_VAL,
  270             amn->amn_txcnt,
  271             amn->amn_retrycnt);
  272 
  273         /*
  274          * XXX This is totally bogus for 11n, as although high MCS
  275          * rates for each stream may be failing, the next stream
  276          * should be checked.
  277          *
  278          * Eg, if MCS5 is ok but MCS6/7 isn't, and we can go up to
  279          * MCS23, we should skip 6/7 and try 8 onwards.
  280          */
  281         if (is_success(amn)) {
  282                 amn->amn_success++;
  283                 if (amn->amn_success >= amn->amn_success_threshold &&
  284                     rix + 1 < rs->rs_nrates) {
  285                         amn->amn_recovery = 1;
  286                         amn->amn_success = 0;
  287                         rix++;
  288                         /* XXX TODO: we really need a rate-to-string method */
  289                         /* XXX TODO: non-11n rate should be divided by two.. */
  290                         IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
  291                             "AMRR increasing rate %d (txcnt=%d retrycnt=%d)",
  292                             rs->rs_rates[rix] & IEEE80211_RATE_VAL,
  293                             amn->amn_txcnt, amn->amn_retrycnt);
  294                 } else {
  295                         amn->amn_recovery = 0;
  296                 }
  297         } else if (is_failure(amn)) {
  298                 amn->amn_success = 0;
  299                 if (rix > 0) {
  300                         if (amn->amn_recovery) {
  301                                 amn->amn_success_threshold *= 2;
  302                                 if (amn->amn_success_threshold >
  303                                     amrr->amrr_max_success_threshold)
  304                                         amn->amn_success_threshold =
  305                                             amrr->amrr_max_success_threshold;
  306                         } else {
  307                                 amn->amn_success_threshold =
  308                                     amrr->amrr_min_success_threshold;
  309                         }
  310                         rix--;
  311                         /* XXX TODO: we really need a rate-to-string method */
  312                         /* XXX TODO: non-11n rate should be divided by two.. */
  313                         IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
  314                             "AMRR decreasing rate %d (txcnt=%d retrycnt=%d)",
  315                             rs->rs_rates[rix] & IEEE80211_RATE_VAL,
  316                             amn->amn_txcnt, amn->amn_retrycnt);
  317                 }
  318                 amn->amn_recovery = 0;
  319         }
  320 
  321         /* reset counters */
  322         amn->amn_txcnt = 0;
  323         amn->amn_retrycnt = 0;
  324 
  325         return rix;
  326 }
  327 
  328 /*
  329  * Return the rate index to use in sending a data frame.
  330  * Update our internal state if it's been long enough.
  331  * If the rate changes we also update ni_txrate to match.
  332  */
  333 static int
  334 amrr_rate(struct ieee80211_node *ni, void *arg __unused, uint32_t iarg __unused)
  335 {
  336         struct ieee80211_amrr_node *amn = ni->ni_rctls;
  337         struct ieee80211_amrr *amrr;
  338         const struct ieee80211_rateset *rs = NULL;
  339         int rix;
  340 
  341         /* XXX should return -1 here, but drivers may not expect this... */
  342         if (!amn)
  343         {
  344                 ni->ni_txrate = ni->ni_rates.rs_rates[0];
  345                 return 0;
  346         }
  347 
  348         amrr = amn->amn_amrr;
  349 
  350         /* 11n or not? Pick the right rateset */
  351         if (amrr_node_is_11n(ni)) {
  352                 /* XXX ew */
  353                 rs = (struct ieee80211_rateset *) &ni->ni_htrates;
  354         } else {
  355                 rs = &ni->ni_rates;
  356         }
  357 
  358         if (is_enough(amn) && (ticks - amn->amn_ticks) > amrr->amrr_interval) {
  359                 rix = amrr_update(amrr, amn, ni);
  360                 if (rix != amn->amn_rix) {
  361                         /* update public rate */
  362                         ni->ni_txrate = rs->rs_rates[rix];
  363                         /* XXX strip basic rate flag from txrate, if non-11n */
  364                         if (amrr_node_is_11n(ni))
  365                                 ni->ni_txrate |= IEEE80211_RATE_MCS;
  366                         else
  367                                 ni->ni_txrate &= IEEE80211_RATE_VAL;
  368                         amn->amn_rix = rix;
  369                 }
  370                 amn->amn_ticks = ticks;
  371         } else
  372                 rix = amn->amn_rix;
  373         return rix;
  374 }
  375 
  376 /*
  377  * Update statistics with tx complete status.  Ok is non-zero
  378  * if the packet is known to be ACK'd.  Retries has the number
  379  * retransmissions (i.e. xmit attempts - 1).
  380  */
  381 static void
  382 amrr_tx_complete(const struct ieee80211_node *ni,
  383     const struct ieee80211_ratectl_tx_status *status)
  384 {
  385         struct ieee80211_amrr_node *amn = ni->ni_rctls;
  386         int retries;
  387 
  388         if (!amn)
  389                 return;
  390 
  391         retries = 0;
  392         if (status->flags & IEEE80211_RATECTL_STATUS_LONG_RETRY)
  393                 retries = status->long_retries;
  394 
  395         amn->amn_txcnt++;
  396         if (status->status == IEEE80211_RATECTL_TX_SUCCESS)
  397                 amn->amn_success++;
  398         amn->amn_retrycnt += retries;
  399 }
  400 
  401 static void
  402 amrr_tx_update_cb(void *arg, struct ieee80211_node *ni)
  403 {
  404         struct ieee80211_ratectl_tx_stats *stats = arg;
  405         struct ieee80211_amrr_node *amn = ni->ni_rctls;
  406         int txcnt, success, retrycnt;
  407 
  408         if (!amn)
  409                 return;
  410 
  411         txcnt = stats->nframes;
  412         success = stats->nsuccess;
  413         retrycnt = 0;
  414         if (stats->flags & IEEE80211_RATECTL_TX_STATS_RETRIES)
  415                 retrycnt = stats->nretries;
  416 
  417         amn->amn_txcnt += txcnt;
  418         amn->amn_success += success;
  419         amn->amn_retrycnt += retrycnt;
  420 }
  421 
  422 /*
  423  * Set tx count/retry statistics explicitly.  Intended for
  424  * drivers that poll the device for statistics maintained
  425  * in the device.
  426  */
  427 static void
  428 amrr_tx_update(struct ieee80211vap *vap,
  429     struct ieee80211_ratectl_tx_stats *stats)
  430 {
  431 
  432         if (stats->flags & IEEE80211_RATECTL_TX_STATS_NODE)
  433                 amrr_tx_update_cb(stats, stats->ni);
  434         else {
  435                 ieee80211_iterate_nodes_vap(&vap->iv_ic->ic_sta, vap,
  436                     amrr_tx_update_cb, stats);
  437         }
  438 }
  439 
  440 static int
  441 amrr_sysctl_interval(SYSCTL_HANDLER_ARGS)
  442 {
  443         struct ieee80211vap *vap = arg1;
  444         struct ieee80211_amrr *amrr = vap->iv_rs;
  445         int msecs, error;
  446 
  447         if (!amrr)
  448                 return ENOMEM;
  449 
  450         msecs = ticks_to_msecs(amrr->amrr_interval);
  451         error = sysctl_handle_int(oidp, &msecs, 0, req);
  452         if (error || !req->newptr)
  453                 return error;
  454         amrr_setinterval(vap, msecs);
  455         return 0;
  456 }
  457 
  458 static void
  459 amrr_sysctlattach(struct ieee80211vap *vap,
  460     struct sysctl_ctx_list *ctx, struct sysctl_oid *tree)
  461 {
  462         struct ieee80211_amrr *amrr = vap->iv_rs;
  463 
  464         if (!amrr)
  465                 return;
  466 
  467         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
  468             "amrr_rate_interval", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
  469             vap, 0, amrr_sysctl_interval, "I", "amrr operation interval (ms)");
  470         /* XXX bounds check values */
  471         SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
  472             "amrr_max_sucess_threshold", CTLFLAG_RW,
  473             &amrr->amrr_max_success_threshold, 0, "");
  474         SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
  475             "amrr_min_sucess_threshold", CTLFLAG_RW,
  476             &amrr->amrr_min_success_threshold, 0, "");
  477 }
  478 
  479 static void
  480 amrr_print_node_rate(struct ieee80211_amrr_node *amn,
  481     struct ieee80211_node *ni, struct sbuf *s)
  482 {
  483         int rate;
  484         struct ieee80211_rateset *rs;
  485 
  486         if (amrr_node_is_11n(ni)) {
  487                 rs = (struct ieee80211_rateset *) &ni->ni_htrates;
  488                 rate = rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL;
  489                 sbuf_printf(s, "rate: MCS %d\n", rate);
  490         } else {
  491                 rs = &ni->ni_rates;
  492                 rate = rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL;
  493                 sbuf_printf(s, "rate: %d Mbit\n", rate / 2);
  494         }
  495 }
  496 
  497 static void
  498 amrr_node_stats(struct ieee80211_node *ni, struct sbuf *s)
  499 {
  500         struct ieee80211_amrr_node *amn = ni->ni_rctls;
  501 
  502         /* XXX TODO: check locking? */
  503 
  504         if (!amn)
  505                 return;
  506 
  507         amrr_print_node_rate(amn, ni, s);
  508         sbuf_printf(s, "ticks: %d\n", amn->amn_ticks);
  509         sbuf_printf(s, "txcnt: %u\n", amn->amn_txcnt);
  510         sbuf_printf(s, "success: %u\n", amn->amn_success);
  511         sbuf_printf(s, "success_threshold: %u\n", amn->amn_success_threshold);
  512         sbuf_printf(s, "recovery: %u\n", amn->amn_recovery);
  513         sbuf_printf(s, "retry_cnt: %u\n", amn->amn_retrycnt);
  514 }

Cache object: 980df390b1b476e371434cef0ca5db26


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.