libnl: /data/src/libnl3/lib/route/qdisc/sfq.c Source File

libnl 3.7.0

sfq.c
1 /* SPDX-License-Identifier: LGPL-2.1-only */
2 /*
3 * Copyright (c) 2003-2011 Thomas Graf <tgraf@suug.ch>
4 */
5
6 /**
7 * @ingroup qdisc
8 * @defgroup qdisc_sfq Stochastic Fairness Queueing (SFQ)
9 * @brief
10 *
11 * @par Parameter Description
12 * - \b Quantum: Number of bytes to send out per slot and round.
13 * - \b Perturbation: Timer period between changing the hash function.
14 * - \b Limit: Upper limit of queue in number of packets before SFQ starts
15 * dropping packets.
16 * - \b Divisor: Hash table divisor, i.e. size of hash table.
17 * @{
18 */
19
20 #include <netlink-private/netlink.h>
21 #include <netlink-private/tc.h>
22 #include <netlink/netlink.h>
23 #include <netlink/utils.h>
24 #include <netlink-private/route/tc-api.h>
25 #include <netlink/route/qdisc.h>
26 #include <netlink/route/qdisc/sfq.h>
27
28 /** @cond SKIP */
29 #define SCH_SFQ_ATTR_QUANTUM 0x01
30 #define SCH_SFQ_ATTR_PERTURB 0x02
31 #define SCH_SFQ_ATTR_LIMIT 0x04
32 #define SCH_SFQ_ATTR_DIVISOR 0x08
33 #define SCH_SFQ_ATTR_FLOWS 0x10
34 /** @endcond */
35
36 static int sfq_msg_parser(struct rtnl_tc *tc, void *data)
37 {
38 struct rtnl_sfq *sfq = data;
39 struct tc_sfq_qopt *opts;
40
41 if (!(tc->ce_mask & TCA_ATTR_OPTS))
42 return 0;
43
44 if (tc->tc_opts->d_size < sizeof(*opts))
45 return -NLE_INVAL;
46
47 opts = (struct tc_sfq_qopt *) tc->tc_opts->d_data;
48
49 sfq->qs_quantum = opts->quantum;
50 sfq->qs_perturb = opts->perturb_period;
51 sfq->qs_limit = opts->limit;
52 sfq->qs_divisor = opts->divisor;
53 sfq->qs_flows = opts->flows;
54
55 sfq->qs_mask = (SCH_SFQ_ATTR_QUANTUM | SCH_SFQ_ATTR_PERTURB |
56 SCH_SFQ_ATTR_LIMIT | SCH_SFQ_ATTR_DIVISOR |
57 SCH_SFQ_ATTR_FLOWS);
58
59 return 0;
60 }
61
62 static void sfq_dump_line(struct rtnl_tc *tc, void *data,
63 struct nl_dump_params *p)
64 {
65 struct rtnl_sfq *sfq = data;
66
67 if (sfq)
68 nl_dump(p, " quantum %u perturb %us", sfq->qs_quantum,
69 sfq->qs_perturb);
70 }
71
72 static void sfq_dump_details(struct rtnl_tc *tc, void *data,
73 struct nl_dump_params *p)
74 {
75 struct rtnl_sfq *sfq = data;
76
77 if (sfq)
78 nl_dump(p, "limit %u divisor %u",
79 sfq->qs_limit, sfq->qs_divisor);
80 }
81
82 static int sfq_msg_fill(struct rtnl_tc *tc, void *data, struct nl_msg *msg)
83 {
84 struct rtnl_sfq *sfq = data;
85 struct tc_sfq_qopt opts = {0};
86
87 if (!sfq)
88 BUG();
89
90 opts.quantum = sfq->qs_quantum;
91 opts.perturb_period = sfq->qs_perturb;
92 opts.limit = sfq->qs_limit;
93
94 return nlmsg_append(msg, &opts, sizeof(opts), NL_DONTPAD);
95 }
96
97 /**
98 * @name Attribute Access
99 * @{
100 */
101
102 /**
103 * Set quantum of SFQ qdisc.
104 * @arg qdisc SFQ qdisc to be modified.
105 * @arg quantum New quantum in bytes.
106 * @return 0 on success or a negative error code.
107 */
108 void rtnl_sfq_set_quantum(struct rtnl_qdisc *qdisc, int quantum)
109 {
110 struct rtnl_sfq *sfq;
111
112 if (!(sfq = rtnl_tc_data(TC_CAST(qdisc))))
113 BUG();
114
115 sfq->qs_quantum = quantum;
116 sfq->qs_mask |= SCH_SFQ_ATTR_QUANTUM;
117 }
118
119 /**
120 * Get quantum of SFQ qdisc.
121 * @arg qdisc SFQ qdisc.
122 * @return Quantum in bytes or a negative error code.
123 */
124 int rtnl_sfq_get_quantum(struct rtnl_qdisc *qdisc)
125 {
126 struct rtnl_sfq *sfq;
127
128 if (!(sfq = rtnl_tc_data(TC_CAST(qdisc))))
129 BUG();
130
131 if (sfq->qs_mask & SCH_SFQ_ATTR_QUANTUM)
132 return sfq->qs_quantum;
133 else
134 return -NLE_NOATTR;
135 }
136
137 /**
138 * Set limit of SFQ qdisc.
139 * @arg qdisc SFQ qdisc to be modified.
140 * @arg limit New limit in number of packets.
141 * @return 0 on success or a negative error code.
142 */
143 void rtnl_sfq_set_limit(struct rtnl_qdisc *qdisc, int limit)
144 {
145 struct rtnl_sfq *sfq;
146
147 if (!(sfq = rtnl_tc_data(TC_CAST(qdisc))))
148 BUG();
149
150 sfq->qs_limit = limit;
151 sfq->qs_mask |= SCH_SFQ_ATTR_LIMIT;
152 }
153
154 /**
155 * Get limit of SFQ qdisc.
156 * @arg qdisc SFQ qdisc.
157 * @return Limit or a negative error code.
158 */
159 int rtnl_sfq_get_limit(struct rtnl_qdisc *qdisc)
160 {
161 struct rtnl_sfq *sfq;
162
163 if (!(sfq = rtnl_tc_data(TC_CAST(qdisc))))
164 BUG();
165
166 if (sfq->qs_mask & SCH_SFQ_ATTR_LIMIT)
167 return sfq->qs_limit;
168 else
169 return -NLE_NOATTR;
170 }
171
172 /**
173 * Set perturbation interval of SFQ qdisc.
174 * @arg qdisc SFQ qdisc to be modified.
175 * @arg perturb New perturbation interval in seconds.
176 * @note A value of 0 disables perturbation altogether.
177 * @return 0 on success or a negative error code.
178 */
179 void rtnl_sfq_set_perturb(struct rtnl_qdisc *qdisc, int perturb)
180 {
181 struct rtnl_sfq *sfq;
182
183 if (!(sfq = rtnl_tc_data(TC_CAST(qdisc))))
184 BUG();
185
186 sfq->qs_perturb = perturb;
187 sfq->qs_mask |= SCH_SFQ_ATTR_PERTURB;
188 }
189
190 /**
191 * Get perturbation interval of SFQ qdisc.
192 * @arg qdisc SFQ qdisc.
193 * @return Perturbation interval in seconds or a negative error code.
194 */
195 int rtnl_sfq_get_perturb(struct rtnl_qdisc *qdisc)
196 {
197 struct rtnl_sfq *sfq;
198
199 if (!(sfq = rtnl_tc_data(TC_CAST(qdisc))))
200 BUG();
201
202 if (sfq->qs_mask & SCH_SFQ_ATTR_PERTURB)
203 return sfq->qs_perturb;
204 else
205 return -NLE_NOATTR;
206 }
207
208 /**
209 * Get divisor of SFQ qdisc.
210 * @arg qdisc SFQ qdisc.
211 * @return Divisor in number of entries or a negative error code.
212 */
213 int rtnl_sfq_get_divisor(struct rtnl_qdisc *qdisc)
214 {
215 struct rtnl_sfq *sfq;
216
217 if (!(sfq = rtnl_tc_data(TC_CAST(qdisc))))
218 BUG();
219
220 if (sfq->qs_mask & SCH_SFQ_ATTR_DIVISOR)
221 return sfq->qs_divisor;
222 else
223 return -NLE_NOATTR;
224 }
225
226 /** @} */
227
228 static struct rtnl_tc_ops sfq_ops = {
229 .to_kind = "sfq",
230 .to_type = RTNL_TC_TYPE_QDISC,
231 .to_size = sizeof(struct rtnl_sfq),
232 .to_msg_parser = sfq_msg_parser,
233 .to_dump = {
234 [NL_DUMP_LINE] = sfq_dump_line,
235 [NL_DUMP_DETAILS] = sfq_dump_details,
236 },
237 .to_msg_fill = sfq_msg_fill,
238 };
239
240 static void __init sfq_init(void)
241 {
242 rtnl_tc_register(&sfq_ops);
243 }
244
245 static void __exit sfq_exit(void)
246 {
247 rtnl_tc_unregister(&sfq_ops);
248 }
249
250 /** @} */
nlmsg_append
int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
Append data to tail of a netlink message.
Definition: msg.c:442
rtnl_sfq_get_quantum
int rtnl_sfq_get_quantum(struct rtnl_qdisc *qdisc)
Get quantum of SFQ qdisc.
Definition: sfq.c:124
rtnl_sfq_set_perturb
void rtnl_sfq_set_perturb(struct rtnl_qdisc *qdisc, int perturb)
Set perturbation interval of SFQ qdisc.
Definition: sfq.c:179
rtnl_sfq_get_divisor
int rtnl_sfq_get_divisor(struct rtnl_qdisc *qdisc)
Get divisor of SFQ qdisc.
Definition: sfq.c:213
rtnl_sfq_get_perturb
int rtnl_sfq_get_perturb(struct rtnl_qdisc *qdisc)
Get perturbation interval of SFQ qdisc.
Definition: sfq.c:195
rtnl_sfq_set_quantum
void rtnl_sfq_set_quantum(struct rtnl_qdisc *qdisc, int quantum)
Set quantum of SFQ qdisc.
Definition: sfq.c:108
rtnl_sfq_get_limit
int rtnl_sfq_get_limit(struct rtnl_qdisc *qdisc)
Get limit of SFQ qdisc.
Definition: sfq.c:159
rtnl_sfq_set_limit
void rtnl_sfq_set_limit(struct rtnl_qdisc *qdisc, int limit)
Set limit of SFQ qdisc.
Definition: sfq.c:143
rtnl_tc_data
void * rtnl_tc_data(struct rtnl_tc *tc)
Return pointer to private data of traffic control object.
Definition: tc.c:1076
TC_CAST
#define TC_CAST(ptr)
Macro to cast qdisc/class/classifier to tc object.
Definition: tc.h:50
rtnl_tc_register
int rtnl_tc_register(struct rtnl_tc_ops *ops)
Register a traffic control module.
Definition: tc.c:1015
rtnl_tc_unregister
void rtnl_tc_unregister(struct rtnl_tc_ops *ops)
Unregister a traffic control module.
Definition: tc.c:1049
nl_dump
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
Definition: utils.c:955
NL_DUMP_LINE
@ NL_DUMP_LINE
Dump object briefly on one line.
Definition: types.h:16
NL_DUMP_DETAILS
@ NL_DUMP_DETAILS
Dump all attributes but no statistics.
Definition: types.h:17
nl_dump_params
Dumping parameters.
Definition: types.h:28