2 * net/sched/sch_fq.c Fair Queue Packet Scheduler (per flow pacing)
4 * Copyright (C) 2013-2015 Eric Dumazet <edumazet@google.com>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
11 * Meant to be mostly used for locally generated traffic :
12 * Fast classification depends on skb->sk being set before reaching us.
13 * If not, (router workload), we use rxhash as fallback, with 32 bits wide hash.
14 * All packets belonging to a socket are considered as a 'flow'.
16 * Flows are dynamically allocated and stored in a hash table of RB trees
17 * They are also part of one Round Robin 'queues' (new or old flows)
19 * Burst avoidance (aka pacing) capability :
21 * Transport (eg TCP) can set in sk->sk_pacing_rate a rate, enqueue a
22 * bunch of packets, and this packet scheduler adds delay between
23 * packets to respect rate limitation.
26 * - lookup one RB tree (out of 1024 or more) to find the flow.
27 * If non existent flow, create it, add it to the tree.
28 * Add skb to the per flow list of skb (fifo).
29 * - Use a special fifo for high prio packets
31 * dequeue() : serves flows in Round Robin
32 * Note : When a flow becomes empty, we do not immediately remove it from
33 * rb trees, for performance reasons (its expected to send additional packets,
34 * or SLAB cache will reuse socket for another flow)
37 #include <linux/module.h>
38 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/jiffies.h>
41 #include <linux/string.h>
43 #include <linux/errno.h>
44 #include <linux/init.h>
45 #include <linux/skbuff.h>
46 #include <linux/slab.h>
47 #include <linux/rbtree.h>
48 #include <linux/hash.h>
49 #include <linux/prefetch.h>
50 #include <linux/vmalloc.h>
51 #include <net/netlink.h>
52 #include <net/pkt_sched.h>
54 #include <net/tcp_states.h>
58 * Per flow structure, dynamically allocated
61 struct sk_buff
*head
; /* list of skbs for this flow : first skb */
63 struct sk_buff
*tail
; /* last skb in the list */
64 unsigned long age
; /* jiffies when flow was emptied, for gc */
66 struct rb_node fq_node
; /* anchor in fq_root[] trees */
68 int qlen
; /* number of packets in flow queue */
70 u32 socket_hash
; /* sk_hash */
71 struct fq_flow
*next
; /* next pointer in RR lists, or &detached */
73 struct rb_node rate_node
; /* anchor in q->delayed tree */
78 struct fq_flow
*first
;
82 struct fq_sched_data
{
83 struct fq_flow_head new_flows
;
85 struct fq_flow_head old_flows
;
87 struct rb_root delayed
; /* for rate limited flows */
88 u64 time_next_delayed_flow
;
90 struct fq_flow internal
; /* for non classified or high prio packets */
93 u32 flow_refill_delay
;
94 u32 flow_max_rate
; /* optional max rate per flow */
95 u32 flow_plimit
; /* max packets per flow */
96 u32 orphan_mask
; /* mask for orphaned skb */
97 struct rb_root
*fq_root
;
106 u64 stat_internal_packets
;
107 u64 stat_tcp_retrans
;
109 u64 stat_flows_plimit
;
110 u64 stat_pkts_too_long
;
111 u64 stat_allocation_errors
;
112 struct qdisc_watchdog watchdog
;
115 /* special value to mark a detached flow (not on old/new list) */
116 static struct fq_flow detached
, throttled
;
118 static void fq_flow_set_detached(struct fq_flow
*f
)
124 static bool fq_flow_is_detached(const struct fq_flow
*f
)
126 return f
->next
== &detached
;
129 static void fq_flow_set_throttled(struct fq_sched_data
*q
, struct fq_flow
*f
)
131 struct rb_node
**p
= &q
->delayed
.rb_node
, *parent
= NULL
;
137 aux
= container_of(parent
, struct fq_flow
, rate_node
);
138 if (f
->time_next_packet
>= aux
->time_next_packet
)
139 p
= &parent
->rb_right
;
141 p
= &parent
->rb_left
;
143 rb_link_node(&f
->rate_node
, parent
, p
);
144 rb_insert_color(&f
->rate_node
, &q
->delayed
);
145 q
->throttled_flows
++;
148 f
->next
= &throttled
;
149 if (q
->time_next_delayed_flow
> f
->time_next_packet
)
150 q
->time_next_delayed_flow
= f
->time_next_packet
;
154 static struct kmem_cache
*fq_flow_cachep __read_mostly
;
156 static void fq_flow_add_tail(struct fq_flow_head
*head
, struct fq_flow
*flow
)
159 head
->last
->next
= flow
;
166 /* limit number of collected flows per round */
168 #define FQ_GC_AGE (3*HZ)
170 static bool fq_gc_candidate(const struct fq_flow
*f
)
172 return fq_flow_is_detached(f
) &&
173 time_after(jiffies
, f
->age
+ FQ_GC_AGE
);
176 static void fq_gc(struct fq_sched_data
*q
,
177 struct rb_root
*root
,
180 struct fq_flow
*f
, *tofree
[FQ_GC_MAX
];
181 struct rb_node
**p
, *parent
;
189 f
= container_of(parent
, struct fq_flow
, fq_node
);
193 if (fq_gc_candidate(f
)) {
195 if (fcnt
== FQ_GC_MAX
)
200 p
= &parent
->rb_right
;
202 p
= &parent
->rb_left
;
206 q
->inactive_flows
-= fcnt
;
207 q
->stat_gc_flows
+= fcnt
;
209 struct fq_flow
*f
= tofree
[--fcnt
];
211 rb_erase(&f
->fq_node
, root
);
212 kmem_cache_free(fq_flow_cachep
, f
);
216 static struct fq_flow
*fq_classify(struct sk_buff
*skb
, struct fq_sched_data
*q
)
218 struct rb_node
**p
, *parent
;
219 struct sock
*sk
= skb
->sk
;
220 struct rb_root
*root
;
223 /* warning: no starvation prevention... */
224 if (unlikely((skb
->priority
& TC_PRIO_MAX
) == TC_PRIO_CONTROL
))
227 /* SYNACK messages are attached to a TCP_NEW_SYN_RECV request socket
228 * or a listener (SYNCOOKIE mode)
229 * 1) request sockets are not full blown,
230 * they do not contain sk_pacing_rate
231 * 2) They are not part of a 'flow' yet
232 * 3) We do not want to rate limit them (eg SYNFLOOD attack),
233 * especially if the listener set SO_MAX_PACING_RATE
234 * 4) We pretend they are orphaned
236 if (!sk
|| sk_listener(sk
)) {
237 unsigned long hash
= skb_get_hash(skb
) & q
->orphan_mask
;
239 /* By forcing low order bit to 1, we make sure to not
240 * collide with a local flow (socket pointers are word aligned)
242 sk
= (struct sock
*)((hash
<< 1) | 1UL);
246 root
= &q
->fq_root
[hash_32((u32
)(long)sk
, q
->fq_trees_log
)];
248 if (q
->flows
>= (2U << q
->fq_trees_log
) &&
249 q
->inactive_flows
> q
->flows
/2)
257 f
= container_of(parent
, struct fq_flow
, fq_node
);
259 /* socket might have been reallocated, so check
260 * if its sk_hash is the same.
261 * It not, we need to refill credit with
264 if (unlikely(skb
->sk
&&
265 f
->socket_hash
!= sk
->sk_hash
)) {
266 f
->credit
= q
->initial_quantum
;
267 f
->socket_hash
= sk
->sk_hash
;
268 f
->time_next_packet
= 0ULL;
273 p
= &parent
->rb_right
;
275 p
= &parent
->rb_left
;
278 f
= kmem_cache_zalloc(fq_flow_cachep
, GFP_ATOMIC
| __GFP_NOWARN
);
280 q
->stat_allocation_errors
++;
283 fq_flow_set_detached(f
);
286 f
->socket_hash
= sk
->sk_hash
;
287 f
->credit
= q
->initial_quantum
;
289 rb_link_node(&f
->fq_node
, parent
, p
);
290 rb_insert_color(&f
->fq_node
, root
);
298 /* remove one skb from head of flow queue */
299 static struct sk_buff
*fq_dequeue_head(struct Qdisc
*sch
, struct fq_flow
*flow
)
301 struct sk_buff
*skb
= flow
->head
;
304 flow
->head
= skb
->next
;
307 qdisc_qstats_backlog_dec(sch
, skb
);
313 /* We might add in the future detection of retransmits
314 * For the time being, just return false
316 static bool skb_is_retransmit(struct sk_buff
*skb
)
321 /* add skb to flow queue
322 * flow queue is a linked list, kind of FIFO, except for TCP retransmits
323 * We special case tcp retransmits to be transmitted before other packets.
324 * We rely on fact that TCP retransmits are unlikely, so we do not waste
325 * a separate queue or a pointer.
326 * head-> [retrans pkt 1]
331 * tail-> [ normal pkt 4]
333 static void flow_queue_add(struct fq_flow
*flow
, struct sk_buff
*skb
)
335 struct sk_buff
*prev
, *head
= flow
->head
;
343 if (likely(!skb_is_retransmit(skb
))) {
344 flow
->tail
->next
= skb
;
349 /* This skb is a tcp retransmit,
350 * find the last retrans packet in the queue
353 while (skb_is_retransmit(head
)) {
359 if (!prev
) { /* no rtx packet in queue, become the new head */
360 skb
->next
= flow
->head
;
363 if (prev
== flow
->tail
)
366 skb
->next
= prev
->next
;
371 static int fq_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
373 struct fq_sched_data
*q
= qdisc_priv(sch
);
376 if (unlikely(sch
->q
.qlen
>= sch
->limit
))
377 return qdisc_drop(skb
, sch
);
379 f
= fq_classify(skb
, q
);
380 if (unlikely(f
->qlen
>= q
->flow_plimit
&& f
!= &q
->internal
)) {
381 q
->stat_flows_plimit
++;
382 return qdisc_drop(skb
, sch
);
386 if (skb_is_retransmit(skb
))
387 q
->stat_tcp_retrans
++;
388 qdisc_qstats_backlog_inc(sch
, skb
);
389 if (fq_flow_is_detached(f
)) {
390 fq_flow_add_tail(&q
->new_flows
, f
);
391 if (time_after(jiffies
, f
->age
+ q
->flow_refill_delay
))
392 f
->credit
= max_t(u32
, f
->credit
, q
->quantum
);
396 /* Note: this overwrites f->age */
397 flow_queue_add(f
, skb
);
399 if (unlikely(f
== &q
->internal
)) {
400 q
->stat_internal_packets
++;
404 return NET_XMIT_SUCCESS
;
407 static void fq_check_throttled(struct fq_sched_data
*q
, u64 now
)
411 if (q
->time_next_delayed_flow
> now
)
414 q
->time_next_delayed_flow
= ~0ULL;
415 while ((p
= rb_first(&q
->delayed
)) != NULL
) {
416 struct fq_flow
*f
= container_of(p
, struct fq_flow
, rate_node
);
418 if (f
->time_next_packet
> now
) {
419 q
->time_next_delayed_flow
= f
->time_next_packet
;
422 rb_erase(p
, &q
->delayed
);
423 q
->throttled_flows
--;
424 fq_flow_add_tail(&q
->old_flows
, f
);
428 static struct sk_buff
*fq_dequeue(struct Qdisc
*sch
)
430 struct fq_sched_data
*q
= qdisc_priv(sch
);
431 u64 now
= ktime_get_ns();
432 struct fq_flow_head
*head
;
437 skb
= fq_dequeue_head(sch
, &q
->internal
);
440 fq_check_throttled(q
, now
);
442 head
= &q
->new_flows
;
444 head
= &q
->old_flows
;
446 if (q
->time_next_delayed_flow
!= ~0ULL)
447 qdisc_watchdog_schedule_ns(&q
->watchdog
,
448 q
->time_next_delayed_flow
);
454 if (f
->credit
<= 0) {
455 f
->credit
+= q
->quantum
;
456 head
->first
= f
->next
;
457 fq_flow_add_tail(&q
->old_flows
, f
);
462 if (unlikely(skb
&& now
< f
->time_next_packet
&&
463 !skb_is_tcp_pure_ack(skb
))) {
464 head
->first
= f
->next
;
465 fq_flow_set_throttled(q
, f
);
469 skb
= fq_dequeue_head(sch
, f
);
471 head
->first
= f
->next
;
472 /* force a pass through old_flows to prevent starvation */
473 if ((head
== &q
->new_flows
) && q
->old_flows
.first
) {
474 fq_flow_add_tail(&q
->old_flows
, f
);
476 fq_flow_set_detached(f
);
482 f
->credit
-= qdisc_pkt_len(skb
);
484 if (f
->credit
> 0 || !q
->rate_enable
)
487 /* Do not pace locally generated ack packets */
488 if (skb_is_tcp_pure_ack(skb
))
491 rate
= q
->flow_max_rate
;
493 rate
= min(skb
->sk
->sk_pacing_rate
, rate
);
496 u32 plen
= max(qdisc_pkt_len(skb
), q
->quantum
);
497 u64 len
= (u64
)plen
* NSEC_PER_SEC
;
501 /* Since socket rate can change later,
502 * clamp the delay to 1 second.
503 * Really, providers of too big packets should be fixed !
505 if (unlikely(len
> NSEC_PER_SEC
)) {
507 q
->stat_pkts_too_long
++;
510 f
->time_next_packet
= now
+ len
;
513 qdisc_bstats_update(sch
, skb
);
517 static void fq_reset(struct Qdisc
*sch
)
519 struct fq_sched_data
*q
= qdisc_priv(sch
);
520 struct rb_root
*root
;
526 while ((skb
= fq_dequeue_head(sch
, &q
->internal
)) != NULL
)
532 for (idx
= 0; idx
< (1U << q
->fq_trees_log
); idx
++) {
533 root
= &q
->fq_root
[idx
];
534 while ((p
= rb_first(root
)) != NULL
) {
535 f
= container_of(p
, struct fq_flow
, fq_node
);
538 while ((skb
= fq_dequeue_head(sch
, f
)) != NULL
)
541 kmem_cache_free(fq_flow_cachep
, f
);
544 q
->new_flows
.first
= NULL
;
545 q
->old_flows
.first
= NULL
;
546 q
->delayed
= RB_ROOT
;
548 q
->inactive_flows
= 0;
549 q
->throttled_flows
= 0;
552 static void fq_rehash(struct fq_sched_data
*q
,
553 struct rb_root
*old_array
, u32 old_log
,
554 struct rb_root
*new_array
, u32 new_log
)
556 struct rb_node
*op
, **np
, *parent
;
557 struct rb_root
*oroot
, *nroot
;
558 struct fq_flow
*of
, *nf
;
562 for (idx
= 0; idx
< (1U << old_log
); idx
++) {
563 oroot
= &old_array
[idx
];
564 while ((op
= rb_first(oroot
)) != NULL
) {
566 of
= container_of(op
, struct fq_flow
, fq_node
);
567 if (fq_gc_candidate(of
)) {
569 kmem_cache_free(fq_flow_cachep
, of
);
572 nroot
= &new_array
[hash_32((u32
)(long)of
->sk
, new_log
)];
574 np
= &nroot
->rb_node
;
579 nf
= container_of(parent
, struct fq_flow
, fq_node
);
580 BUG_ON(nf
->sk
== of
->sk
);
583 np
= &parent
->rb_right
;
585 np
= &parent
->rb_left
;
588 rb_link_node(&of
->fq_node
, parent
, np
);
589 rb_insert_color(&of
->fq_node
, nroot
);
593 q
->inactive_flows
-= fcnt
;
594 q
->stat_gc_flows
+= fcnt
;
597 static void *fq_alloc_node(size_t sz
, int node
)
601 ptr
= kmalloc_node(sz
, GFP_KERNEL
| __GFP_REPEAT
| __GFP_NOWARN
, node
);
603 ptr
= vmalloc_node(sz
, node
);
607 static void fq_free(void *addr
)
612 static int fq_resize(struct Qdisc
*sch
, u32 log
)
614 struct fq_sched_data
*q
= qdisc_priv(sch
);
615 struct rb_root
*array
;
619 if (q
->fq_root
&& log
== q
->fq_trees_log
)
622 /* If XPS was setup, we can allocate memory on right NUMA node */
623 array
= fq_alloc_node(sizeof(struct rb_root
) << log
,
624 netdev_queue_numa_node_read(sch
->dev_queue
));
628 for (idx
= 0; idx
< (1U << log
); idx
++)
629 array
[idx
] = RB_ROOT
;
633 old_fq_root
= q
->fq_root
;
635 fq_rehash(q
, old_fq_root
, q
->fq_trees_log
, array
, log
);
638 q
->fq_trees_log
= log
;
640 sch_tree_unlock(sch
);
642 fq_free(old_fq_root
);
647 static const struct nla_policy fq_policy
[TCA_FQ_MAX
+ 1] = {
648 [TCA_FQ_PLIMIT
] = { .type
= NLA_U32
},
649 [TCA_FQ_FLOW_PLIMIT
] = { .type
= NLA_U32
},
650 [TCA_FQ_QUANTUM
] = { .type
= NLA_U32
},
651 [TCA_FQ_INITIAL_QUANTUM
] = { .type
= NLA_U32
},
652 [TCA_FQ_RATE_ENABLE
] = { .type
= NLA_U32
},
653 [TCA_FQ_FLOW_DEFAULT_RATE
] = { .type
= NLA_U32
},
654 [TCA_FQ_FLOW_MAX_RATE
] = { .type
= NLA_U32
},
655 [TCA_FQ_BUCKETS_LOG
] = { .type
= NLA_U32
},
656 [TCA_FQ_FLOW_REFILL_DELAY
] = { .type
= NLA_U32
},
659 static int fq_change(struct Qdisc
*sch
, struct nlattr
*opt
)
661 struct fq_sched_data
*q
= qdisc_priv(sch
);
662 struct nlattr
*tb
[TCA_FQ_MAX
+ 1];
663 int err
, drop_count
= 0;
664 unsigned drop_len
= 0;
670 err
= nla_parse_nested(tb
, TCA_FQ_MAX
, opt
, fq_policy
);
676 fq_log
= q
->fq_trees_log
;
678 if (tb
[TCA_FQ_BUCKETS_LOG
]) {
679 u32 nval
= nla_get_u32(tb
[TCA_FQ_BUCKETS_LOG
]);
681 if (nval
>= 1 && nval
<= ilog2(256*1024))
686 if (tb
[TCA_FQ_PLIMIT
])
687 sch
->limit
= nla_get_u32(tb
[TCA_FQ_PLIMIT
]);
689 if (tb
[TCA_FQ_FLOW_PLIMIT
])
690 q
->flow_plimit
= nla_get_u32(tb
[TCA_FQ_FLOW_PLIMIT
]);
692 if (tb
[TCA_FQ_QUANTUM
]) {
693 u32 quantum
= nla_get_u32(tb
[TCA_FQ_QUANTUM
]);
696 q
->quantum
= quantum
;
701 if (tb
[TCA_FQ_INITIAL_QUANTUM
])
702 q
->initial_quantum
= nla_get_u32(tb
[TCA_FQ_INITIAL_QUANTUM
]);
704 if (tb
[TCA_FQ_FLOW_DEFAULT_RATE
])
705 pr_warn_ratelimited("sch_fq: defrate %u ignored.\n",
706 nla_get_u32(tb
[TCA_FQ_FLOW_DEFAULT_RATE
]));
708 if (tb
[TCA_FQ_FLOW_MAX_RATE
])
709 q
->flow_max_rate
= nla_get_u32(tb
[TCA_FQ_FLOW_MAX_RATE
]);
711 if (tb
[TCA_FQ_RATE_ENABLE
]) {
712 u32 enable
= nla_get_u32(tb
[TCA_FQ_RATE_ENABLE
]);
715 q
->rate_enable
= enable
;
720 if (tb
[TCA_FQ_FLOW_REFILL_DELAY
]) {
721 u32 usecs_delay
= nla_get_u32(tb
[TCA_FQ_FLOW_REFILL_DELAY
]) ;
723 q
->flow_refill_delay
= usecs_to_jiffies(usecs_delay
);
726 if (tb
[TCA_FQ_ORPHAN_MASK
])
727 q
->orphan_mask
= nla_get_u32(tb
[TCA_FQ_ORPHAN_MASK
]);
730 sch_tree_unlock(sch
);
731 err
= fq_resize(sch
, fq_log
);
734 while (sch
->q
.qlen
> sch
->limit
) {
735 struct sk_buff
*skb
= fq_dequeue(sch
);
739 drop_len
+= qdisc_pkt_len(skb
);
743 qdisc_tree_reduce_backlog(sch
, drop_count
, drop_len
);
745 sch_tree_unlock(sch
);
749 static void fq_destroy(struct Qdisc
*sch
)
751 struct fq_sched_data
*q
= qdisc_priv(sch
);
755 qdisc_watchdog_cancel(&q
->watchdog
);
758 static int fq_init(struct Qdisc
*sch
, struct nlattr
*opt
)
760 struct fq_sched_data
*q
= qdisc_priv(sch
);
764 q
->flow_plimit
= 100;
765 q
->quantum
= 2 * psched_mtu(qdisc_dev(sch
));
766 q
->initial_quantum
= 10 * psched_mtu(qdisc_dev(sch
));
767 q
->flow_refill_delay
= msecs_to_jiffies(40);
768 q
->flow_max_rate
= ~0U;
770 q
->new_flows
.first
= NULL
;
771 q
->old_flows
.first
= NULL
;
772 q
->delayed
= RB_ROOT
;
774 q
->fq_trees_log
= ilog2(1024);
775 q
->orphan_mask
= 1024 - 1;
776 qdisc_watchdog_init(&q
->watchdog
, sch
);
779 err
= fq_change(sch
, opt
);
781 err
= fq_resize(sch
, q
->fq_trees_log
);
786 static int fq_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
788 struct fq_sched_data
*q
= qdisc_priv(sch
);
791 opts
= nla_nest_start(skb
, TCA_OPTIONS
);
793 goto nla_put_failure
;
795 /* TCA_FQ_FLOW_DEFAULT_RATE is not used anymore */
797 if (nla_put_u32(skb
, TCA_FQ_PLIMIT
, sch
->limit
) ||
798 nla_put_u32(skb
, TCA_FQ_FLOW_PLIMIT
, q
->flow_plimit
) ||
799 nla_put_u32(skb
, TCA_FQ_QUANTUM
, q
->quantum
) ||
800 nla_put_u32(skb
, TCA_FQ_INITIAL_QUANTUM
, q
->initial_quantum
) ||
801 nla_put_u32(skb
, TCA_FQ_RATE_ENABLE
, q
->rate_enable
) ||
802 nla_put_u32(skb
, TCA_FQ_FLOW_MAX_RATE
, q
->flow_max_rate
) ||
803 nla_put_u32(skb
, TCA_FQ_FLOW_REFILL_DELAY
,
804 jiffies_to_usecs(q
->flow_refill_delay
)) ||
805 nla_put_u32(skb
, TCA_FQ_ORPHAN_MASK
, q
->orphan_mask
) ||
806 nla_put_u32(skb
, TCA_FQ_BUCKETS_LOG
, q
->fq_trees_log
))
807 goto nla_put_failure
;
809 return nla_nest_end(skb
, opts
);
815 static int fq_dump_stats(struct Qdisc
*sch
, struct gnet_dump
*d
)
817 struct fq_sched_data
*q
= qdisc_priv(sch
);
818 u64 now
= ktime_get_ns();
819 struct tc_fq_qd_stats st
= {
820 .gc_flows
= q
->stat_gc_flows
,
821 .highprio_packets
= q
->stat_internal_packets
,
822 .tcp_retrans
= q
->stat_tcp_retrans
,
823 .throttled
= q
->stat_throttled
,
824 .flows_plimit
= q
->stat_flows_plimit
,
825 .pkts_too_long
= q
->stat_pkts_too_long
,
826 .allocation_errors
= q
->stat_allocation_errors
,
828 .inactive_flows
= q
->inactive_flows
,
829 .throttled_flows
= q
->throttled_flows
,
830 .time_next_delayed_flow
= q
->time_next_delayed_flow
- now
,
833 return gnet_stats_copy_app(d
, &st
, sizeof(st
));
836 static struct Qdisc_ops fq_qdisc_ops __read_mostly
= {
838 .priv_size
= sizeof(struct fq_sched_data
),
840 .enqueue
= fq_enqueue
,
841 .dequeue
= fq_dequeue
,
842 .peek
= qdisc_peek_dequeued
,
845 .destroy
= fq_destroy
,
848 .dump_stats
= fq_dump_stats
,
849 .owner
= THIS_MODULE
,
852 static int __init
fq_module_init(void)
856 fq_flow_cachep
= kmem_cache_create("fq_flow_cache",
857 sizeof(struct fq_flow
),
862 ret
= register_qdisc(&fq_qdisc_ops
);
864 kmem_cache_destroy(fq_flow_cachep
);
868 static void __exit
fq_module_exit(void)
870 unregister_qdisc(&fq_qdisc_ops
);
871 kmem_cache_destroy(fq_flow_cachep
);
874 module_init(fq_module_init
)
875 module_exit(fq_module_exit
)
876 MODULE_AUTHOR("Eric Dumazet");
877 MODULE_LICENSE("GPL");