libnl  1.1
fifo.c
1 /*
2  * lib/route/sch/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-2006 Thomas Graf <tgraf@suug.ch>
10  */
11 
12 /**
13  * @ingroup qdisc_api
14  * @defgroup 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_qdisc_set_kind()).
29  * @{
30  */
31 
32 #include <netlink-local.h>
33 #include <netlink-tc.h>
34 #include <netlink/netlink.h>
35 #include <netlink/route/qdisc.h>
36 #include <netlink/route/qdisc-modules.h>
37 #include <netlink/route/sch/fifo.h>
38 #include <netlink/utils.h>
39 
40 /** @cond SKIP */
41 #define SCH_FIFO_ATTR_LIMIT 1
42 /** @endcond */
43 
44 static inline struct rtnl_fifo *fifo_qdisc(struct rtnl_qdisc *qdisc)
45 {
46  return (struct rtnl_fifo *) qdisc->q_subdata;
47 }
48 
49 static inline struct rtnl_fifo *fifo_alloc(struct rtnl_qdisc *qdisc)
50 {
51  if (!qdisc->q_subdata)
52  qdisc->q_subdata = calloc(1, sizeof(struct rtnl_fifo));
53 
54  return fifo_qdisc(qdisc);
55 }
56 
57 static int fifo_msg_parser(struct rtnl_qdisc *qdisc)
58 {
59  struct rtnl_fifo *fifo;
60  struct tc_fifo_qopt *opt;
61 
62  if (qdisc->q_opts->d_size < sizeof(struct tc_fifo_qopt))
63  return nl_error(EINVAL, "FIFO options size mismatch");
64 
65  fifo = fifo_alloc(qdisc);
66  if (!fifo)
67  return nl_errno(ENOMEM);
68 
69  opt = (struct tc_fifo_qopt *) qdisc->q_opts->d_data;
70  fifo->qf_limit = opt->limit;
71  fifo->qf_mask = SCH_FIFO_ATTR_LIMIT;
72 
73  return 0;
74 }
75 
76 static void fifo_free_data(struct rtnl_qdisc *qdisc)
77 {
78  free(qdisc->q_subdata);
79 }
80 
81 static int pfifo_dump_brief(struct rtnl_qdisc *qdisc,
82  struct nl_dump_params *p, int line)
83 {
84  struct rtnl_fifo *fifo = fifo_qdisc(qdisc);
85 
86  if (fifo)
87  dp_dump(p, " limit %u packets", fifo->qf_limit);
88 
89  return line;
90 }
91 
92 static int bfifo_dump_brief(struct rtnl_qdisc *qdisc,
93  struct nl_dump_params *p, int line)
94 {
95  struct rtnl_fifo *fifo = fifo_qdisc(qdisc);
96 
97  if (fifo) {
98  char *unit;
99  double r;
100 
101  r = nl_cancel_down_bytes(fifo->qf_limit, &unit);
102  dp_dump(p, " limit %.1f%s", r, unit);
103  }
104 
105  return line;
106 }
107 
108 static struct nl_msg *fifo_get_opts(struct rtnl_qdisc *qdisc)
109 {
110  struct rtnl_fifo *fifo;
111  struct tc_fifo_qopt opts;
112  struct nl_msg *msg;
113 
114  fifo = fifo_qdisc(qdisc);
115  if (!fifo || !(fifo->qf_mask & SCH_FIFO_ATTR_LIMIT))
116  return NULL;
117 
118  msg = nlmsg_alloc();
119  if (!msg)
120  goto errout;
121 
122  memset(&opts, 0, sizeof(opts));
123  opts.limit = fifo->qf_limit;
124 
125  if (nlmsg_append(msg, &opts, sizeof(opts), NL_DONTPAD) < 0)
126  goto errout;
127 
128  return msg;
129 errout:
130  nlmsg_free(msg);
131  return NULL;
132 }
133 
134 /**
135  * @name Attribute Modification
136  * @{
137  */
138 
139 /**
140  * Set limit of FIFO qdisc.
141  * @arg qdisc FIFO qdisc to be modified.
142  * @arg limit New limit.
143  * @return 0 on success or a negative error code.
144  */
145 int rtnl_qdisc_fifo_set_limit(struct rtnl_qdisc *qdisc, int limit)
146 {
147  struct rtnl_fifo *fifo;
148 
149  fifo = fifo_alloc(qdisc);
150  if (!fifo)
151  return nl_errno(ENOMEM);
152 
153  fifo->qf_limit = limit;
154  fifo->qf_mask |= SCH_FIFO_ATTR_LIMIT;
155 
156  return 0;
157 }
158 
159 /**
160  * Get limit of a FIFO qdisc.
161  * @arg qdisc FIFO qdisc.
162  * @return Numeric limit or a negative error code.
163  */
164 int rtnl_qdisc_fifo_get_limit(struct rtnl_qdisc *qdisc)
165 {
166  struct rtnl_fifo *fifo;
167 
168  fifo = fifo_qdisc(qdisc);
169  if (fifo && fifo->qf_mask & SCH_FIFO_ATTR_LIMIT)
170  return fifo->qf_limit;
171  else
172  return nl_errno(ENOMEM);
173 }
174 
175 /** @} */
176 
177 static struct rtnl_qdisc_ops pfifo_ops = {
178  .qo_kind = "pfifo",
179  .qo_msg_parser = fifo_msg_parser,
180  .qo_free_data = fifo_free_data,
181  .qo_dump[NL_DUMP_BRIEF] = pfifo_dump_brief,
182  .qo_get_opts = fifo_get_opts,
183 };
184 
185 static struct rtnl_qdisc_ops bfifo_ops = {
186  .qo_kind = "bfifo",
187  .qo_msg_parser = fifo_msg_parser,
188  .qo_free_data = fifo_free_data,
189  .qo_dump[NL_DUMP_BRIEF] = bfifo_dump_brief,
190  .qo_get_opts = fifo_get_opts,
191 };
192 
193 static void __init fifo_init(void)
194 {
195  rtnl_qdisc_register(&pfifo_ops);
196  rtnl_qdisc_register(&bfifo_ops);
197 }
198 
199 static void __exit fifo_exit(void)
200 {
201  rtnl_qdisc_unregister(&pfifo_ops);
202  rtnl_qdisc_unregister(&bfifo_ops);
203 }
204 
205 /** @} */
Dump object in a brief one-liner.
Definition: types.h:22
char qo_kind[32]
Kind/Name of Qdisc.
Definition: qdisc-modules.h:30
int rtnl_qdisc_fifo_set_limit(struct rtnl_qdisc *qdisc, int limit)
Set limit of FIFO qdisc.
Definition: fifo.c:145
int rtnl_qdisc_unregister(struct rtnl_qdisc_ops *qops)
Unregister a qdisc module.
Definition: qdisc_api.c:61
struct nl_msg * nlmsg_alloc(void)
Allocate a new netlink message with the default maximum payload size.
Definition: msg.c:401
void nlmsg_free(struct nl_msg *n)
Free a netlink message.
Definition: msg.c:656
double nl_cancel_down_bytes(unsigned long long l, char **unit)
Cancel down a byte counter.
Definition: utils.c:188
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:549
int rtnl_qdisc_register(struct rtnl_qdisc_ops *qops)
Register a qdisc module.
Definition: qdisc_api.c:40
Dumping parameters.
Definition: types.h:36
Qdisc Operations.
Definition: qdisc-modules.h:25
int rtnl_qdisc_fifo_get_limit(struct rtnl_qdisc *qdisc)
Get limit of a FIFO qdisc.
Definition: fifo.c:164