pkt_sched: sch_qfq: remove forward declaration of qfq_update_agg_ts

This patch removes the forward declaration of qfq_update_agg_ts, by moving
the definition of the function above its first call. This patch also
removes a useless forward declaration of qfq_schedule_agg.

Reported-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 55 insertions, 63 deletions

diff --git a/net/sched/sch_qfq.c b/net/sched/sch_qfq.c
index 8d86a8b5522a..a7ab323849b6 100644
--- a/net/sched/sch_qfq.c
+++ b/net/sched/sch_qfq.c
@@ -1010,9 +1010,61 @@ static inline void charge_actual_service(struct qfq_aggregate *agg)
         agg->F = agg->S + (u64)service_received * agg->inv_w;
 }
 
-static inline void qfq_update_agg_ts(struct qfq_sched *q,
-                                     struct qfq_aggregate *agg,
-                                     enum update_reason reason);
+/* Assign a reasonable start time for a new aggregate in group i.
+ * Admissible values for \hat(F) are multiples of \sigma_i
+ * no greater than V+\sigma_i . Larger values mean that
+ * we had a wraparound so we consider the timestamp to be stale.
+ *
+ * If F is not stale and F >= V then we set S = F.
+ * Otherwise we should assign S = V, but this may violate
+ * the ordering in EB (see [2]). So, if we have groups in ER,
+ * set S to the F_j of the first group j which would be blocking us.
+ * We are guaranteed not to move S backward because
+ * otherwise our group i would still be blocked.
+ */
+static void qfq_update_start(struct qfq_sched *q, struct qfq_aggregate *agg)
+{
+        unsigned long mask;
+        u64 limit, roundedF;
+        int slot_shift = agg->grp->slot_shift;
+
+        roundedF = qfq_round_down(agg->F, slot_shift);
+        limit = qfq_round_down(q->V, slot_shift) + (1ULL << slot_shift);
+
+        if (!qfq_gt(agg->F, q->V) || qfq_gt(roundedF, limit)) {
+                /* timestamp was stale */
+                mask = mask_from(q->bitmaps[ER], agg->grp->index);
+                if (mask) {
+                        struct qfq_group *next = qfq_ffs(q, mask);
+                        if (qfq_gt(roundedF, next->F)) {
+                                if (qfq_gt(limit, next->F))
+                                        agg->S = next->F;
+                                else /* preserve timestamp correctness */
+                                        agg->S = limit;
+                                return;
+                        }
+                }
+                agg->S = q->V;
+        } else  /* timestamp is not stale */
+                agg->S = agg->F;
+}
+
+/* Update the timestamps of agg before scheduling/rescheduling it for
+ * service.  In particular, assign to agg->F its maximum possible
+ * value, i.e., the virtual finish time with which the aggregate
+ * should be labeled if it used all its budget once in service.
+ */
+static inline void
+qfq_update_agg_ts(struct qfq_sched *q,
+                    struct qfq_aggregate *agg, enum update_reason reason)
+{
+        if (reason != requeue)
+                qfq_update_start(q, agg);
+        else /* just charge agg for the service received */
+                agg->S = agg->F;
+
+        agg->F = agg->S + (u64)agg->budgetmax * agg->inv_w;
+}
 
 static void qfq_schedule_agg(struct qfq_sched *q, struct qfq_aggregate *agg);
 
@@ -1135,66 +1187,6 @@ static struct qfq_aggregate *qfq_choose_next_agg(struct qfq_sched *q)
         return agg;
 }
 
-/*
- * Assign a reasonable start time for a new aggregate in group i.
- * Admissible values for \hat(F) are multiples of \sigma_i
- * no greater than V+\sigma_i . Larger values mean that
- * we had a wraparound so we consider the timestamp to be stale.
- *
- * If F is not stale and F >= V then we set S = F.
- * Otherwise we should assign S = V, but this may violate
- * the ordering in EB (see [2]). So, if we have groups in ER,
- * set S to the F_j of the first group j which would be blocking us.
- * We are guaranteed not to move S backward because
- * otherwise our group i would still be blocked.
- */
-static void qfq_update_start(struct qfq_sched *q, struct qfq_aggregate *agg)
-{
-        unsigned long mask;
-        u64 limit, roundedF;
-        int slot_shift = agg->grp->slot_shift;
-
-        roundedF = qfq_round_down(agg->F, slot_shift);
-        limit = qfq_round_down(q->V, slot_shift) + (1ULL << slot_shift);
-
-        if (!qfq_gt(agg->F, q->V) || qfq_gt(roundedF, limit)) {
-                /* timestamp was stale */
-                mask = mask_from(q->bitmaps[ER], agg->grp->index);
-                if (mask) {
-                        struct qfq_group *next = qfq_ffs(q, mask);
-                        if (qfq_gt(roundedF, next->F)) {
-                                if (qfq_gt(limit, next->F))
-                                        agg->S = next->F;
-                                else /* preserve timestamp correctness */
-                                        agg->S = limit;
-                                return;
-                        }
-                }
-                agg->S = q->V;
-        } else  /* timestamp is not stale */
-                agg->S = agg->F;
-}
-
-/*
- * Update the timestamps of agg before scheduling/rescheduling it for
- * service.  In particular, assign to agg->F its maximum possible
- * value, i.e., the virtual finish time with which the aggregate
- * should be labeled if it used all its budget once in service.
- */
-static inline void
-qfq_update_agg_ts(struct qfq_sched *q,
-                    struct qfq_aggregate *agg, enum update_reason reason)
-{
-        if (reason != requeue)
-                qfq_update_start(q, agg);
-        else /* just charge agg for the service received */
-                agg->S = agg->F;
-
-        agg->F = agg->S + (u64)agg->budgetmax * agg->inv_w;
-}
-
-static void qfq_schedule_agg(struct qfq_sched *, struct qfq_aggregate *);
-
 static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
         struct qfq_sched *q = qdisc_priv(sch);