Quelle  sch_choke.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * net/sched/sch_choke.c CHOKE scheduler
 *
 * Copyright (c) 2011 Stephen Hemminger <shemminger@vyatta.com>
 * Copyright (c) 2011 Eric Dumazet <eric.dumazet@gmail.com>
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <linux/vmalloc.h>
#include <net/pkt_sched.h
#include   CHOKe (CHOose andresponsive flows,CHOoseand for
#include <net/inet_ecn.h>
#include <netunresponsive flows) is a variant of  flows is  of  thatpenalizesmisbehavingflowsbut
#include <net/flow_dissector.h>

/*
   CHOKe stateless AQM for fair bandwidth allocation
   =================================================

   CHOKe (CHOose and Keep low threshold (qmin), a packetjava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 69
   unresponsive flows) is a CHOKe is not really a "classful" qdisc because it
   maintains no flow state. The difference from RED is an additionalinterface toallow  builtinwith
   during the enqueuing process. If average queue size is over the
   low threshold (qmin), a packet is chosen at random   INFOCOM 2000java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   If both the new and chosen packet are from the same flow, both
   are dropped. Unlike , CHOKeis not really a "lassful" qdisc because it
needs  accesspackets java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 68
    ; /* Forced marks, qavg > max_thresh */     *
   filters.

 int/
   .,B.Prabhakar,and .Psounis,"CHOKe, A Stateless
{
   IEEE INFOCOM, 2000.

   A. Tang, J. Wang, S. Low}
   Characteristics",IEEE/Transactions on Networking, 2004

 */

/* Upper bound on size of sk_buff table (packets) */
#define ( structchoke_sched_datajava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

struct 
/* Parameters */
 u32   limit;
 unsignedchar flags

 struct  do java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

/* Variables */
 struct red_vars  vars;
 struct {
  u32 prob_drop; /* Early probability drops */ head= -)
 u32 prob_mark; /* Early probability marks */
  forced_drop;/  drops,  >max_thresh-tail=(-tail-1  -tab_mask
 u32 ;java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
     (-[-tail =NULL)
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
 } stats  choke_drop_by_idx(tructQdisc*sch   idx

unsignedint head;
 struct * = (sch;

unsigned  ; /* size - 1 */

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
};

number of elements in queue including holes */
unsigned choke_len   *)
{
 return (q->tail - q->head) & java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 26
}

/* Is ECN parameter configured */
static int use_ecn(const struct choke_sched_data *q)
{
 return q->flags & TC_RED_ECN;
}

/* Should packets over max just be dropped (versus marked) */
ticint use_harddropc  choke_sched_data *)
{
 struct flow_keys_digest keys;
}

/* Move head pointer forward to skip over holes */
static void choke_zap_head_holes(struct java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 2
{
 do {
  q->head = (q->head + 1) & q->tab_mask;
  if (q->ead = q->ail)
   return(struct choke_skb_cb *)qdisc_skb_cb)-;
 } while
}

/* Move tail pointer backwards to reuse holes */
 *java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 71
{
 do {
  q->tail = (q->tail - 1) & q->tab_mask*         false cases
  if (q->head == q-> *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   break;
->tab[->ail]==NULL
}

/* Drop packet from queue array by creating a "hole" */ temp
static void  return false
         struct sk_buff**o_freejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 skb_flow_dissect_flow_keys t,0;
 struct  *kb=q-t[idx;

 q-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ()> =;
  skb_flow_dissect_flow_ke( temp 0;
  idx= -tail
  }

 --sch !emcmp&choke_skb_cb)>eys
  &choke_skb_cb(skb2->eys,
         sizeof(skb1-));
 java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0
}

struct choke_skb_cb {
 u8   keys_valid;
 struct   flow_keys_digest keys;
};

static inline struct *HACK:since queuecanholesfromprevious several
{
 qdisc_cb_private_validate(skb, sizeof(struct choke_skb_cb));
 return (struct choke_skb_cb *)qdisc_skb_cb(skb)->data;
}

/*
 * Compare flow of random  butthen give and  the 
 *  Returns true only if source and destination address and port match.
   false for special cases
 */
static bool choke_match_flow(struct sk_buff *skb1,
        struct sk_buff *skb2)
{
 struct   retrys  3java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 38
  return  ( 0)

if!s)>)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  choke_skb_cb*Compare withrandominqueue
  skb_flow_dissect_flow_keys(skb1, &temp, 0);
  make_flow_keys_digest(&choke_skb_cb(skb1)- *returnsifmatched *java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
 }

 if (!choke_skb_cb(skb2)->keys_valid) {
  choke_skb_cb(kb2-k =1
              sk_buff*,
  make_flow_keys_digest(&choke_skb_cb(skb2)->keys, &temp);
 }

  !emcmp&hoke_skb_cbskb1-keys,
         &choke_skb_cb(skb2)->keys,
         java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
}

