?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf bpf: Move perf_event_output() from stdio.h to bpf.h
[linux/fpc-iii.git] / net / batman-adv / sysfs.c
blob09427fc6494a157554d8b19f3481a878a9f97bba
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2010-2018 B.A.T.M.A.N. contributors:
3 *
4 * Marek Lindner
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include "sysfs.h"
20 #include "main.h"
21
22 #include <linux/atomic.h>
23 #include <linux/compiler.h>
24 #include <linux/device.h>
25 #include <linux/errno.h>
26 #include <linux/gfp.h>
27 #include <linux/if.h>
28 #include <linux/if_vlan.h>
29 #include <linux/kernel.h>
30 #include <linux/kobject.h>
31 #include <linux/kref.h>
32 #include <linux/netdevice.h>
33 #include <linux/printk.h>
34 #include <linux/rculist.h>
35 #include <linux/rcupdate.h>
36 #include <linux/rtnetlink.h>
37 #include <linux/slab.h>
38 #include <linux/stddef.h>
39 #include <linux/string.h>
40 #include <linux/stringify.h>
41 #include <linux/workqueue.h>
42 #include <uapi/linux/batadv_packet.h>
43
44 #include "bridge_loop_avoidance.h"
45 #include "distributed-arp-table.h"
46 #include "gateway_client.h"
47 #include "gateway_common.h"
48 #include "hard-interface.h"
49 #include "log.h"
50 #include "network-coding.h"
51 #include "soft-interface.h"
52
53 static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
54 {
55 struct device *dev = container_of(obj->parent, struct device, kobj);
56
57 return to_net_dev(dev);
58 }
59
60 static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
61 {
62 struct net_device *net_dev = batadv_kobj_to_netdev(obj);
63
64 return netdev_priv(net_dev);
65 }
66
67 /**
68 * batadv_vlan_kobj_to_batpriv() - convert a vlan kobj in the associated batpriv
69 * @obj: kobject to covert
70 *
71 * Return: the associated batadv_priv struct.
72 */
73 static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
74 {
75 /* VLAN specific attributes are located in the root sysfs folder if they
76 * refer to the untagged VLAN..
77 */
78 if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
79 return batadv_kobj_to_batpriv(obj);
80
81 /* ..while the attributes for the tagged vlans are located in
82 * the in the corresponding "vlan%VID" subfolder
83 */
84 return batadv_kobj_to_batpriv(obj->parent);
85 }
86
87 /**
88 * batadv_kobj_to_vlan() - convert a kobj in the associated softif_vlan struct
89 * @bat_priv: the bat priv with all the soft interface information
90 * @obj: kobject to covert
91 *
92 * Return: the associated softif_vlan struct if found, NULL otherwise.
93 */
94 static struct batadv_softif_vlan *
95 batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
96 {
97 struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
98
99 rcu_read_lock();
100 hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
101 if (vlan_tmp->kobj != obj)
102 continue;
103
104 if (!kref_get_unless_zero(&vlan_tmp->refcount))
105 continue;
106
107 vlan = vlan_tmp;
108 break;
109 }
110 rcu_read_unlock();
111
112 return vlan;
113 }
114
115 #define BATADV_UEV_TYPE_VAR "BATTYPE="
116 #define BATADV_UEV_ACTION_VAR "BATACTION="
117 #define BATADV_UEV_DATA_VAR "BATDATA="
118
119 static char *batadv_uev_action_str[] = {
120 "add",
121 "del",
122 "change",
123 "loopdetect",
124 };
125
126 static char *batadv_uev_type_str[] = {
127 "gw",
128 "bla",
129 };
130
131 /* Use this, if you have customized show and store functions for vlan attrs */
132 #define BATADV_ATTR_VLAN(_name, _mode, _show, _store) \
133 struct batadv_attribute batadv_attr_vlan_##_name = { \
134 .attr = {.name = __stringify(_name), \
135 .mode = _mode }, \
136 .show = _show, \
137 .store = _store, \
138 }
139
140 /* Use this, if you have customized show and store functions */
141 #define BATADV_ATTR(_name, _mode, _show, _store) \
142 struct batadv_attribute batadv_attr_##_name = { \
143 .attr = {.name = __stringify(_name), \
144 .mode = _mode }, \
145 .show = _show, \
146 .store = _store, \
147 }
148
149 #define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
150 ssize_t batadv_store_##_name(struct kobject *kobj, \
151 struct attribute *attr, char *buff, \
152 size_t count) \
153 { \
154 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
155 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
156 \
157 return __batadv_store_bool_attr(buff, count, _post_func, attr, \
158 &bat_priv->_name, net_dev); \
159 }
160
161 #define BATADV_ATTR_SIF_SHOW_BOOL(_name) \
162 ssize_t batadv_show_##_name(struct kobject *kobj, \
163 struct attribute *attr, char *buff) \
164 { \
165 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
166 \
167 return sprintf(buff, "%s\n", \
168 atomic_read(&bat_priv->_name) == 0 ? \
169 "disabled" : "enabled"); \
170 } \
171
172 /* Use this, if you are going to turn a [name] in the soft-interface
173 * (bat_priv) on or off
174 */
175 #define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func) \
176 static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
177 static BATADV_ATTR_SIF_SHOW_BOOL(_name) \
178 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
179 batadv_store_##_name)
180
181 #define BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func) \
182 ssize_t batadv_store_##_name(struct kobject *kobj, \
183 struct attribute *attr, char *buff, \
184 size_t count) \
185 { \
186 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
187 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
188 \
189 return __batadv_store_uint_attr(buff, count, _min, _max, \
190 _post_func, attr, \
191 &bat_priv->_var, net_dev, \
192 NULL); \
193 }
194
195 #define BATADV_ATTR_SIF_SHOW_UINT(_name, _var) \
196 ssize_t batadv_show_##_name(struct kobject *kobj, \
197 struct attribute *attr, char *buff) \
198 { \
199 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
200 \
201 return sprintf(buff, "%i\n", atomic_read(&bat_priv->_var)); \
202 } \
203
204 /* Use this, if you are going to set [name] in the soft-interface
205 * (bat_priv) to an unsigned integer value
206 */
207 #define BATADV_ATTR_SIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
208 static BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func)\
209 static BATADV_ATTR_SIF_SHOW_UINT(_name, _var) \
210 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
211 batadv_store_##_name)
212
213 #define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
214 ssize_t batadv_store_vlan_##_name(struct kobject *kobj, \
215 struct attribute *attr, char *buff, \
216 size_t count) \
217 { \
218 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
219 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
220 kobj); \
221 size_t res = __batadv_store_bool_attr(buff, count, _post_func, \
222 attr, &vlan->_name, \
223 bat_priv->soft_iface); \
224 \
225 batadv_softif_vlan_put(vlan); \
226 return res; \
227 }
228
229 #define BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
230 ssize_t batadv_show_vlan_##_name(struct kobject *kobj, \
231 struct attribute *attr, char *buff) \
232 { \
233 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
234 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
235 kobj); \
236 size_t res = sprintf(buff, "%s\n", \
237 atomic_read(&vlan->_name) == 0 ? \
238 "disabled" : "enabled"); \
239 \
240 batadv_softif_vlan_put(vlan); \
241 return res; \
242 }
243
244 /* Use this, if you are going to turn a [name] in the vlan struct on or off */
245 #define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func) \
246 static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
247 static BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
248 static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name, \
249 batadv_store_vlan_##_name)
250
251 #define BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min, _max, _post_func) \
252 ssize_t batadv_store_##_name(struct kobject *kobj, \
253 struct attribute *attr, char *buff, \
254 size_t count) \
255 { \
256 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
257 struct batadv_hard_iface *hard_iface; \
258 ssize_t length; \
259 \
260 hard_iface = batadv_hardif_get_by_netdev(net_dev); \
261 if (!hard_iface) \
262 return 0; \
263 \
264 length = __batadv_store_uint_attr(buff, count, _min, _max, \
265 _post_func, attr, \
266 &hard_iface->_var, \
267 hard_iface->soft_iface, \
268 net_dev); \
269 \
270 batadv_hardif_put(hard_iface); \
271 return length; \
272 }
273
274 #define BATADV_ATTR_HIF_SHOW_UINT(_name, _var) \
275 ssize_t batadv_show_##_name(struct kobject *kobj, \
276 struct attribute *attr, char *buff) \
277 { \
278 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
279 struct batadv_hard_iface *hard_iface; \
280 ssize_t length; \
281 \
282 hard_iface = batadv_hardif_get_by_netdev(net_dev); \
283 if (!hard_iface) \
284 return 0; \
285 \
286 length = sprintf(buff, "%i\n", atomic_read(&hard_iface->_var)); \
287 \
288 batadv_hardif_put(hard_iface); \
289 return length; \
290 }
291
292 /* Use this, if you are going to set [name] in hard_iface to an
293 * unsigned integer value
294 */
295 #define BATADV_ATTR_HIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
296 static BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min, \
297 _max, _post_func) \
298 static BATADV_ATTR_HIF_SHOW_UINT(_name, _var) \
299 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
300 batadv_store_##_name)
301
302 static int batadv_store_bool_attr(char *buff, size_t count,
303 struct net_device *net_dev,
304 const char *attr_name, atomic_t *attr,
305 bool *changed)
306 {
307 int enabled = -1;
308
309 *changed = false;
310
311 if (buff[count - 1] == '\n')
312 buff[count - 1] = '\0';
313
314 if ((strncmp(buff, "1", 2) == 0) ||
315 (strncmp(buff, "enable", 7) == 0) ||
316 (strncmp(buff, "enabled", 8) == 0))
317 enabled = 1;
318
319 if ((strncmp(buff, "0", 2) == 0) ||
320 (strncmp(buff, "disable", 8) == 0) ||
321 (strncmp(buff, "disabled", 9) == 0))
322 enabled = 0;
323
324 if (enabled < 0) {
325 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
326 attr_name, buff);
327 return -EINVAL;
328 }
329
330 if (atomic_read(attr) == enabled)
331 return count;
332
333 batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
334 atomic_read(attr) == 1 ? "enabled" : "disabled",
335 enabled == 1 ? "enabled" : "disabled");
336
337 *changed = true;
338
339 atomic_set(attr, (unsigned int)enabled);
340 return count;
341 }
342
343 static inline ssize_t
344 __batadv_store_bool_attr(char *buff, size_t count,
345 void (*post_func)(struct net_device *),
346 struct attribute *attr,
347 atomic_t *attr_store, struct net_device *net_dev)
348 {
349 bool changed;
350 int ret;
351
352 ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
353 attr_store, &changed);
354 if (post_func && changed)
355 post_func(net_dev);
356
357 return ret;
358 }
359
360 static int batadv_store_uint_attr(const char *buff, size_t count,
361 struct net_device *net_dev,
362 struct net_device *slave_dev,
363 const char *attr_name,
364 unsigned int min, unsigned int max,
365 atomic_t *attr)
366 {
367 char ifname[IFNAMSIZ + 3] = "";
368 unsigned long uint_val;
369 int ret;
370
371 ret = kstrtoul(buff, 10, &uint_val);
372 if (ret) {
373 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
374 attr_name, buff);
375 return -EINVAL;
376 }
377
378 if (uint_val < min) {
379 batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
380 attr_name, uint_val, min);
381 return -EINVAL;
382 }
383
384 if (uint_val > max) {
385 batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
386 attr_name, uint_val, max);
387 return -EINVAL;
388 }
389
390 if (atomic_read(attr) == uint_val)
391 return count;
392
393 if (slave_dev)
394 snprintf(ifname, sizeof(ifname), "%s: ", slave_dev->name);
395
396 batadv_info(net_dev, "%s: %sChanging from: %i to: %lu\n",
397 attr_name, ifname, atomic_read(attr), uint_val);
398
399 atomic_set(attr, uint_val);
400 return count;
401 }
402
403 static ssize_t __batadv_store_uint_attr(const char *buff, size_t count,
404 int min, int max,
405 void (*post_func)(struct net_device *),
406 const struct attribute *attr,
407 atomic_t *attr_store,
408 struct net_device *net_dev,
409 struct net_device *slave_dev)
410 {
411 int ret;
412
413 ret = batadv_store_uint_attr(buff, count, net_dev, slave_dev,
414 attr->name, min, max, attr_store);
415 if (post_func && ret)
416 post_func(net_dev);
417
418 return ret;
419 }
420
421 static ssize_t batadv_show_bat_algo(struct kobject *kobj,
422 struct attribute *attr, char *buff)
423 {
424 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
425
426 return sprintf(buff, "%s\n", bat_priv->algo_ops->name);
427 }
428
429 static void batadv_post_gw_reselect(struct net_device *net_dev)
430 {
431 struct batadv_priv *bat_priv = netdev_priv(net_dev);
432
433 batadv_gw_reselect(bat_priv);
434 }
435
436 static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
437 char *buff)
438 {
439 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
440 int bytes_written;
441
442 /* GW mode is not available if the routing algorithm in use does not
443 * implement the GW API
444 */
445 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
446 !bat_priv->algo_ops->gw.is_eligible)
447 return -ENOENT;
448
449 switch (atomic_read(&bat_priv->gw.mode)) {
450 case BATADV_GW_MODE_CLIENT:
451 bytes_written = sprintf(buff, "%s\n",
452 BATADV_GW_MODE_CLIENT_NAME);
453 break;
454 case BATADV_GW_MODE_SERVER:
455 bytes_written = sprintf(buff, "%s\n",
456 BATADV_GW_MODE_SERVER_NAME);
457 break;
458 default:
459 bytes_written = sprintf(buff, "%s\n",
460 BATADV_GW_MODE_OFF_NAME);
461 break;
462 }
463
464 return bytes_written;
465 }
466
467 static ssize_t batadv_store_gw_mode(struct kobject *kobj,
468 struct attribute *attr, char *buff,
469 size_t count)
470 {
471 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
472 struct batadv_priv *bat_priv = netdev_priv(net_dev);
473 char *curr_gw_mode_str;
474 int gw_mode_tmp = -1;
475
476 /* toggling GW mode is allowed only if the routing algorithm in use
477 * provides the GW API
478 */
479 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
480 !bat_priv->algo_ops->gw.is_eligible)
481 return -EINVAL;
482
483 if (buff[count - 1] == '\n')
484 buff[count - 1] = '\0';
485
486 if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
487 strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
488 gw_mode_tmp = BATADV_GW_MODE_OFF;
489
490 if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
491 strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
492 gw_mode_tmp = BATADV_GW_MODE_CLIENT;
493
494 if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
495 strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
496 gw_mode_tmp = BATADV_GW_MODE_SERVER;
497
498 if (gw_mode_tmp < 0) {
499 batadv_info(net_dev,
500 "Invalid parameter for 'gw mode' setting received: %s\n",
501 buff);
502 return -EINVAL;
503 }
504
505 if (atomic_read(&bat_priv->gw.mode) == gw_mode_tmp)
506 return count;
507
508 switch (atomic_read(&bat_priv->gw.mode)) {
509 case BATADV_GW_MODE_CLIENT:
510 curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
511 break;
512 case BATADV_GW_MODE_SERVER:
513 curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
514 break;
515 default:
516 curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
517 break;
518 }
519
520 batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
521 curr_gw_mode_str, buff);
522
523 /* Invoking batadv_gw_reselect() is not enough to really de-select the
524 * current GW. It will only instruct the gateway client code to perform
525 * a re-election the next time that this is needed.
526 *
527 * When gw client mode is being switched off the current GW must be
528 * de-selected explicitly otherwise no GW_ADD uevent is thrown on
529 * client mode re-activation. This is operation is performed in
530 * batadv_gw_check_client_stop().
531 */
532 batadv_gw_reselect(bat_priv);
533 /* always call batadv_gw_check_client_stop() before changing the gateway
534 * state
535 */
536 batadv_gw_check_client_stop(bat_priv);
537 atomic_set(&bat_priv->gw.mode, (unsigned int)gw_mode_tmp);
538 batadv_gw_tvlv_container_update(bat_priv);
539 return count;
540 }
541
542 static ssize_t batadv_show_gw_sel_class(struct kobject *kobj,
543 struct attribute *attr, char *buff)
544 {
545 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
546
547 /* GW selection class is not available if the routing algorithm in use
548 * does not implement the GW API
549 */
550 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
551 !bat_priv->algo_ops->gw.is_eligible)
552 return -ENOENT;
553
554 if (bat_priv->algo_ops->gw.show_sel_class)
555 return bat_priv->algo_ops->gw.show_sel_class(bat_priv, buff);
556
557 return sprintf(buff, "%i\n", atomic_read(&bat_priv->gw.sel_class));
558 }
559
560 static ssize_t batadv_store_gw_sel_class(struct kobject *kobj,
561 struct attribute *attr, char *buff,
562 size_t count)
563 {
564 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
565
566 /* setting the GW selection class is allowed only if the routing
567 * algorithm in use implements the GW API
568 */
569 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
570 !bat_priv->algo_ops->gw.is_eligible)
571 return -EINVAL;
572
573 if (buff[count - 1] == '\n')
574 buff[count - 1] = '\0';
575
576 if (bat_priv->algo_ops->gw.store_sel_class)
577 return bat_priv->algo_ops->gw.store_sel_class(bat_priv, buff,
578 count);
579
580 return __batadv_store_uint_attr(buff, count, 1, BATADV_TQ_MAX_VALUE,
581 batadv_post_gw_reselect, attr,
582 &bat_priv->gw.sel_class,
583 bat_priv->soft_iface, NULL);
584 }
585
586 static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
587 struct attribute *attr, char *buff)
588 {
589 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
590 u32 down, up;
591
592 down = atomic_read(&bat_priv->gw.bandwidth_down);
593 up = atomic_read(&bat_priv->gw.bandwidth_up);
594
595 return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
596 down % 10, up / 10, up % 10);
597 }
598
599 static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
600 struct attribute *attr, char *buff,
601 size_t count)
602 {
603 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
604
605 if (buff[count - 1] == '\n')
606 buff[count - 1] = '\0';
607
608 return batadv_gw_bandwidth_set(net_dev, buff, count);
609 }
610
611 /**
612 * batadv_show_isolation_mark() - print the current isolation mark/mask
613 * @kobj: kobject representing the private mesh sysfs directory
614 * @attr: the batman-adv attribute the user is interacting with
615 * @buff: the buffer that will contain the data to send back to the user
616 *
617 * Return: the number of bytes written into 'buff' on success or a negative
618 * error code in case of failure
619 */
620 static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
621 struct attribute *attr, char *buff)
622 {
623 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
624
625 return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
626 bat_priv->isolation_mark_mask);
627 }
628
629 /**
630 * batadv_store_isolation_mark() - parse and store the isolation mark/mask
631 * entered by the user
632 * @kobj: kobject representing the private mesh sysfs directory
633 * @attr: the batman-adv attribute the user is interacting with
634 * @buff: the buffer containing the user data
635 * @count: number of bytes in the buffer
636 *
637 * Return: 'count' on success or a negative error code in case of failure
638 */
639 static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
640 struct attribute *attr, char *buff,
641 size_t count)
642 {
643 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
644 struct batadv_priv *bat_priv = netdev_priv(net_dev);
645 u32 mark, mask;
646 char *mask_ptr;
647
648 /* parse the mask if it has been specified, otherwise assume the mask is
649 * the biggest possible
650 */
651 mask = 0xFFFFFFFF;
652 mask_ptr = strchr(buff, '/');
653 if (mask_ptr) {
654 *mask_ptr = '\0';
655 mask_ptr++;
656
657 /* the mask must be entered in hex base as it is going to be a
658 * bitmask and not a prefix length
659 */
660 if (kstrtou32(mask_ptr, 16, &mask) < 0)
661 return -EINVAL;
662 }
663
664 /* the mark can be entered in any base */
665 if (kstrtou32(buff, 0, &mark) < 0)
666 return -EINVAL;
667
668 bat_priv->isolation_mark_mask = mask;
669 /* erase bits not covered by the mask */
670 bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;
671
672 batadv_info(net_dev,
673 "New skb mark for extended isolation: %#.8x/%#.8x\n",
674 bat_priv->isolation_mark, bat_priv->isolation_mark_mask);
675
676 return count;
677 }
678
679 BATADV_ATTR_SIF_BOOL(aggregated_ogms, 0644, NULL);
680 BATADV_ATTR_SIF_BOOL(bonding, 0644, NULL);
681 #ifdef CONFIG_BATMAN_ADV_BLA
682 BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, 0644, batadv_bla_status_update);
683 #endif
684 #ifdef CONFIG_BATMAN_ADV_DAT
685 BATADV_ATTR_SIF_BOOL(distributed_arp_table, 0644, batadv_dat_status_update);
686 #endif
687 BATADV_ATTR_SIF_BOOL(fragmentation, 0644, batadv_update_min_mtu);
688 static BATADV_ATTR(routing_algo, 0444, batadv_show_bat_algo, NULL);
689 static BATADV_ATTR(gw_mode, 0644, batadv_show_gw_mode, batadv_store_gw_mode);
690 BATADV_ATTR_SIF_UINT(orig_interval, orig_interval, 0644, 2 * BATADV_JITTER,
691 INT_MAX, NULL);
692 BATADV_ATTR_SIF_UINT(hop_penalty, hop_penalty, 0644, 0, BATADV_TQ_MAX_VALUE,
693 NULL);
694 static BATADV_ATTR(gw_sel_class, 0644, batadv_show_gw_sel_class,
695 batadv_store_gw_sel_class);
696 static BATADV_ATTR(gw_bandwidth, 0644, batadv_show_gw_bwidth,
697 batadv_store_gw_bwidth);
698 #ifdef CONFIG_BATMAN_ADV_MCAST
699 BATADV_ATTR_SIF_BOOL(multicast_mode, 0644, NULL);
700 #endif
701 #ifdef CONFIG_BATMAN_ADV_DEBUG
702 BATADV_ATTR_SIF_UINT(log_level, log_level, 0644, 0, BATADV_DBG_ALL, NULL);
703 #endif
704 #ifdef CONFIG_BATMAN_ADV_NC
705 BATADV_ATTR_SIF_BOOL(network_coding, 0644, batadv_nc_status_update);
706 #endif
707 static BATADV_ATTR(isolation_mark, 0644, batadv_show_isolation_mark,
708 batadv_store_isolation_mark);
709
710 static struct batadv_attribute *batadv_mesh_attrs[] = {
711 &batadv_attr_aggregated_ogms,
712 &batadv_attr_bonding,
713 #ifdef CONFIG_BATMAN_ADV_BLA
714 &batadv_attr_bridge_loop_avoidance,
715 #endif
716 #ifdef CONFIG_BATMAN_ADV_DAT
717 &batadv_attr_distributed_arp_table,
718 #endif
719 #ifdef CONFIG_BATMAN_ADV_MCAST
720 &batadv_attr_multicast_mode,
721 #endif
722 &batadv_attr_fragmentation,
723 &batadv_attr_routing_algo,
724 &batadv_attr_gw_mode,
725 &batadv_attr_orig_interval,
726 &batadv_attr_hop_penalty,
727 &batadv_attr_gw_sel_class,
728 &batadv_attr_gw_bandwidth,
729 #ifdef CONFIG_BATMAN_ADV_DEBUG
730 &batadv_attr_log_level,
731 #endif
732 #ifdef CONFIG_BATMAN_ADV_NC
733 &batadv_attr_network_coding,
734 #endif
735 &batadv_attr_isolation_mark,
736 NULL,
737 };
738
739 BATADV_ATTR_VLAN_BOOL(ap_isolation, 0644, NULL);
740
741 /* array of vlan specific sysfs attributes */
742 static struct batadv_attribute *batadv_vlan_attrs[] = {
743 &batadv_attr_vlan_ap_isolation,
744 NULL,
745 };
746
747 /**
748 * batadv_sysfs_add_meshif() - Add soft interface specific sysfs entries
749 * @dev: netdev struct of the soft interface
750 *
751 * Return: 0 on success or negative error number in case of failure
752 */
753 int batadv_sysfs_add_meshif(struct net_device *dev)
754 {
755 struct kobject *batif_kobject = &dev->dev.kobj;
756 struct batadv_priv *bat_priv = netdev_priv(dev);
757 struct batadv_attribute **bat_attr;
758 int err;
759
760 bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
761 batif_kobject);
762 if (!bat_priv->mesh_obj) {
763 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
764 BATADV_SYSFS_IF_MESH_SUBDIR);
765 goto out;
766 }
767
768 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
769 err = sysfs_create_file(bat_priv->mesh_obj,
770 &((*bat_attr)->attr));
771 if (err) {
772 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
773 dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
774 ((*bat_attr)->attr).name);
775 goto rem_attr;
776 }
777 }
778
779 return 0;
780
781 rem_attr:
782 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
783 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
784
785 kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
786 kobject_del(bat_priv->mesh_obj);
787 kobject_put(bat_priv->mesh_obj);
788 bat_priv->mesh_obj = NULL;
789 out:
790 return -ENOMEM;
791 }
792
793 /**
794 * batadv_sysfs_del_meshif() - Remove soft interface specific sysfs entries
795 * @dev: netdev struct of the soft interface
796 */
797 void batadv_sysfs_del_meshif(struct net_device *dev)
798 {
799 struct batadv_priv *bat_priv = netdev_priv(dev);
800 struct batadv_attribute **bat_attr;
801
802 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
803 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
804
805 kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
806 kobject_del(bat_priv->mesh_obj);
807 kobject_put(bat_priv->mesh_obj);
808 bat_priv->mesh_obj = NULL;
809 }
810
811 /**
812 * batadv_sysfs_add_vlan() - add all the needed sysfs objects for the new vlan
813 * @dev: netdev of the mesh interface
814 * @vlan: private data of the newly added VLAN interface
815 *
816 * Return: 0 on success and -ENOMEM if any of the structure allocations fails.
817 */
818 int batadv_sysfs_add_vlan(struct net_device *dev,
819 struct batadv_softif_vlan *vlan)
820 {
821 char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
822 struct batadv_priv *bat_priv = netdev_priv(dev);
823 struct batadv_attribute **bat_attr;
824 int err;
825
826 if (vlan->vid & BATADV_VLAN_HAS_TAG) {
827 sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
828 vlan->vid & VLAN_VID_MASK);
829
830 vlan->kobj = kobject_create_and_add(vlan_subdir,
831 bat_priv->mesh_obj);
832 if (!vlan->kobj) {
833 batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
834 dev->name, vlan_subdir);
835 goto out;
836 }
837 } else {
838 /* the untagged LAN uses the root folder to store its "VLAN
839 * specific attributes"
840 */
841 vlan->kobj = bat_priv->mesh_obj;
842 kobject_get(bat_priv->mesh_obj);
843 }
844
845 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
846 err = sysfs_create_file(vlan->kobj,
847 &((*bat_attr)->attr));
848 if (err) {
849 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
850 dev->name, vlan_subdir,
851 ((*bat_attr)->attr).name);
852 goto rem_attr;
853 }
854 }
855
856 return 0;
857
858 rem_attr:
859 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
860 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
861
862 if (vlan->kobj != bat_priv->mesh_obj) {
863 kobject_uevent(vlan->kobj, KOBJ_REMOVE);
864 kobject_del(vlan->kobj);
865 }
866 kobject_put(vlan->kobj);
867 vlan->kobj = NULL;
868 out:
869 return -ENOMEM;
870 }
871
872 /**
873 * batadv_sysfs_del_vlan() - remove all the sysfs objects for a given VLAN
874 * @bat_priv: the bat priv with all the soft interface information
875 * @vlan: the private data of the VLAN to destroy
876 */
877 void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
878 struct batadv_softif_vlan *vlan)
879 {
880 struct batadv_attribute **bat_attr;
881
882 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
883 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
884
885 if (vlan->kobj != bat_priv->mesh_obj) {
886 kobject_uevent(vlan->kobj, KOBJ_REMOVE);
887 kobject_del(vlan->kobj);
888 }
889 kobject_put(vlan->kobj);
890 vlan->kobj = NULL;
891 }
892
893 static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
894 struct attribute *attr, char *buff)
895 {
896 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
897 struct batadv_hard_iface *hard_iface;
898 ssize_t length;
899 const char *ifname;
900
901 hard_iface = batadv_hardif_get_by_netdev(net_dev);
902 if (!hard_iface)
903 return 0;
904
905 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
906 ifname = "none";
907 else
908 ifname = hard_iface->soft_iface->name;
909
910 length = sprintf(buff, "%s\n", ifname);
911
912 batadv_hardif_put(hard_iface);
913
914 return length;
915 }
916
917 /**
918 * batadv_store_mesh_iface_finish() - store new hardif mesh_iface state
919 * @net_dev: netdevice to add/remove to/from batman-adv soft-interface
920 * @ifname: name of soft-interface to modify
921 *
922 * Changes the parts of the hard+soft interface which can not be modified under
923 * sysfs lock (to prevent deadlock situations).
924 *
925 * Return: 0 on success, 0 < on failure
926 */
927 static int batadv_store_mesh_iface_finish(struct net_device *net_dev,
928 char ifname[IFNAMSIZ])
929 {
930 struct net *net = dev_net(net_dev);
931 struct batadv_hard_iface *hard_iface;
932 int status_tmp;
933 int ret = 0;
934
935 ASSERT_RTNL();
936
937 hard_iface = batadv_hardif_get_by_netdev(net_dev);
938 if (!hard_iface)
939 return 0;
940
941 if (strncmp(ifname, "none", 4) == 0)
942 status_tmp = BATADV_IF_NOT_IN_USE;
943 else
944 status_tmp = BATADV_IF_I_WANT_YOU;
945
946 if (hard_iface->if_status == status_tmp)
947 goto out;
948
949 if (hard_iface->soft_iface &&
950 strncmp(hard_iface->soft_iface->name, ifname, IFNAMSIZ) == 0)
951 goto out;
952
953 if (status_tmp == BATADV_IF_NOT_IN_USE) {
954 batadv_hardif_disable_interface(hard_iface,
955 BATADV_IF_CLEANUP_AUTO);
956 goto out;
957 }
958
959 /* if the interface already is in use */
960 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
961 batadv_hardif_disable_interface(hard_iface,
962 BATADV_IF_CLEANUP_AUTO);
963
964 ret = batadv_hardif_enable_interface(hard_iface, net, ifname);
965 out:
966 batadv_hardif_put(hard_iface);
967 return ret;
968 }
969
970 /**
971 * batadv_store_mesh_iface_work() - store new hardif mesh_iface state
972 * @work: work queue item
973 *
974 * Changes the parts of the hard+soft interface which can not be modified under
975 * sysfs lock (to prevent deadlock situations).
976 */
977 static void batadv_store_mesh_iface_work(struct work_struct *work)
978 {
979 struct batadv_store_mesh_work *store_work;
980 int ret;
981
982 store_work = container_of(work, struct batadv_store_mesh_work, work);
983
984 rtnl_lock();
985 ret = batadv_store_mesh_iface_finish(store_work->net_dev,
986 store_work->soft_iface_name);
987 rtnl_unlock();
988
989 if (ret < 0)
990 pr_err("Failed to store new mesh_iface state %s for %s: %d\n",
991 store_work->soft_iface_name, store_work->net_dev->name,
992 ret);
993
994 dev_put(store_work->net_dev);
995 kfree(store_work);
996 }
997
998 static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
999 struct attribute *attr, char *buff,
1000 size_t count)
1001 {
1002 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1003 struct batadv_store_mesh_work *store_work;
1004
1005 if (buff[count - 1] == '\n')
1006 buff[count - 1] = '\0';
1007
1008 if (strlen(buff) >= IFNAMSIZ) {
1009 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
1010 buff);
1011 return -EINVAL;
1012 }
1013
1014 store_work = kmalloc(sizeof(*store_work), GFP_KERNEL);
1015 if (!store_work)
1016 return -ENOMEM;
1017
1018 dev_hold(net_dev);
1019 INIT_WORK(&store_work->work, batadv_store_mesh_iface_work);
1020 store_work->net_dev = net_dev;
1021 strlcpy(store_work->soft_iface_name, buff,
1022 sizeof(store_work->soft_iface_name));
1023
1024 queue_work(batadv_event_workqueue, &store_work->work);
1025
1026 return count;
1027 }
1028
1029 static ssize_t batadv_show_iface_status(struct kobject *kobj,
1030 struct attribute *attr, char *buff)
1031 {
1032 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1033 struct batadv_hard_iface *hard_iface;
1034 ssize_t length;
1035
1036 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1037 if (!hard_iface)
1038 return 0;
1039
1040 switch (hard_iface->if_status) {
1041 case BATADV_IF_TO_BE_REMOVED:
1042 length = sprintf(buff, "disabling\n");
1043 break;
1044 case BATADV_IF_INACTIVE:
1045 length = sprintf(buff, "inactive\n");
1046 break;
1047 case BATADV_IF_ACTIVE:
1048 length = sprintf(buff, "active\n");
1049 break;
1050 case BATADV_IF_TO_BE_ACTIVATED:
1051 length = sprintf(buff, "enabling\n");
1052 break;
1053 case BATADV_IF_NOT_IN_USE:
1054 default:
1055 length = sprintf(buff, "not in use\n");
1056 break;
1057 }
1058
1059 batadv_hardif_put(hard_iface);
1060
1061 return length;
1062 }
1063
1064 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
1065
1066 /**
1067 * batadv_store_throughput_override() - parse and store throughput override
1068 * entered by the user
1069 * @kobj: kobject representing the private mesh sysfs directory
1070 * @attr: the batman-adv attribute the user is interacting with
1071 * @buff: the buffer containing the user data
1072 * @count: number of bytes in the buffer
1073 *
1074 * Return: 'count' on success or a negative error code in case of failure
1075 */
1076 static ssize_t batadv_store_throughput_override(struct kobject *kobj,
1077 struct attribute *attr,
1078 char *buff, size_t count)
1079 {
1080 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1081 struct batadv_hard_iface *hard_iface;
1082 u32 tp_override;
1083 u32 old_tp_override;
1084 bool ret;
1085
1086 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1087 if (!hard_iface)
1088 return -EINVAL;
1089
1090 if (buff[count - 1] == '\n')
1091 buff[count - 1] = '\0';
1092
1093 ret = batadv_parse_throughput(net_dev, buff, "throughput_override",
1094 &tp_override);
1095 if (!ret)
1096 return count;
1097
1098 old_tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
1099 if (old_tp_override == tp_override)
1100 goto out;
1101
1102 batadv_info(hard_iface->soft_iface,
1103 "%s: %s: Changing from: %u.%u MBit to: %u.%u MBit\n",
1104 "throughput_override", net_dev->name,
1105 old_tp_override / 10, old_tp_override % 10,
1106 tp_override / 10, tp_override % 10);
1107
1108 atomic_set(&hard_iface->bat_v.throughput_override, tp_override);
1109
1110 out:
1111 batadv_hardif_put(hard_iface);
1112 return count;
1113 }
1114
1115 static ssize_t batadv_show_throughput_override(struct kobject *kobj,
1116 struct attribute *attr,
1117 char *buff)
1118 {
1119 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1120 struct batadv_hard_iface *hard_iface;
1121 u32 tp_override;
1122
1123 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1124 if (!hard_iface)
1125 return -EINVAL;
1126
1127 tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
1128
1129 return sprintf(buff, "%u.%u MBit\n", tp_override / 10,
1130 tp_override % 10);
1131 }
1132
1133 #endif
1134
1135 static BATADV_ATTR(mesh_iface, 0644, batadv_show_mesh_iface,
1136 batadv_store_mesh_iface);
1137 static BATADV_ATTR(iface_status, 0444, batadv_show_iface_status, NULL);
1138 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
1139 BATADV_ATTR_HIF_UINT(elp_interval, bat_v.elp_interval, 0644,
1140 2 * BATADV_JITTER, INT_MAX, NULL);
1141 static BATADV_ATTR(throughput_override, 0644, batadv_show_throughput_override,
1142 batadv_store_throughput_override);
1143 #endif
1144
1145 static struct batadv_attribute *batadv_batman_attrs[] = {
1146 &batadv_attr_mesh_iface,
1147 &batadv_attr_iface_status,
1148 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
1149 &batadv_attr_elp_interval,
1150 &batadv_attr_throughput_override,
1151 #endif
1152 NULL,
1153 };
1154
1155 /**
1156 * batadv_sysfs_add_hardif() - Add hard interface specific sysfs entries
1157 * @hardif_obj: address where to store the pointer to new sysfs folder
1158 * @dev: netdev struct of the hard interface
1159 *
1160 * Return: 0 on success or negative error number in case of failure
1161 */
1162 int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
1163 {
1164 struct kobject *hardif_kobject = &dev->dev.kobj;
1165 struct batadv_attribute **bat_attr;
1166 int err;
1167
1168 *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
1169 hardif_kobject);
1170
1171 if (!*hardif_obj) {
1172 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
1173 BATADV_SYSFS_IF_BAT_SUBDIR);
1174 goto out;
1175 }
1176
1177 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
1178 err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
1179 if (err) {
1180 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
1181 dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
1182 ((*bat_attr)->attr).name);
1183 goto rem_attr;
1184 }
1185 }
1186
1187 return 0;
1188
1189 rem_attr:
1190 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
1191 sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
1192 out:
1193 return -ENOMEM;
1194 }
1195
1196 /**
1197 * batadv_sysfs_del_hardif() - Remove hard interface specific sysfs entries
1198 * @hardif_obj: address to the pointer to which stores batman-adv sysfs folder
1199 * of the hard interface
1200 */
1201 void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
1202 {
1203 kobject_uevent(*hardif_obj, KOBJ_REMOVE);
1204 kobject_del(*hardif_obj);
1205 kobject_put(*hardif_obj);
1206 *hardif_obj = NULL;
1207 }
1208
1209 /**
1210 * batadv_throw_uevent() - Send an uevent with batman-adv specific env data
1211 * @bat_priv: the bat priv with all the soft interface information
1212 * @type: subsystem type of event. Stored in uevent's BATTYPE
1213 * @action: action type of event. Stored in uevent's BATACTION
1214 * @data: string with additional information to the event (ignored for
1215 * BATADV_UEV_DEL). Stored in uevent's BATDATA
1216 *
1217 * Return: 0 on success or negative error number in case of failure
1218 */
1219 int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
1220 enum batadv_uev_action action, const char *data)
1221 {
1222 int ret = -ENOMEM;
1223 struct kobject *bat_kobj;
1224 char *uevent_env[4] = { NULL, NULL, NULL, NULL };
1225
1226 bat_kobj = &bat_priv->soft_iface->dev.kobj;
1227
1228 uevent_env[0] = kasprintf(GFP_ATOMIC,
1229 "%s%s", BATADV_UEV_TYPE_VAR,
1230 batadv_uev_type_str[type]);
1231 if (!uevent_env[0])
1232 goto out;
1233
1234 uevent_env[1] = kasprintf(GFP_ATOMIC,
1235 "%s%s", BATADV_UEV_ACTION_VAR,
1236 batadv_uev_action_str[action]);
1237 if (!uevent_env[1])
1238 goto out;
1239
1240 /* If the event is DEL, ignore the data field */
1241 if (action != BATADV_UEV_DEL) {
1242 uevent_env[2] = kasprintf(GFP_ATOMIC,
1243 "%s%s", BATADV_UEV_DATA_VAR, data);
1244 if (!uevent_env[2])
1245 goto out;
1246 }
1247
1248 ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
1249 out:
1250 kfree(uevent_env[0]);
1251 kfree(uevent_env[1]);
1252 kfree(uevent_env[2]);
1253
1254 if (ret)
1255 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1256 "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
1257 batadv_uev_type_str[type],
1258 batadv_uev_action_str[action],
1259 (action == BATADV_UEV_DEL ? "NULL" : data), ret);
1260 return ret;
1261 }
Linux with added FPC-III support