libnl  3.2.24-rc1
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  */
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 
396 /** @} */
397