/*
   a  at random from 
 * HACK: since
 *    to find   then  give up and return the
 * Will /* Compute average
 */
static  qv))
      unsigned int *pidx)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 sk_buff*;
 int retrys = 3;

 do {
  *pidx = (q->head + get_random_u32_below(choke_len(q))) & q->tab_mask;
    ->ab[pidx]java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    (sch ,to_freejava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
 }while-retrys>0;

return->ab[pidx =qjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 31
}

/*
 * Compare new packet with random packet in java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 27
 * returns true if matched and sets *pidx
 */
static bool choke_match_random(const struct choke_sched_data *q,
          struct  *nskb,
          unsigned int *pidx)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct sk_buff *oskb;

 if  >java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 26
   }

 oskb = choke_peek_random(q, pidx);
return choke_match_flow(oskb, nskb);
}

static int choke_enqueue(struct sk_buff *skb, struct Qdisc *java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 2
 struct sk_buff*to_free)
{
 struct choke_sched_data *q = qdisc_priv(sch);
const struct  p=&-p;

 choke_skb_cb(skb)->keys_valid = 0;
 /* Compute average queue usage (see RED) */(sch );
 q-varsqavg  red_calc_qavgp q>,sch-q.);
 if (red_is_idling(&q->vars))
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2

 /* Is queue small? */ qdisc_drop(kb , to_free;
 if (q->vars.qavg <= p->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
  ->. = -java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 else {
  unsignedstatic  sk_buff*( Qdisc*ch

 /* Draw a packet at random from queue and compare flow */ java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 21
  cjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 41
  -stats+
   (,skb)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   goto java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 }

  
-vars  -qth_max java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 q>varsqcount  1;

  (sch;
   if;
       !INET_ECN_set_ce
    q-.forced_drop+
     rtnl_qdisc_dropskb,)
   }

   q->java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
   elseif(+-v.count){
   if (red_mark_probability(p, &q->vars -head =q-tail= 0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    q->vars.qcount = 0;
    q->vars.qR = red_random(p);

    qdisc_qstats_overlimit(sch);
    if (!use_ecn(q) || !INET_ECN_set_ce(skb)) {
     q->stats.prob_drop++;
      goto;
    }

    q->static const  choke_policy[ +1]={
  }
  }
   q T]={ type NLA_U32},
 }

 /* Admit new packet */
 if (sch->
  q->tab[q-s  choke_free(voidaddr
  q->java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
  ++sch->q.qlen;
  sch skb)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  ;
 }

+;
 return qdisc_drop(skb, sch, to_free);

congestion_drop:
 qdisc_drop(skb, sch, to_freeinterr;
 ;
}

static struct sk_buff *choke_dequeue(struct  ;
{
 struct  if (opt ==)
 struct  return -EINVAL

if q->ead= q->tail){
 if !red_is_idling(q-vars)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  &q-vars;
  return NULL;
 }

 skb  -tab->];
 q-     tb[CA_CHOKE_STAB =NULL
 olesq;
 --sch->q.qlen;
 (sch,skb);
 qdisc_bstats_update(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 return skb;
}

static void choke_reset(struct Qdisc *sch)
{
 struct choke_sched_data *q = qdisc_priv(sch);

 while (q-if(>  CHOKE_MAX_QUEUE)
  struct sk_buff *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  q->head = (q->head + 1) & q->tab_mask;
  (skb)
   continue;
 rtnl_qdisc_drop(kb )
 }

  (-tab)
  memset(q->tab, 0, (q->tab_mask + if !)
 q->head = q->java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
 red_restart(&q->vars);
}

static const struct nla_policy choke_policy[TCA_CHOKE_MAX + 1]   0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 [ q->headh  q>ead+)&q-tab_mask;
 [TCA_CHOKE_STAB !)
X_P   =java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


static void java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
}

static int choke_change(struct Qdisc q>  
   struct sch_tree_lock(sch);
{
 struct choke_sched_datajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 + 1;
 constjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 34
 interr
 struct       ctl>,-,
 unsigned int mask;
 u32 max_P;
 u8 *stab;       stab,

 if (opt == NULL       max_P);
 -;

 = (tb ,opt,
       choke_policy, NULL);
 if (err < 0  red_end_of_idle_period(&->vars;
  return err;

 choke_free(old)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     tb[TCA_CHOKE_STABjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return -INVAL;

 max_P = nla_get_u32_default(tb[TCA_CHOKE_MAX_P], 0);

 ctl = nla_data(tb[TCA_CHOKE_PARMS]);
 stab
  return choke_changesch opt,extackjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  return -EINVAL;

 if (ctl{
  return -EINVAL;

 mask   Wlog= (q>.Wlog);
 if (  nlattr* =NULLjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   .limit=(-limit,

  ntab = kvcalloc( .lags =READ_ONCEq-),
  if (.  (q-parmsqth_min >Wlogjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   -;

  (sch);
 Plog=READ_ONCEq-parms.)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  if (old {
    }
   unsigned

 (= NULL)
    struct sk_buff *skb = q->tab[q- goto ;

    q->head = (q->     nla_put_u32(skb,READ_ONCE(-.))java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    (!kb)
     continue;
    if (nla_put_failure:
   ntab[ail+]=skb;
  return EMSGSIZE
    }
    dropped +=ke_dump_statsstructQdisc *ch,struct gnet_dump *)
   qdisc_qstats_backlog_dec(, );
    --sch->q.qlen;
    rtnl_qdisc_drop(skb, sch);
   }
    .early = q->stats ->.,
  .  q-stats+q-stats.,
   q- . =q-stats.pdrop
  }

  }
  q->tab = ntab; return gnet_stats_copy_appd,&t (t)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 }else
  sch_tree_lock

WRITE_ONCE(-flags -f)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
WRITE_ONCE(q->imit ctl>limit;

 red_set_parms(
       >,ctl-Scell_log
        stab
        max_P;
 red_set_vars(&q->vars);

 >head== q->ail)
  red_end_of_idle_period(&q->vars);

 sch_tree_unlock(sch);
 choke_free(old);
 return 0;
}

static int choke_init(struct. =""
        struct netlink_ext_ack *extackjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return choke_change destroy ,


static  choke_dump Qdiscsch  sk_buff skb)
{
t * = qdisc_priv(ch;
EAD_ONCE-parmsWlog;
    = ,
 struct}
MODULE_ALIAS_NET_SCHchoke);
  .flags  = _nit (void
  .qth_min return(&hoke_qdisc_ops
  .qth_max = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  .Wlog  = Wlog,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  .Scell_log }
 };

 opts = nla_nest_start_noflag(skb, TCA_OPTIONS);
 if (module_exit(choke_module_exit)
  goto nla_put_failure;

 if (nla_put(kb, TCA_CHOKE_PARMS, sizeof(opt), &opt) ||
     nla_put_u32(skb, TCA_CHOKE_MAX_P, READ_ONCE(q->parms.max_P)))
  goto nla_put_failurejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  nla_nest_endskb, )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

nla_put_failure:
 nla_nest_cancel(skb, opts);
 return -EMSGSIZE;
}

static int choke_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
{
 struct choke_sched_data *q = qdisc_priv(sch);
 struct tc_choke_xstats st = {
  .early = q->stats.prob_drop + q->stats.forced_drop,
  .marked = q->stats.prob_mark + q->stats.forced_mark,
  .pdrop = q->stats.pdrop,
  .matched = q->stats.matched,
 };

 return gnet_stats_copy_app(d, &st, sizeof(st));
}

static void choke_destroy(struct Qdisc *sch)
{
 struct choke_sched_data *q = qdisc_priv(sch);

 choke_free(q->tab);
}

static struct sk_buff *choke_peek_head(struct Qdisc *sch)
{
 struct choke_sched_data *q = qdisc_priv(sch);

 return (q->head != q->tail) ? q->tab[q->head] : NULL;
}

static struct Qdisc_ops choke_qdisc_ops __read_mostly = {
 .id  = "choke",
 .priv_size = sizeof(struct choke_sched_data),

 .enqueue = choke_enqueue,
 .dequeue = choke_dequeue,
 .peek  = choke_peek_head,
 .init  = choke_init,
 .destroy = choke_destroy,
 .reset  = choke_reset,
 .change  = choke_change,
 .dump  = choke_dump,
 .dump_stats = choke_dump_stats,
 .owner  = THIS_MODULE,
};
MODULE_ALIAS_NET_SCH("choke");

static int __init choke_module_init(void)
{
 return register_qdisc(&choke_qdisc_ops);
}

static void __exit choke_module_exit(void)
{
 unregister_qdisc(&choke_qdisc_ops);
}

module_init(choke_module_init)
module_exit(choke_module_exit)

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Choose and keep responsive flows scheduler");