cfg80211: wext: really don't store non-WEP keys

[cascardo/linux.git] / net / sched / sch_hfsc.c

diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 3ddc7bd..000f1d3 100644 (file)
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -142,8 +142,6 @@ struct hfsc_class {
                                           link-sharing, max(myf, cfmin) */
        u64     cl_myf;                 /* my fit-time (calculated from this
                                           class's own upperlimit curve) */
-       u64     cl_myfadj;              /* my fit-time adjustment (to cancel
-                                          history dependence) */
        u64     cl_cfmin;               /* earliest children's fit-time (used
                                           with cl_myf to obtain cl_f) */
        u64     cl_cvtmin;              /* minimal virtual time among the
@@ -151,11 +149,8 @@ struct hfsc_class {
                                           (monotonic within a period) */
        u64     cl_vtadj;               /* intra-period cumulative vt
                                           adjustment */
-       u64     cl_vtoff;               /* inter-period cumulative vt offset */
-       u64     cl_cvtmax;              /* max child's vt in the last period */
-       u64     cl_cvtoff;              /* cumulative cvtmax of all periods */
-       u64     cl_pcvtoff;             /* parent's cvtoff at initialization
-                                          time */
+       u64     cl_cvtoff;              /* largest virtual time seen among
+                                          the children */
 
        struct internal_sc cl_rsc;      /* internal real-time service curve */
        struct internal_sc cl_fsc;      /* internal fair service curve */
@@ -701,28 +696,16 @@ init_vf(struct hfsc_class *cl, unsigned int len)
                        } else {
                                /*
                                 * first child for a new parent backlog period.
-                                * add parent's cvtmax to cvtoff to make a new
-                                * vt (vtoff + vt) larger than the vt in the
-                                * last period for all children.
+                                * initialize cl_vt to the highest value seen
+                                * among the siblings. this is analogous to
+                                * what cur_time would provide in realtime case.
                                 */
-                               vt = cl->cl_parent->cl_cvtmax;
-                               cl->cl_parent->cl_cvtoff += vt;
-                               cl->cl_parent->cl_cvtmax = 0;
+                               cl->cl_vt = cl->cl_parent->cl_cvtoff;
                                cl->cl_parent->cl_cvtmin = 0;
-                               cl->cl_vt = 0;
                        }
 
-                       cl->cl_vtoff = cl->cl_parent->cl_cvtoff -
-                                                       cl->cl_pcvtoff;
-
                        /* update the virtual curve */
-                       vt = cl->cl_vt + cl->cl_vtoff;
-                       rtsc_min(&cl->cl_virtual, &cl->cl_fsc, vt,
-                                                     cl->cl_total);
-                       if (cl->cl_virtual.x == vt) {
-                               cl->cl_virtual.x -= cl->cl_vtoff;
-                               cl->cl_vtoff = 0;
-                       }
+                       rtsc_min(&cl->cl_virtual, &cl->cl_fsc, cl->cl_vt, cl->cl_total);
                        cl->cl_vtadj = 0;
 
                        cl->cl_vtperiod++;  /* increment vt period */
@@ -745,7 +728,6 @@ init_vf(struct hfsc_class *cl, unsigned int len)
                                /* compute myf */
                                cl->cl_myf = rtsc_y2x(&cl->cl_ulimit,
                                                      cl->cl_total);
-                               cl->cl_myfadj = 0;
                        }
                }
 
@@ -779,8 +761,7 @@ update_vf(struct hfsc_class *cl, unsigned int len, u64 cur_time)
                        go_passive = 0;
 
                /* update vt */
-               cl->cl_vt = rtsc_y2x(&cl->cl_virtual, cl->cl_total)
-                           - cl->cl_vtoff + cl->cl_vtadj;
+               cl->cl_vt = rtsc_y2x(&cl->cl_virtual, cl->cl_total) + cl->cl_vtadj;
 
                /*
                 * if vt of the class is smaller than cvtmin,
@@ -795,9 +776,9 @@ update_vf(struct hfsc_class *cl, unsigned int len, u64 cur_time)
                if (go_passive) {
                        /* no more active child, going passive */
 
-                       /* update cvtmax of the parent class */
-                       if (cl->cl_vt > cl->cl_parent->cl_cvtmax)
-                               cl->cl_parent->cl_cvtmax = cl->cl_vt;
+                       /* update cvtoff of the parent class */
+                       if (cl->cl_vt > cl->cl_parent->cl_cvtoff)
+                               cl->cl_parent->cl_cvtoff = cl->cl_vt;
 
                        /* remove this class from the vt tree */
                        vttree_remove(cl);
@@ -813,9 +794,10 @@ update_vf(struct hfsc_class *cl, unsigned int len, u64 cur_time)
 
                /* update f */
                if (cl->cl_flags & HFSC_USC) {
+                       cl->cl_myf = rtsc_y2x(&cl->cl_ulimit, cl->cl_total);
+#if 0
                        cl->cl_myf = cl->cl_myfadj + rtsc_y2x(&cl->cl_ulimit,
                                                              cl->cl_total);
-#if 0
                        /*
                         * This code causes classes to stay way under their
                         * limit when multiple classes are used at gigabit
@@ -940,7 +922,7 @@ static void
 hfsc_change_fsc(struct hfsc_class *cl, struct tc_service_curve *fsc)
 {
        sc2isc(fsc, &cl->cl_fsc);
-       rtsc_init(&cl->cl_virtual, &cl->cl_fsc, cl->cl_vtoff + cl->cl_vt, cl->cl_total);
+       rtsc_init(&cl->cl_virtual, &cl->cl_fsc, cl->cl_vt, cl->cl_total);
        cl->cl_flags |= HFSC_FSC;
 }
 
@@ -1094,7 +1076,6 @@ hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
        if (parent->level == 0)
                hfsc_purge_queue(sch, parent);
        hfsc_adjust_levels(parent);
-       cl->cl_pcvtoff = parent->cl_cvtoff;
        sch_tree_unlock(sch);
 
        qdisc_class_hash_grow(sch, &q->clhash);
@@ -1482,16 +1463,12 @@ hfsc_reset_class(struct hfsc_class *cl)
        cl->cl_e            = 0;
        cl->cl_vt           = 0;
        cl->cl_vtadj        = 0;
-       cl->cl_vtoff        = 0;
        cl->cl_cvtmin       = 0;
-       cl->cl_cvtmax       = 0;
        cl->cl_cvtoff       = 0;
-       cl->cl_pcvtoff      = 0;
        cl->cl_vtperiod     = 0;
        cl->cl_parentperiod = 0;
        cl->cl_f            = 0;
        cl->cl_myf          = 0;
-       cl->cl_myfadj       = 0;
        cl->cl_cfmin        = 0;
        cl->cl_nactive      = 0;