1 /* Copyright (C) 2010-2013 B.A.T.M.A.N. contributors:
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 #include "translation-table.h"
23 #include "distributed-arp-table.h"
24 #include "network-coding.h"
25 #include "originator.h"
26 #include "hard-interface.h"
27 #include "gateway_common.h"
28 #include "gateway_client.h"
30 static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
32 struct device *dev = container_of(obj->parent, struct device, kobj);
33 return to_net_dev(dev);
36 static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
38 struct net_device *net_dev = batadv_kobj_to_netdev(obj);
39 return netdev_priv(net_dev);
42 #define BATADV_UEV_TYPE_VAR "BATTYPE="
43 #define BATADV_UEV_ACTION_VAR "BATACTION="
44 #define BATADV_UEV_DATA_VAR "BATDATA="
46 static char *batadv_uev_action_str[] = {
52 static char *batadv_uev_type_str[] = {
56 /* Use this, if you have customized show and store functions */
57 #define BATADV_ATTR(_name, _mode, _show, _store) \
58 struct batadv_attribute batadv_attr_##_name = { \
59 .attr = {.name = __stringify(_name), \
65 #define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
66 ssize_t batadv_store_##_name(struct kobject *kobj, \
67 struct attribute *attr, char *buff, \
70 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
71 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
72 return __batadv_store_bool_attr(buff, count, _post_func, attr, \
73 &bat_priv->_name, net_dev); \
76 #define BATADV_ATTR_SIF_SHOW_BOOL(_name) \
77 ssize_t batadv_show_##_name(struct kobject *kobj, \
78 struct attribute *attr, char *buff) \
80 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
81 return sprintf(buff, "%s\n", \
82 atomic_read(&bat_priv->_name) == 0 ? \
83 "disabled" : "enabled"); \
86 /* Use this, if you are going to turn a [name] in the soft-interface
87 * (bat_priv) on or off
89 #define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func) \
90 static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
91 static BATADV_ATTR_SIF_SHOW_BOOL(_name) \
92 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
96 #define BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func) \
97 ssize_t batadv_store_##_name(struct kobject *kobj, \
98 struct attribute *attr, char *buff, \
101 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
102 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
103 return __batadv_store_uint_attr(buff, count, _min, _max, \
105 &bat_priv->_name, net_dev); \
108 #define BATADV_ATTR_SIF_SHOW_UINT(_name) \
109 ssize_t batadv_show_##_name(struct kobject *kobj, \
110 struct attribute *attr, char *buff) \
112 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
113 return sprintf(buff, "%i\n", atomic_read(&bat_priv->_name)); \
116 /* Use this, if you are going to set [name] in the soft-interface
117 * (bat_priv) to an unsigned integer value
119 #define BATADV_ATTR_SIF_UINT(_name, _mode, _min, _max, _post_func) \
120 static BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func)\
121 static BATADV_ATTR_SIF_SHOW_UINT(_name) \
122 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
123 batadv_store_##_name)
126 static int batadv_store_bool_attr(char *buff, size_t count,
127 struct net_device *net_dev,
128 const char *attr_name, atomic_t *attr)
132 if (buff[count - 1] == '\n')
133 buff[count - 1] = '\0';
135 if ((strncmp(buff, "1", 2) == 0) ||
136 (strncmp(buff, "enable", 7) == 0) ||
137 (strncmp(buff, "enabled", 8) == 0))
140 if ((strncmp(buff, "0", 2) == 0) ||
141 (strncmp(buff, "disable", 8) == 0) ||
142 (strncmp(buff, "disabled", 9) == 0))
146 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
151 if (atomic_read(attr) == enabled)
154 batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
155 atomic_read(attr) == 1 ? "enabled" : "disabled",
156 enabled == 1 ? "enabled" : "disabled");
158 atomic_set(attr, (unsigned int)enabled);
162 static inline ssize_t
163 __batadv_store_bool_attr(char *buff, size_t count,
164 void (*post_func)(struct net_device *),
165 struct attribute *attr,
166 atomic_t *attr_store, struct net_device *net_dev)
170 ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
172 if (post_func && ret)
178 static int batadv_store_uint_attr(const char *buff, size_t count,
179 struct net_device *net_dev,
180 const char *attr_name,
181 unsigned int min, unsigned int max,
184 unsigned long uint_val;
187 ret = kstrtoul(buff, 10, &uint_val);
189 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
194 if (uint_val < min) {
195 batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
196 attr_name, uint_val, min);
200 if (uint_val > max) {
201 batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
202 attr_name, uint_val, max);
206 if (atomic_read(attr) == uint_val)
209 batadv_info(net_dev, "%s: Changing from: %i to: %lu\n",
210 attr_name, atomic_read(attr), uint_val);
212 atomic_set(attr, uint_val);
216 static inline ssize_t
217 __batadv_store_uint_attr(const char *buff, size_t count,
219 void (*post_func)(struct net_device *),
220 const struct attribute *attr,
221 atomic_t *attr_store, struct net_device *net_dev)
225 ret = batadv_store_uint_attr(buff, count, net_dev, attr->name, min, max,
227 if (post_func && ret)
233 static ssize_t batadv_show_bat_algo(struct kobject *kobj,
234 struct attribute *attr, char *buff)
236 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
237 return sprintf(buff, "%s\n", bat_priv->bat_algo_ops->name);
240 static void batadv_post_gw_deselect(struct net_device *net_dev)
242 struct batadv_priv *bat_priv = netdev_priv(net_dev);
243 batadv_gw_deselect(bat_priv);
246 static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
249 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
252 switch (atomic_read(&bat_priv->gw_mode)) {
253 case BATADV_GW_MODE_CLIENT:
254 bytes_written = sprintf(buff, "%s\n",
255 BATADV_GW_MODE_CLIENT_NAME);
257 case BATADV_GW_MODE_SERVER:
258 bytes_written = sprintf(buff, "%s\n",
259 BATADV_GW_MODE_SERVER_NAME);
262 bytes_written = sprintf(buff, "%s\n",
263 BATADV_GW_MODE_OFF_NAME);
267 return bytes_written;
270 static ssize_t batadv_store_gw_mode(struct kobject *kobj,
271 struct attribute *attr, char *buff,
274 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
275 struct batadv_priv *bat_priv = netdev_priv(net_dev);
276 char *curr_gw_mode_str;
277 int gw_mode_tmp = -1;
279 if (buff[count - 1] == '\n')
280 buff[count - 1] = '\0';
282 if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
283 strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
284 gw_mode_tmp = BATADV_GW_MODE_OFF;
286 if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
287 strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
288 gw_mode_tmp = BATADV_GW_MODE_CLIENT;
290 if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
291 strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
292 gw_mode_tmp = BATADV_GW_MODE_SERVER;
294 if (gw_mode_tmp < 0) {
296 "Invalid parameter for 'gw mode' setting received: %s\n",
301 if (atomic_read(&bat_priv->gw_mode) == gw_mode_tmp)
304 switch (atomic_read(&bat_priv->gw_mode)) {
305 case BATADV_GW_MODE_CLIENT:
306 curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
308 case BATADV_GW_MODE_SERVER:
309 curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
312 curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
316 batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
317 curr_gw_mode_str, buff);
319 batadv_gw_deselect(bat_priv);
320 /* always call batadv_gw_check_client_stop() before changing the gateway
323 batadv_gw_check_client_stop(bat_priv);
324 atomic_set(&bat_priv->gw_mode, (unsigned int)gw_mode_tmp);
325 batadv_gw_tvlv_container_update(bat_priv);
329 static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
330 struct attribute *attr, char *buff)
332 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
335 down = atomic_read(&bat_priv->gw.bandwidth_down);
336 up = atomic_read(&bat_priv->gw.bandwidth_up);
338 return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
339 down % 10, up / 10, up % 10);
342 static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
343 struct attribute *attr, char *buff,
346 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
348 if (buff[count - 1] == '\n')
349 buff[count - 1] = '\0';
351 return batadv_gw_bandwidth_set(net_dev, buff, count);
354 BATADV_ATTR_SIF_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL);
355 BATADV_ATTR_SIF_BOOL(bonding, S_IRUGO | S_IWUSR, NULL);
356 #ifdef CONFIG_BATMAN_ADV_BLA
357 BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, S_IRUGO | S_IWUSR, NULL);
359 #ifdef CONFIG_BATMAN_ADV_DAT
360 BATADV_ATTR_SIF_BOOL(distributed_arp_table, S_IRUGO | S_IWUSR,
361 batadv_dat_status_update);
363 BATADV_ATTR_SIF_BOOL(fragmentation, S_IRUGO | S_IWUSR, batadv_update_min_mtu);
364 BATADV_ATTR_SIF_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL);
365 static BATADV_ATTR(routing_algo, S_IRUGO, batadv_show_bat_algo, NULL);
366 static BATADV_ATTR(gw_mode, S_IRUGO | S_IWUSR, batadv_show_gw_mode,
367 batadv_store_gw_mode);
368 BATADV_ATTR_SIF_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * BATADV_JITTER,
370 BATADV_ATTR_SIF_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, BATADV_TQ_MAX_VALUE,
372 BATADV_ATTR_SIF_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, BATADV_TQ_MAX_VALUE,
373 batadv_post_gw_deselect);
374 static BATADV_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, batadv_show_gw_bwidth,
375 batadv_store_gw_bwidth);
376 #ifdef CONFIG_BATMAN_ADV_DEBUG
377 BATADV_ATTR_SIF_UINT(log_level, S_IRUGO | S_IWUSR, 0, BATADV_DBG_ALL, NULL);
379 #ifdef CONFIG_BATMAN_ADV_NC
380 BATADV_ATTR_SIF_BOOL(network_coding, S_IRUGO | S_IWUSR,
381 batadv_nc_status_update);
384 static struct batadv_attribute *batadv_mesh_attrs[] = {
385 &batadv_attr_aggregated_ogms,
386 &batadv_attr_bonding,
387 #ifdef CONFIG_BATMAN_ADV_BLA
388 &batadv_attr_bridge_loop_avoidance,
390 #ifdef CONFIG_BATMAN_ADV_DAT
391 &batadv_attr_distributed_arp_table,
393 &batadv_attr_fragmentation,
394 &batadv_attr_ap_isolation,
395 &batadv_attr_routing_algo,
396 &batadv_attr_gw_mode,
397 &batadv_attr_orig_interval,
398 &batadv_attr_hop_penalty,
399 &batadv_attr_gw_sel_class,
400 &batadv_attr_gw_bandwidth,
401 #ifdef CONFIG_BATMAN_ADV_DEBUG
402 &batadv_attr_log_level,
404 #ifdef CONFIG_BATMAN_ADV_NC
405 &batadv_attr_network_coding,
410 int batadv_sysfs_add_meshif(struct net_device *dev)
412 struct kobject *batif_kobject = &dev->dev.kobj;
413 struct batadv_priv *bat_priv = netdev_priv(dev);
414 struct batadv_attribute **bat_attr;
417 bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
419 if (!bat_priv->mesh_obj) {
420 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
421 BATADV_SYSFS_IF_MESH_SUBDIR);
425 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
426 err = sysfs_create_file(bat_priv->mesh_obj,
427 &((*bat_attr)->attr));
429 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
430 dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
431 ((*bat_attr)->attr).name);
439 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
440 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
442 kobject_put(bat_priv->mesh_obj);
443 bat_priv->mesh_obj = NULL;
448 void batadv_sysfs_del_meshif(struct net_device *dev)
450 struct batadv_priv *bat_priv = netdev_priv(dev);
451 struct batadv_attribute **bat_attr;
453 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
454 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
456 kobject_put(bat_priv->mesh_obj);
457 bat_priv->mesh_obj = NULL;
460 static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
461 struct attribute *attr, char *buff)
463 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
464 struct batadv_hard_iface *hard_iface;
468 hard_iface = batadv_hardif_get_by_netdev(net_dev);
472 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
475 ifname = hard_iface->soft_iface->name;
477 length = sprintf(buff, "%s\n", ifname);
479 batadv_hardif_free_ref(hard_iface);
484 static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
485 struct attribute *attr, char *buff,
488 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
489 struct batadv_hard_iface *hard_iface;
493 hard_iface = batadv_hardif_get_by_netdev(net_dev);
497 if (buff[count - 1] == '\n')
498 buff[count - 1] = '\0';
500 if (strlen(buff) >= IFNAMSIZ) {
501 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
503 batadv_hardif_free_ref(hard_iface);
507 if (strncmp(buff, "none", 4) == 0)
508 status_tmp = BATADV_IF_NOT_IN_USE;
510 status_tmp = BATADV_IF_I_WANT_YOU;
512 if (hard_iface->if_status == status_tmp)
515 if ((hard_iface->soft_iface) &&
516 (strncmp(hard_iface->soft_iface->name, buff, IFNAMSIZ) == 0))
521 if (status_tmp == BATADV_IF_NOT_IN_USE) {
522 batadv_hardif_disable_interface(hard_iface,
523 BATADV_IF_CLEANUP_AUTO);
527 /* if the interface already is in use */
528 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
529 batadv_hardif_disable_interface(hard_iface,
530 BATADV_IF_CLEANUP_AUTO);
532 ret = batadv_hardif_enable_interface(hard_iface, buff);
537 batadv_hardif_free_ref(hard_iface);
541 static ssize_t batadv_show_iface_status(struct kobject *kobj,
542 struct attribute *attr, char *buff)
544 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
545 struct batadv_hard_iface *hard_iface;
548 hard_iface = batadv_hardif_get_by_netdev(net_dev);
552 switch (hard_iface->if_status) {
553 case BATADV_IF_TO_BE_REMOVED:
554 length = sprintf(buff, "disabling\n");
556 case BATADV_IF_INACTIVE:
557 length = sprintf(buff, "inactive\n");
559 case BATADV_IF_ACTIVE:
560 length = sprintf(buff, "active\n");
562 case BATADV_IF_TO_BE_ACTIVATED:
563 length = sprintf(buff, "enabling\n");
565 case BATADV_IF_NOT_IN_USE:
567 length = sprintf(buff, "not in use\n");
571 batadv_hardif_free_ref(hard_iface);
576 static BATADV_ATTR(mesh_iface, S_IRUGO | S_IWUSR, batadv_show_mesh_iface,
577 batadv_store_mesh_iface);
578 static BATADV_ATTR(iface_status, S_IRUGO, batadv_show_iface_status, NULL);
580 static struct batadv_attribute *batadv_batman_attrs[] = {
581 &batadv_attr_mesh_iface,
582 &batadv_attr_iface_status,
586 int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
588 struct kobject *hardif_kobject = &dev->dev.kobj;
589 struct batadv_attribute **bat_attr;
592 *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
596 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
597 BATADV_SYSFS_IF_BAT_SUBDIR);
601 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
602 err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
604 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
605 dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
606 ((*bat_attr)->attr).name);
614 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
615 sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
620 void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
622 kobject_put(*hardif_obj);
626 int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
627 enum batadv_uev_action action, const char *data)
630 struct kobject *bat_kobj;
631 char *uevent_env[4] = { NULL, NULL, NULL, NULL };
633 bat_kobj = &bat_priv->soft_iface->dev.kobj;
635 uevent_env[0] = kmalloc(strlen(BATADV_UEV_TYPE_VAR) +
636 strlen(batadv_uev_type_str[type]) + 1,
641 sprintf(uevent_env[0], "%s%s", BATADV_UEV_TYPE_VAR,
642 batadv_uev_type_str[type]);
644 uevent_env[1] = kmalloc(strlen(BATADV_UEV_ACTION_VAR) +
645 strlen(batadv_uev_action_str[action]) + 1,
650 sprintf(uevent_env[1], "%s%s", BATADV_UEV_ACTION_VAR,
651 batadv_uev_action_str[action]);
653 /* If the event is DEL, ignore the data field */
654 if (action != BATADV_UEV_DEL) {
655 uevent_env[2] = kmalloc(strlen(BATADV_UEV_DATA_VAR) +
656 strlen(data) + 1, GFP_ATOMIC);
660 sprintf(uevent_env[2], "%s%s", BATADV_UEV_DATA_VAR, data);
663 ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
665 kfree(uevent_env[0]);
666 kfree(uevent_env[1]);
667 kfree(uevent_env[2]);
670 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
671 "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
672 batadv_uev_type_str[type],
673 batadv_uev_action_str[action],
674 (action == BATADV_UEV_DEL ? "NULL" : data), ret);