libnl 3.5.0

fifo.c
1 /*
2 * lib/route/qdisc/fifo.c (p|b)fifo
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation version 2.1
7 * of the License.
8 *
9 * Copyright (c) 2003-2011 Thomas Graf <tgraf@suug.ch>
10 */
11
12 /**
13 * @ingroup qdisc
14 * @defgroup qdisc_fifo Packet/Bytes FIFO (pfifo/bfifo)
15 * @brief
16 *
17 * The FIFO qdisc comes in two flavours:
18 * @par bfifo (Byte FIFO)
19 * Allows enqueuing until the currently queued volume in bytes exceeds
20 * the configured limit.backlog contains currently enqueued volume in bytes.
21 *
22 * @par pfifo (Packet FIFO)
23 * Allows enquueing until the currently queued number of packets
24 * exceeds the configured limit.
25 *
26 * The configuration is exactly the same, the decision which of
27 * the two variations is going to be used is made based on the
28 * kind of the qdisc (rtnl_tc_set_kind()).
29 * @{
30 */
31
32 #include <netlink-private/netlink.h>
33 #include <netlink-private/tc.h>
34 #include <netlink/netlink.h>
35 #include <netlink-private/route/tc-api.h>
36 #include <netlink/route/qdisc.h>
37 #include <netlink/route/qdisc/fifo.h>
38 #include <netlink/utils.h>
39
40 /** @cond SKIP */
41 #define SCH_FIFO_ATTR_LIMIT 1
42 /** @endcond */
43
44 static int fifo_msg_parser(struct rtnl_tc *tc, void *data)
45 {
46 struct rtnl_fifo *fifo = data;
47 struct tc_fifo_qopt *opt;
48
49 if (tc->tc_opts->d_size < sizeof(struct tc_fifo_qopt))
50 return -NLE_INVAL;
51
52 opt = (struct tc_fifo_qopt *) tc->tc_opts->d_data;
53 fifo->qf_limit = opt->limit;
54 fifo->qf_mask = SCH_FIFO_ATTR_LIMIT;
55
56 return 0;
57 }
58
59 static void pfifo_dump_line(struct rtnl_tc *tc, void *data,
60 struct nl_dump_params *p)
61 {
62 struct rtnl_fifo *fifo = data;
63
64 if (fifo)
65 nl_dump(p, " limit %u packets", fifo->qf_limit);
66 }
67
68 static void bfifo_dump_line(struct rtnl_tc *tc, void *data,
69 struct nl_dump_params *p)
70 {
71 struct rtnl_fifo *fifo = data;
72 char *unit;
73 double r;
74
75 if (!fifo)
76 return;
77
78 r = nl_cancel_down_bytes(fifo->qf_limit, &unit);
79 nl_dump(p, " limit %.1f%s", r, unit);
80 }
81
82 static int fifo_msg_fill(struct rtnl_tc *tc, void *data, struct nl_msg *msg)
83 {
84 struct rtnl_fifo *fifo = data;
85 struct tc_fifo_qopt opts = {0};
86
87 if (!fifo || !(fifo->qf_mask & SCH_FIFO_ATTR_LIMIT))
88 return -NLE_INVAL;
89
90 opts.limit = fifo->qf_limit;
91
92 return nlmsg_append(msg, &opts, sizeof(opts), NL_DONTPAD);
93 }
94
95 /**
96 * @name Attribute Modification
97 * @{
98 */
99
100 /**
101 * Set limit of FIFO qdisc.
102 * @arg qdisc FIFO qdisc to be modified.
103 * @arg limit New limit.
104 * @return 0 on success or a negative error code.
105 */
106 int rtnl_qdisc_fifo_set_limit(struct rtnl_qdisc *qdisc, int limit)
107 {
108 struct rtnl_fifo *fifo;
109
110 if (!(fifo = rtnl_tc_data(TC_CAST(qdisc))))
111 return -NLE_NOMEM;
112
113 fifo->qf_limit = limit;
114 fifo->qf_mask |= SCH_FIFO_ATTR_LIMIT;
115
116 return 0;
117 }
118
119 /**
120 * Get limit of a FIFO qdisc.
121 * @arg qdisc FIFO qdisc.
122 * @return Numeric limit or a negative error code.
123 */
124 int rtnl_qdisc_fifo_get_limit(struct rtnl_qdisc *qdisc)
125 {
126 struct rtnl_fifo *fifo;
127
128 if (!(fifo = rtnl_tc_data(TC_CAST(qdisc))))
129 return -NLE_NOMEM;
130
131 if (fifo->qf_mask & SCH_FIFO_ATTR_LIMIT)
132 return fifo->qf_limit;
133 else
134 return -NLE_NOATTR;
135 }
136
137 /** @} */
138
139 static struct rtnl_tc_ops pfifo_ops = {
140 .to_kind = "pfifo",
141 .to_type = RTNL_TC_TYPE_QDISC,
142 .to_size = sizeof(struct rtnl_fifo),
143 .to_msg_parser = fifo_msg_parser,
144 .to_dump[NL_DUMP_LINE] = pfifo_dump_line,
145 .to_msg_fill = fifo_msg_fill,
146 };
147
148 static struct rtnl_tc_ops bfifo_ops = {
149 .to_kind = "bfifo",
150 .to_type = RTNL_TC_TYPE_QDISC,
151 .to_size = sizeof(struct rtnl_fifo),
152 .to_msg_parser = fifo_msg_parser,
153 .to_dump[NL_DUMP_LINE] = bfifo_dump_line,
154 .to_msg_fill = fifo_msg_fill,
155 };
156
157 static void __init fifo_init(void)
158 {
159 rtnl_tc_register(&pfifo_ops);
160 rtnl_tc_register(&bfifo_ops);
161 }
162
163 static void __exit fifo_exit(void)
164 {
165 rtnl_tc_unregister(&pfifo_ops);
166 rtnl_tc_unregister(&bfifo_ops);
167 }
168
169 /** @} */
NL_DUMP_LINE
Dump object briefly on one line.
Definition: types.h:22
rtnl_tc_register
int rtnl_tc_register(struct rtnl_tc_ops *ops)
Register a traffic control module.
Definition: tc.c:1021
rtnl_tc_unregister
void rtnl_tc_unregister(struct rtnl_tc_ops *ops)
Unregister a traffic control module.
Definition: tc.c:1055
nl_cancel_down_bytes
double nl_cancel_down_bytes(unsigned long long l, char **unit)
Cancel down a byte counter.
Definition: utils.c:170
TC_CAST
#define TC_CAST(ptr)
Macro to cast qdisc/class/classifier to tc object.
Definition: tc.h:56
rtnl_tc_data
void * rtnl_tc_data(struct rtnl_tc *tc)
Return pointer to private data of traffic control object.
Definition: tc.c:1082
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:449
nl_dump_params
Dumping parameters.
Definition: types.h:33
rtnl_qdisc_fifo_get_limit
int rtnl_qdisc_fifo_get_limit(struct rtnl_qdisc *qdisc)
Get limit of a FIFO qdisc.
Definition: fifo.c:124
nl_dump
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
Definition: utils.c:962
rtnl_qdisc_fifo_set_limit
int rtnl_qdisc_fifo_set_limit(struct rtnl_qdisc *qdisc, int limit)
Set limit of FIFO qdisc.
Definition: fifo.c:106