libnl 3.5.0

api.c
1 /*
2 * lib/route/link/api.c Link Info API
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-2008 Thomas Graf <tgraf@suug.ch>
10 */
11
12 /**
13 * @ingroup link
14 * @defgroup link_API Link Modules API
15 * @brief API for modules implementing specific link types/semantics.
16 *
17 * @par 1) Registering/Unregistering a new link info type
18 * @code
19 * static struct rtnl_link_info_ops vlan_info_ops = {
20 * .io_name = "vlan",
21 * .io_alloc = vlan_alloc,
22 * .io_parse = vlan_parse,
23 * .io_dump[NL_DUMP_BRIEF] = vlan_dump_brief,
24 * .io_dump[NL_DUMP_FULL] = vlan_dump_full,
25 * .io_free = vlan_free,
26 * };
27 *
28 * static void __init vlan_init(void)
29 * {
30 * rtnl_link_register_info(&vlan_info_ops);
31 * }
32 *
33 * static void __exit vlan_exit(void)
34 * {
35 * rtnl_link_unregister_info(&vlan_info_ops);
36 * }
37 * @endcode
38 *
39 * @{
40 */
41
42 #include <netlink-private/netlink.h>
43 #include <netlink/netlink.h>
44 #include <netlink/utils.h>
45 #include <netlink/route/link.h>
46 #include <netlink-private/route/link/api.h>
47
48 static NL_LIST_HEAD(info_ops);
49
50 /* lock protecting info_ops and af_ops */
51 static NL_RW_LOCK(info_lock);
52
53 static struct rtnl_link_info_ops *__rtnl_link_info_ops_lookup(const char *name)
54 {
55 struct rtnl_link_info_ops *ops;
56
57 nl_list_for_each_entry(ops, &info_ops, io_list)
58 if (!strcmp(ops->io_name, name))
59 return ops;
60
61 return NULL;
62 }
63
64 /**
65 * @name Link Info Modules
66 * @{
67 */
68
69 /**
70 * Return operations of a specific link info type
71 * @arg name Name of link info type.
72 *
73 * @note The returned pointer must be given back using rtnl_link_info_ops_put()
74 *
75 * @return Pointer to operations or NULL if unavailable.
76 */
77 struct rtnl_link_info_ops *rtnl_link_info_ops_lookup(const char *name)
78 {
79 struct rtnl_link_info_ops *ops;
80
81 nl_write_lock(&info_lock);
82 if ((ops = __rtnl_link_info_ops_lookup(name)))
83 ops->io_refcnt++;
84 nl_write_unlock(&info_lock);
85
86 return ops;
87 }
88
89 /**
90 * Give back reference to a set of operations.
91 * @arg ops Link info operations.
92 */
93 void rtnl_link_info_ops_put(struct rtnl_link_info_ops *ops)
94 {
95 if (ops)
96 ops->io_refcnt--;
97 }
98
99 /**
100 * Register operations for a link info type
101 * @arg ops Link info operations
102 *
103 * This function must be called by modules implementing a specific link
104 * info type. It will make the operations implemented by the module
105 * available for everyone else.
106 *
107 * @return 0 on success or a negative error code.
108 * @return -NLE_INVAL Link info name not specified.
109 * @return -NLE_EXIST Operations for address family already registered.
110 */
111 int rtnl_link_register_info(struct rtnl_link_info_ops *ops)
112 {
113 int err = 0;
114
115 if (ops->io_name == NULL)
116 return -NLE_INVAL;
117
118 nl_write_lock(&info_lock);
119 if (__rtnl_link_info_ops_lookup(ops->io_name)) {
120 err = -NLE_EXIST;
121 goto errout;
122 }
123
124 NL_DBG(1, "Registered link info operations %s\n", ops->io_name);
125
126 nl_list_add_tail(&ops->io_list, &info_ops);
127 errout:
128 nl_write_unlock(&info_lock);
129
130 return err;
131 }
132
133 /**
134 * Unregister operations for a link info type
135 * @arg ops Link info operations
136 *
137 * This function must be called if a module implementing a specific link
138 * info type is unloaded or becomes unavailable. It must provide a
139 * set of operations which have previously been registered using
140 * rtnl_link_register_info().
141 *
142 * @return 0 on success or a negative error code
143 * @return _NLE_OPNOTSUPP Link info operations not registered.
144 * @return -NLE_BUSY Link info operations still in use.
145 */
146 int rtnl_link_unregister_info(struct rtnl_link_info_ops *ops)
147 {
148 struct rtnl_link_info_ops *t;
149 int err = -NLE_OPNOTSUPP;
150
151 nl_write_lock(&info_lock);
152
153 nl_list_for_each_entry(t, &info_ops, io_list) {
154 if (t == ops) {
155 if (t->io_refcnt > 0) {
156 err = -NLE_BUSY;
157 goto errout;
158 }
159
160 nl_list_del(&t->io_list);
161
162 NL_DBG(1, "Unregistered link info operations %s\n",
163 ops->io_name);
164 err = 0;
165 goto errout;
166 }
167 }
168
169 errout:
170 nl_write_unlock(&info_lock);
171
172 return err;
173 }
174
175 /** @} */
176
177 /**
178 * @name Link Address Family Modules
179 * @{
180 */
181
182 static struct rtnl_link_af_ops *af_ops[AF_MAX];
183
184 /**
185 * Return operations of a specific link address family
186 * @arg family Address family
187 *
188 * @note The returned pointer must be given back using rtnl_link_af_ops_put()
189 *
190 * @return Pointer to operations or NULL if unavailable.
191 */
192 struct rtnl_link_af_ops *rtnl_link_af_ops_lookup(const unsigned int family)
193 {
194 if (family == AF_UNSPEC || family >= AF_MAX)
195 return NULL;
196
197 nl_write_lock(&info_lock);
198 if (af_ops[family])
199 af_ops[family]->ao_refcnt++;
200 nl_write_unlock(&info_lock);
201
202 return af_ops[family];
203 }
204
205 /**
206 * Give back reference to a set of operations.
207 * @arg ops Address family operations.
208 */
209 void rtnl_link_af_ops_put(struct rtnl_link_af_ops *ops)
210 {
211 if (ops)
212 ops->ao_refcnt--;
213 }
214
215 /**
216 * Allocate and return data buffer for link address family modules
217 * @arg link Link object
218 * @arg ops Address family operations
219 *
220 * This function must be called by link address family modules in all
221 * cases where the API does not provide the data buffer as argument
222 * already. This typically includes set functions the module provides.
223 * Calling this function is strictly required to ensure proper allocation
224 * of the buffer upon first use. Link objects will NOT proactively
225 * allocate a data buffer for each registered link address family.
226 *
227 * @return Pointer to data buffer or NULL on error.
228 */
229 void *rtnl_link_af_alloc(struct rtnl_link *link,
230 const struct rtnl_link_af_ops *ops)
231 {
232 int family;
233
234 if (!link || !ops)
235 BUG();
236
237 family = ops->ao_family;
238
239 if (!link->l_af_data[family]) {
240 if (!ops->ao_alloc)
241 BUG();
242
243 link->l_af_data[family] = ops->ao_alloc(link);
244 if (!link->l_af_data[family])
245 return NULL;
246 }
247
248 return link->l_af_data[family];
249 }
250
251 /**
252 * Return data buffer for link address family modules
253 * @arg link Link object
254 * @arg ops Address family operations
255 *
256 * This function returns a pointer to the data buffer for the specified link
257 * address family module or NULL if the buffer was not allocated yet. This
258 * function is typically used by get functions of modules which are not
259 * interested in having the data buffer allocated if no values have been set
260 * yet.
261 *
262 * @return Pointer to data buffer or NULL on error.
263 */
264 void *rtnl_link_af_data(const struct rtnl_link *link,
265 const struct rtnl_link_af_ops *ops)
266 {
267 if (!link || !ops)
268 BUG();
269
270 return link->l_af_data[ops->ao_family];
271 }
272
273 /**
274 * Register operations for a link address family
275 * @arg ops Address family operations
276 *
277 * This function must be called by modules implementing a specific link
278 * address family. It will make the operations implemented by the module
279 * available for everyone else.
280 *
281 * @return 0 on success or a negative error code.
282 * @return -NLE_INVAL Address family is out of range (0..AF_MAX)
283 * @return -NLE_EXIST Operations for address family already registered.
284 */
285 int rtnl_link_af_register(struct rtnl_link_af_ops *ops)
286 {
287 int err = 0;
288
289 if (ops->ao_family == AF_UNSPEC || ops->ao_family >= AF_MAX)
290 return -NLE_INVAL;
291
292 nl_write_lock(&info_lock);
293 if (af_ops[ops->ao_family]) {
294 err = -NLE_EXIST;
295 goto errout;
296 }
297
298 ops->ao_refcnt = 0;
299 af_ops[ops->ao_family] = ops;
300
301 NL_DBG(1, "Registered link address family operations %u\n",
302 ops->ao_family);
303
304 errout:
305 nl_write_unlock(&info_lock);
306
307 return err;
308 }
309
310 /**
311 * Unregister operations for a link address family
312 * @arg ops Address family operations
313 *
314 * This function must be called if a module implementing a specific link
315 * address family is unloaded or becomes unavailable. It must provide a
316 * set of operations which have previously been registered using
317 * rtnl_link_af_register().
318 *
319 * @return 0 on success or a negative error code
320 * @return -NLE_INVAL ops is NULL
321 * @return -NLE_OBJ_NOTFOUND Address family operations not registered.
322 * @return -NLE_BUSY Address family operations still in use.
323 */
324 int rtnl_link_af_unregister(struct rtnl_link_af_ops *ops)
325 {
326 int err = -NLE_INVAL;
327
328 if (!ops)
329 return err;
330
331 nl_write_lock(&info_lock);
332 if (!af_ops[ops->ao_family]) {
333 err = -NLE_OBJ_NOTFOUND;
334 goto errout;
335 }
336
337 if (ops->ao_refcnt > 0) {
338 err = -NLE_BUSY;
339 goto errout;
340 }
341
342 af_ops[ops->ao_family] = NULL;
343
344 NL_DBG(1, "Unregistered link address family operations %u\n",
345 ops->ao_family);
346
347 errout:
348 nl_write_unlock(&info_lock);
349
350 return err;
351 }
352
353 /**
354 * Compare af data for a link address family
355 * @arg a Link object a
356 * @arg b Link object b
357 * @arg family af data family
358 *
359 * This function will compare af_data between two links
360 * a and b of family given by arg family
361 *
362 * @return 0 if address family specific data matches or is not present
363 * or != 0 if it mismatches.
364 */
365 int rtnl_link_af_data_compare(struct rtnl_link *a, struct rtnl_link *b,
366 int family)
367 {
368 struct rtnl_link_af_ops *af_ops;
369 int ret = 0;
370
371 if (!a->l_af_data[family] && !b->l_af_data[family])
372 return 0;
373
374 if (!a->l_af_data[family] || !b->l_af_data[family])
375 return ~0;
376
377 af_ops = rtnl_link_af_ops_lookup(family);
378 if (!af_ops)
379 return ~0;
380
381 if (af_ops->ao_compare == NULL) {
382 ret = ~0;
383 goto out;
384 }
385
386 ret = af_ops->ao_compare(a, b, family, ~0, 0);
387
388 out:
389 rtnl_link_af_ops_put(af_ops);
390
391 return ret;
392 }
393
394 /**
395 * Compare link info data
396 * @arg a Link object a
397 * @arg b Link object b
398 *
399 * This function will compare link_info data between two links
400 * a and b
401 *
402 * @return 0 if link_info data matches or is not present
403 * or != 0 if it mismatches.
404 */
405 int rtnl_link_info_data_compare(struct rtnl_link *a, struct rtnl_link *b, int flags)
406 {
407 if (a->l_info_ops != b->l_info_ops)
408 return ~0;
409
410 if (!a->l_info_ops || !a->l_info_ops->io_compare)
411 return 0;
412
413 return a->l_info_ops->io_compare(a, b, flags);
414 }
415
416 /** @} */
417
418 /** @} */
419
rtnl_link_info_data_compare
int rtnl_link_info_data_compare(struct rtnl_link *a, struct rtnl_link *b, int flags)
Compare link info data.
Definition: api.c:405
rtnl_link_af_register
int rtnl_link_af_register(struct rtnl_link_af_ops *ops)
Register operations for a link address family.
Definition: api.c:285
rtnl_link_register_info
int rtnl_link_register_info(struct rtnl_link_info_ops *ops)
Register operations for a link info type.
Definition: api.c:111
rtnl_link_af_unregister
int rtnl_link_af_unregister(struct rtnl_link_af_ops *ops)
Unregister operations for a link address family.
Definition: api.c:324
rtnl_link
Link object.
rtnl_link_af_ops_lookup
struct rtnl_link_af_ops * rtnl_link_af_ops_lookup(const unsigned int family)
Return operations of a specific link address family.
Definition: api.c:192
rtnl_link_af_alloc
void * rtnl_link_af_alloc(struct rtnl_link *link, const struct rtnl_link_af_ops *ops)
Allocate and return data buffer for link address family modules.
Definition: api.c:229
rtnl_link_af_data_compare
int rtnl_link_af_data_compare(struct rtnl_link *a, struct rtnl_link *b, int family)
Compare af data for a link address family.
Definition: api.c:365
rtnl_link_af_data
void * rtnl_link_af_data(const struct rtnl_link *link, const struct rtnl_link_af_ops *ops)
Return data buffer for link address family modules.
Definition: api.c:264
rtnl_link_unregister_info
int rtnl_link_unregister_info(struct rtnl_link_info_ops *ops)
Unregister operations for a link info type.
Definition: api.c:146
rtnl_link_af_ops_put
void rtnl_link_af_ops_put(struct rtnl_link_af_ops *ops)
Give back reference to a set of operations.
Definition: api.c:209
rtnl_link_info_ops_put
void rtnl_link_info_ops_put(struct rtnl_link_info_ops *ops)
Give back reference to a set of operations.
Definition: api.c:93
rtnl_link_info_ops_lookup
struct rtnl_link_info_ops * rtnl_link_info_ops_lookup(const char *name)
Return operations of a specific link info type.
Definition: api.c:77