blob: e5bbc28ed12c3a221a6b1a06d4379d406da0e9da [file] [log] [blame]
Sven Eckelmann7db7d9f2017-11-19 15:05:11 +01001// SPDX-License-Identifier: GPL-2.0
Sven Eckelmann7a79d712018-12-31 23:59:59 +01002/* Copyright (C) 2010-2019 B.A.T.M.A.N. contributors:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00003 *
4 * Marek Lindner
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00005 */
6
Sven Eckelmannb706b132012-06-10 23:58:51 +02007#include "sysfs.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +02008#include "main.h"
9
Sven Eckelmann1392f552019-03-03 18:02:59 +010010#include <asm/current.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020011#include <linux/atomic.h>
12#include <linux/compiler.h>
13#include <linux/device.h>
14#include <linux/errno.h>
Sven Eckelmannb92b94a2017-11-19 17:12:02 +010015#include <linux/gfp.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020016#include <linux/if.h>
17#include <linux/if_vlan.h>
18#include <linux/kernel.h>
Sven Eckelmann8cfba952017-11-19 17:12:05 +010019#include <linux/kobject.h>
Sven Eckelmannfcafa5e2016-05-15 11:07:42 +020020#include <linux/kref.h>
Sven Eckelmanne1928752019-05-24 16:28:50 +020021#include <linux/limits.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020022#include <linux/netdevice.h>
23#include <linux/printk.h>
24#include <linux/rculist.h>
25#include <linux/rcupdate.h>
26#include <linux/rtnetlink.h>
Sven Eckelmann1392f552019-03-03 18:02:59 +010027#include <linux/sched.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020028#include <linux/slab.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020029#include <linux/stddef.h>
30#include <linux/string.h>
31#include <linux/stringify.h>
Sven Eckelmann77d69d82016-06-13 07:41:30 +020032#include <linux/workqueue.h>
Sven Eckelmannfec149f2017-12-21 10:17:41 +010033#include <uapi/linux/batadv_packet.h>
Sven Eckelmanne2d0d352018-11-23 13:15:00 +010034#include <uapi/linux/batman_adv.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020035
Sven Eckelmannfcafa5e2016-05-15 11:07:42 +020036#include "bridge_loop_avoidance.h"
Antonio Quartulli33af49a2012-08-08 18:50:57 +020037#include "distributed-arp-table.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000038#include "gateway_client.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020039#include "gateway_common.h"
40#include "hard-interface.h"
Sven Eckelmannba412082016-05-15 23:48:31 +020041#include "log.h"
Sven Eckelmann7e6f4612018-11-23 16:07:12 +010042#include "netlink.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020043#include "network-coding.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020044#include "soft-interface.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000045
Sven Eckelmann1392f552019-03-03 18:02:59 +010046/**
47 * batadv_sysfs_deprecated() - Log use of deprecated batadv sysfs access
48 * @attr: attribute which was accessed
49 */
50static void batadv_sysfs_deprecated(struct attribute *attr)
51{
52 pr_warn_ratelimited(DEPRECATED "%s (pid %d) Use of sysfs file \"%s\".\nUse batadv genl family instead",
53 current->comm, task_pid_nr(current), attr->name);
54}
55
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020056static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020057{
58 struct device *dev = container_of(obj->parent, struct device, kobj);
Antonio Quartullif1386942014-05-10 18:56:37 +020059
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020060 return to_net_dev(dev);
61}
62
Sven Eckelmann56303d32012-06-05 22:31:31 +020063static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020064{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020065 struct net_device *net_dev = batadv_kobj_to_netdev(obj);
Antonio Quartullif1386942014-05-10 18:56:37 +020066
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020067 return netdev_priv(net_dev);
68}
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000069
Antonio Quartulli90f44352013-07-02 11:04:35 +020070/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +010071 * batadv_vlan_kobj_to_batpriv() - convert a vlan kobj in the associated batpriv
Antonio Quartulli90f44352013-07-02 11:04:35 +020072 * @obj: kobject to covert
73 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +020074 * Return: the associated batadv_priv struct.
Antonio Quartulli90f44352013-07-02 11:04:35 +020075 */
76static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
77{
78 /* VLAN specific attributes are located in the root sysfs folder if they
79 * refer to the untagged VLAN..
80 */
81 if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
82 return batadv_kobj_to_batpriv(obj);
83
84 /* ..while the attributes for the tagged vlans are located in
85 * the in the corresponding "vlan%VID" subfolder
86 */
87 return batadv_kobj_to_batpriv(obj->parent);
88}
89
90/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +010091 * batadv_kobj_to_vlan() - convert a kobj in the associated softif_vlan struct
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +010092 * @bat_priv: the bat priv with all the soft interface information
Antonio Quartulli90f44352013-07-02 11:04:35 +020093 * @obj: kobject to covert
94 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +020095 * Return: the associated softif_vlan struct if found, NULL otherwise.
Antonio Quartulli90f44352013-07-02 11:04:35 +020096 */
97static struct batadv_softif_vlan *
98batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
99{
100 struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
101
102 rcu_read_lock();
103 hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
104 if (vlan_tmp->kobj != obj)
105 continue;
106
Sven Eckelmann6be4d302016-01-16 10:29:42 +0100107 if (!kref_get_unless_zero(&vlan_tmp->refcount))
Antonio Quartulli90f44352013-07-02 11:04:35 +0200108 continue;
109
110 vlan = vlan_tmp;
111 break;
112 }
113 rcu_read_unlock();
114
115 return vlan;
116}
117
Antonio Quartulli90f44352013-07-02 11:04:35 +0200118/* Use this, if you have customized show and store functions for vlan attrs */
119#define BATADV_ATTR_VLAN(_name, _mode, _show, _store) \
120struct batadv_attribute batadv_attr_vlan_##_name = { \
121 .attr = {.name = __stringify(_name), \
122 .mode = _mode }, \
123 .show = _show, \
124 .store = _store, \
Antonio Quartulli2b64df22014-05-15 11:24:26 +0200125}
Antonio Quartulli90f44352013-07-02 11:04:35 +0200126
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000127/* Use this, if you have customized show and store functions */
Sven Eckelmann347c80f02012-06-03 22:19:07 +0200128#define BATADV_ATTR(_name, _mode, _show, _store) \
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200129struct batadv_attribute batadv_attr_##_name = { \
Sven Eckelmann347c80f02012-06-03 22:19:07 +0200130 .attr = {.name = __stringify(_name), \
131 .mode = _mode }, \
132 .show = _show, \
133 .store = _store, \
Antonio Quartulli2b64df22014-05-15 11:24:26 +0200134}
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000135
Sven Eckelmann347c80f02012-06-03 22:19:07 +0200136#define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200137ssize_t batadv_store_##_name(struct kobject *kobj, \
138 struct attribute *attr, char *buff, \
139 size_t count) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000140{ \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200141 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200142 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100143 ssize_t length; \
Antonio Quartullif1386942014-05-10 18:56:37 +0200144 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100145 batadv_sysfs_deprecated(attr); \
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100146 length = __batadv_store_bool_attr(buff, count, _post_func, attr,\
147 &bat_priv->_name, net_dev); \
148 \
149 batadv_netlink_notify_mesh(bat_priv); \
150 \
151 return length; \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000152}
153
Sven Eckelmann347c80f02012-06-03 22:19:07 +0200154#define BATADV_ATTR_SIF_SHOW_BOOL(_name) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200155ssize_t batadv_show_##_name(struct kobject *kobj, \
156 struct attribute *attr, char *buff) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000157{ \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200158 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200159 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100160 batadv_sysfs_deprecated(attr); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000161 return sprintf(buff, "%s\n", \
162 atomic_read(&bat_priv->_name) == 0 ? \
163 "disabled" : "enabled"); \
164} \
165
Marek Lindnerf245c382012-03-11 06:17:51 +0800166/* Use this, if you are going to turn a [name] in the soft-interface
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200167 * (bat_priv) on or off
168 */
Sven Eckelmann347c80f02012-06-03 22:19:07 +0200169#define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func) \
170 static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
171 static BATADV_ATTR_SIF_SHOW_BOOL(_name) \
172 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
173 batadv_store_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000174
Antonio Quartulli6f70eb72015-03-01 00:50:16 +0800175#define BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200176ssize_t batadv_store_##_name(struct kobject *kobj, \
177 struct attribute *attr, char *buff, \
178 size_t count) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000179{ \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200180 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200181 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100182 ssize_t length; \
Antonio Quartullif1386942014-05-10 18:56:37 +0200183 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100184 batadv_sysfs_deprecated(attr); \
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100185 length = __batadv_store_uint_attr(buff, count, _min, _max, \
186 _post_func, attr, \
187 &bat_priv->_var, net_dev, \
188 NULL); \
189 \
190 batadv_netlink_notify_mesh(bat_priv); \
191 \
192 return length; \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000193}
194
Antonio Quartulli6f70eb72015-03-01 00:50:16 +0800195#define BATADV_ATTR_SIF_SHOW_UINT(_name, _var) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200196ssize_t batadv_show_##_name(struct kobject *kobj, \
197 struct attribute *attr, char *buff) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000198{ \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200199 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200200 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100201 batadv_sysfs_deprecated(attr); \
Antonio Quartulli6f70eb72015-03-01 00:50:16 +0800202 return sprintf(buff, "%i\n", atomic_read(&bat_priv->_var)); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000203} \
204
Marek Lindnerf245c382012-03-11 06:17:51 +0800205/* Use this, if you are going to set [name] in the soft-interface
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200206 * (bat_priv) to an unsigned integer value
207 */
Antonio Quartulli6f70eb72015-03-01 00:50:16 +0800208#define BATADV_ATTR_SIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
209 static BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func)\
210 static BATADV_ATTR_SIF_SHOW_UINT(_name, _var) \
Sven Eckelmann347c80f02012-06-03 22:19:07 +0200211 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
212 batadv_store_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000213
Antonio Quartulli90f44352013-07-02 11:04:35 +0200214#define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
215ssize_t batadv_store_vlan_##_name(struct kobject *kobj, \
216 struct attribute *attr, char *buff, \
217 size_t count) \
218{ \
219 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
220 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
221 kobj); \
222 size_t res = __batadv_store_bool_attr(buff, count, _post_func, \
223 attr, &vlan->_name, \
224 bat_priv->soft_iface); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200225 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100226 batadv_sysfs_deprecated(attr); \
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100227 if (vlan->vid) \
228 batadv_netlink_notify_vlan(bat_priv, vlan); \
229 else \
230 batadv_netlink_notify_mesh(bat_priv); \
231 \
Sven Eckelmann9c3bf082016-01-17 11:01:21 +0100232 batadv_softif_vlan_put(vlan); \
Antonio Quartulli90f44352013-07-02 11:04:35 +0200233 return res; \
234}
235
236#define BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
237ssize_t batadv_show_vlan_##_name(struct kobject *kobj, \
238 struct attribute *attr, char *buff) \
239{ \
240 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
241 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
242 kobj); \
243 size_t res = sprintf(buff, "%s\n", \
244 atomic_read(&vlan->_name) == 0 ? \
245 "disabled" : "enabled"); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200246 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100247 batadv_sysfs_deprecated(attr); \
Sven Eckelmann9c3bf082016-01-17 11:01:21 +0100248 batadv_softif_vlan_put(vlan); \
Antonio Quartulli90f44352013-07-02 11:04:35 +0200249 return res; \
250}
251
252/* Use this, if you are going to turn a [name] in the vlan struct on or off */
253#define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func) \
254 static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
255 static BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
256 static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name, \
257 batadv_store_vlan_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000258
Linus Luessing0744ff82016-01-16 16:40:08 +0800259#define BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min, _max, _post_func) \
260ssize_t batadv_store_##_name(struct kobject *kobj, \
261 struct attribute *attr, char *buff, \
262 size_t count) \
263{ \
264 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
265 struct batadv_hard_iface *hard_iface; \
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100266 struct batadv_priv *bat_priv; \
Linus Luessing0744ff82016-01-16 16:40:08 +0800267 ssize_t length; \
268 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100269 batadv_sysfs_deprecated(attr); \
Linus Luessing0744ff82016-01-16 16:40:08 +0800270 hard_iface = batadv_hardif_get_by_netdev(net_dev); \
271 if (!hard_iface) \
272 return 0; \
273 \
274 length = __batadv_store_uint_attr(buff, count, _min, _max, \
275 _post_func, attr, \
Sven Eckelmanna25bab92018-08-31 16:56:29 +0200276 &hard_iface->_var, \
277 hard_iface->soft_iface, \
278 net_dev); \
Linus Luessing0744ff82016-01-16 16:40:08 +0800279 \
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100280 if (hard_iface->soft_iface) { \
281 bat_priv = netdev_priv(hard_iface->soft_iface); \
282 batadv_netlink_notify_hardif(bat_priv, hard_iface); \
283 } \
284 \
Linus Luessing0744ff82016-01-16 16:40:08 +0800285 batadv_hardif_put(hard_iface); \
286 return length; \
287}
288
289#define BATADV_ATTR_HIF_SHOW_UINT(_name, _var) \
290ssize_t batadv_show_##_name(struct kobject *kobj, \
291 struct attribute *attr, char *buff) \
292{ \
293 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
294 struct batadv_hard_iface *hard_iface; \
295 ssize_t length; \
296 \
Sven Eckelmann1392f552019-03-03 18:02:59 +0100297 batadv_sysfs_deprecated(attr); \
Linus Luessing0744ff82016-01-16 16:40:08 +0800298 hard_iface = batadv_hardif_get_by_netdev(net_dev); \
299 if (!hard_iface) \
300 return 0; \
301 \
302 length = sprintf(buff, "%i\n", atomic_read(&hard_iface->_var)); \
303 \
304 batadv_hardif_put(hard_iface); \
305 return length; \
306}
307
308/* Use this, if you are going to set [name] in hard_iface to an
309 * unsigned integer value
310 */
311#define BATADV_ATTR_HIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
312 static BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min, \
313 _max, _post_func) \
314 static BATADV_ATTR_HIF_SHOW_UINT(_name, _var) \
315 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
316 batadv_store_##_name)
317
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200318static int batadv_store_bool_attr(char *buff, size_t count,
319 struct net_device *net_dev,
Simon Wunderlich9e728e82015-11-17 14:11:26 +0100320 const char *attr_name, atomic_t *attr,
321 bool *changed)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000322{
323 int enabled = -1;
324
Simon Wunderlich9e728e82015-11-17 14:11:26 +0100325 *changed = false;
326
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000327 if (buff[count - 1] == '\n')
328 buff[count - 1] = '\0';
329
330 if ((strncmp(buff, "1", 2) == 0) ||
331 (strncmp(buff, "enable", 7) == 0) ||
332 (strncmp(buff, "enabled", 8) == 0))
333 enabled = 1;
334
335 if ((strncmp(buff, "0", 2) == 0) ||
336 (strncmp(buff, "disable", 8) == 0) ||
337 (strncmp(buff, "disabled", 9) == 0))
338 enabled = 0;
339
340 if (enabled < 0) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200341 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
342 attr_name, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000343 return -EINVAL;
344 }
345
346 if (atomic_read(attr) == enabled)
347 return count;
348
Sven Eckelmann3e348192012-05-16 20:23:22 +0200349 batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
350 atomic_read(attr) == 1 ? "enabled" : "disabled",
351 enabled == 1 ? "enabled" : "disabled");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000352
Simon Wunderlich9e728e82015-11-17 14:11:26 +0100353 *changed = true;
354
Eric Dumazet95c96172012-04-15 05:58:06 +0000355 atomic_set(attr, (unsigned int)enabled);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000356 return count;
357}
358
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200359static inline ssize_t
360__batadv_store_bool_attr(char *buff, size_t count,
361 void (*post_func)(struct net_device *),
362 struct attribute *attr,
363 atomic_t *attr_store, struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000364{
Simon Wunderlich9e728e82015-11-17 14:11:26 +0100365 bool changed;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000366 int ret;
367
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200368 ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
Simon Wunderlich9e728e82015-11-17 14:11:26 +0100369 attr_store, &changed);
370 if (post_func && changed)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000371 post_func(net_dev);
372
373 return ret;
374}
375
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200376static int batadv_store_uint_attr(const char *buff, size_t count,
377 struct net_device *net_dev,
Sven Eckelmanna25bab92018-08-31 16:56:29 +0200378 struct net_device *slave_dev,
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200379 const char *attr_name,
380 unsigned int min, unsigned int max,
381 atomic_t *attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000382{
Sven Eckelmanna25bab92018-08-31 16:56:29 +0200383 char ifname[IFNAMSIZ + 3] = "";
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000384 unsigned long uint_val;
385 int ret;
386
Sven Eckelmann25a92b12011-09-30 13:32:01 +0200387 ret = kstrtoul(buff, 10, &uint_val);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000388 if (ret) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200389 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
390 attr_name, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000391 return -EINVAL;
392 }
393
394 if (uint_val < min) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200395 batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
396 attr_name, uint_val, min);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000397 return -EINVAL;
398 }
399
400 if (uint_val > max) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200401 batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
402 attr_name, uint_val, max);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000403 return -EINVAL;
404 }
405
406 if (atomic_read(attr) == uint_val)
407 return count;
408
Sven Eckelmanna25bab92018-08-31 16:56:29 +0200409 if (slave_dev)
410 snprintf(ifname, sizeof(ifname), "%s: ", slave_dev->name);
411
412 batadv_info(net_dev, "%s: %sChanging from: %i to: %lu\n",
413 attr_name, ifname, atomic_read(attr), uint_val);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000414
415 atomic_set(attr, uint_val);
416 return count;
417}
418
Antonio Quartullic149ca72016-05-06 02:46:37 +0800419static ssize_t __batadv_store_uint_attr(const char *buff, size_t count,
420 int min, int max,
421 void (*post_func)(struct net_device *),
422 const struct attribute *attr,
423 atomic_t *attr_store,
Sven Eckelmanna25bab92018-08-31 16:56:29 +0200424 struct net_device *net_dev,
425 struct net_device *slave_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000426{
427 int ret;
428
Sven Eckelmanna25bab92018-08-31 16:56:29 +0200429 ret = batadv_store_uint_attr(buff, count, net_dev, slave_dev,
430 attr->name, min, max, attr_store);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000431 if (post_func && ret)
432 post_func(net_dev);
433
434 return ret;
435}
436
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200437static ssize_t batadv_show_bat_algo(struct kobject *kobj,
438 struct attribute *attr, char *buff)
Marek Lindnerea3d2fd2011-11-29 00:15:37 +0800439{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200440 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Antonio Quartullif1386942014-05-10 18:56:37 +0200441
Sven Eckelmann1392f552019-03-03 18:02:59 +0100442 batadv_sysfs_deprecated(attr);
Antonio Quartulli29824a52016-05-25 23:27:31 +0800443 return sprintf(buff, "%s\n", bat_priv->algo_ops->name);
Marek Lindnerea3d2fd2011-11-29 00:15:37 +0800444}
445
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100446static void batadv_post_gw_reselect(struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000447{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200448 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Antonio Quartullif1386942014-05-10 18:56:37 +0200449
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100450 batadv_gw_reselect(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000451}
452
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200453static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
454 char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000455{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200456 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000457 int bytes_written;
458
Sven Eckelmann1392f552019-03-03 18:02:59 +0100459 batadv_sysfs_deprecated(attr);
460
Antonio Quartullia8d8d1d2016-07-03 12:46:35 +0200461 /* GW mode is not available if the routing algorithm in use does not
462 * implement the GW API
463 */
464 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
465 !bat_priv->algo_ops->gw.is_eligible)
466 return -ENOENT;
467
Antonio Quartulli3a24a632016-05-06 02:46:38 +0800468 switch (atomic_read(&bat_priv->gw.mode)) {
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200469 case BATADV_GW_MODE_CLIENT:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200470 bytes_written = sprintf(buff, "%s\n",
471 BATADV_GW_MODE_CLIENT_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000472 break;
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200473 case BATADV_GW_MODE_SERVER:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200474 bytes_written = sprintf(buff, "%s\n",
475 BATADV_GW_MODE_SERVER_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000476 break;
477 default:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200478 bytes_written = sprintf(buff, "%s\n",
479 BATADV_GW_MODE_OFF_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000480 break;
481 }
482
483 return bytes_written;
484}
485
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200486static ssize_t batadv_store_gw_mode(struct kobject *kobj,
487 struct attribute *attr, char *buff,
488 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000489{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200490 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200491 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000492 char *curr_gw_mode_str;
493 int gw_mode_tmp = -1;
494
Sven Eckelmann1392f552019-03-03 18:02:59 +0100495 batadv_sysfs_deprecated(attr);
496
Antonio Quartullia8d8d1d2016-07-03 12:46:35 +0200497 /* toggling GW mode is allowed only if the routing algorithm in use
498 * provides the GW API
499 */
500 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
501 !bat_priv->algo_ops->gw.is_eligible)
502 return -EINVAL;
503
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000504 if (buff[count - 1] == '\n')
505 buff[count - 1] = '\0';
506
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200507 if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
508 strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200509 gw_mode_tmp = BATADV_GW_MODE_OFF;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000510
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200511 if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
512 strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200513 gw_mode_tmp = BATADV_GW_MODE_CLIENT;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000514
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200515 if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
516 strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200517 gw_mode_tmp = BATADV_GW_MODE_SERVER;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000518
519 if (gw_mode_tmp < 0) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200520 batadv_info(net_dev,
521 "Invalid parameter for 'gw mode' setting received: %s\n",
522 buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000523 return -EINVAL;
524 }
525
Antonio Quartulli3a24a632016-05-06 02:46:38 +0800526 if (atomic_read(&bat_priv->gw.mode) == gw_mode_tmp)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000527 return count;
528
Antonio Quartulli3a24a632016-05-06 02:46:38 +0800529 switch (atomic_read(&bat_priv->gw.mode)) {
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200530 case BATADV_GW_MODE_CLIENT:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200531 curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000532 break;
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200533 case BATADV_GW_MODE_SERVER:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200534 curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000535 break;
536 default:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200537 curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000538 break;
539 }
540
Sven Eckelmann3e348192012-05-16 20:23:22 +0200541 batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
542 curr_gw_mode_str, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000543
Antonio Quartullif3163182013-11-04 20:59:40 +0100544 /* Invoking batadv_gw_reselect() is not enough to really de-select the
545 * current GW. It will only instruct the gateway client code to perform
546 * a re-election the next time that this is needed.
547 *
548 * When gw client mode is being switched off the current GW must be
549 * de-selected explicitly otherwise no GW_ADD uevent is thrown on
550 * client mode re-activation. This is operation is performed in
551 * batadv_gw_check_client_stop().
552 */
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100553 batadv_gw_reselect(bat_priv);
Antonio Quartullic6eaa3f2013-07-13 00:06:00 +0200554 /* always call batadv_gw_check_client_stop() before changing the gateway
555 * state
556 */
557 batadv_gw_check_client_stop(bat_priv);
Antonio Quartulli3a24a632016-05-06 02:46:38 +0800558 atomic_set(&bat_priv->gw.mode, (unsigned int)gw_mode_tmp);
Marek Lindner414254e2013-04-23 21:39:58 +0800559 batadv_gw_tvlv_container_update(bat_priv);
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100560
561 batadv_netlink_notify_mesh(bat_priv);
562
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000563 return count;
564}
565
Antonio Quartulli08686942016-07-03 12:46:32 +0200566static ssize_t batadv_show_gw_sel_class(struct kobject *kobj,
567 struct attribute *attr, char *buff)
568{
569 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
570
Sven Eckelmann1392f552019-03-03 18:02:59 +0100571 batadv_sysfs_deprecated(attr);
572
Antonio Quartullia8d8d1d2016-07-03 12:46:35 +0200573 /* GW selection class is not available if the routing algorithm in use
574 * does not implement the GW API
575 */
576 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
577 !bat_priv->algo_ops->gw.is_eligible)
578 return -ENOENT;
579
Antonio Quartulli08686942016-07-03 12:46:32 +0200580 if (bat_priv->algo_ops->gw.show_sel_class)
581 return bat_priv->algo_ops->gw.show_sel_class(bat_priv, buff);
582
583 return sprintf(buff, "%i\n", atomic_read(&bat_priv->gw.sel_class));
584}
585
586static ssize_t batadv_store_gw_sel_class(struct kobject *kobj,
587 struct attribute *attr, char *buff,
588 size_t count)
589{
590 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100591 ssize_t length;
Antonio Quartulli08686942016-07-03 12:46:32 +0200592
Sven Eckelmann1392f552019-03-03 18:02:59 +0100593 batadv_sysfs_deprecated(attr);
594
Antonio Quartullia8d8d1d2016-07-03 12:46:35 +0200595 /* setting the GW selection class is allowed only if the routing
596 * algorithm in use implements the GW API
597 */
598 if (!bat_priv->algo_ops->gw.get_best_gw_node ||
599 !bat_priv->algo_ops->gw.is_eligible)
600 return -EINVAL;
601
Antonio Quartulli08686942016-07-03 12:46:32 +0200602 if (buff[count - 1] == '\n')
603 buff[count - 1] = '\0';
604
605 if (bat_priv->algo_ops->gw.store_sel_class)
606 return bat_priv->algo_ops->gw.store_sel_class(bat_priv, buff,
607 count);
608
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100609 length = __batadv_store_uint_attr(buff, count, 1, BATADV_TQ_MAX_VALUE,
610 batadv_post_gw_reselect, attr,
611 &bat_priv->gw.sel_class,
612 bat_priv->soft_iface, NULL);
613
614 batadv_netlink_notify_mesh(bat_priv);
615
616 return length;
Antonio Quartulli08686942016-07-03 12:46:32 +0200617}
618
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200619static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
620 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000621{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200622 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200623 u32 down, up;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000624
Sven Eckelmann1392f552019-03-03 18:02:59 +0100625 batadv_sysfs_deprecated(attr);
626
Marek Lindner414254e2013-04-23 21:39:58 +0800627 down = atomic_read(&bat_priv->gw.bandwidth_down);
628 up = atomic_read(&bat_priv->gw.bandwidth_up);
629
630 return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
631 down % 10, up / 10, up % 10);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000632}
633
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200634static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
635 struct attribute *attr, char *buff,
636 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000637{
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100638 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200639 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100640 ssize_t length;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000641
Sven Eckelmann1392f552019-03-03 18:02:59 +0100642 batadv_sysfs_deprecated(attr);
643
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000644 if (buff[count - 1] == '\n')
645 buff[count - 1] = '\0';
646
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100647 length = batadv_gw_bandwidth_set(net_dev, buff, count);
648
649 batadv_netlink_notify_mesh(bat_priv);
650
651 return length;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000652}
653
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100654/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +0100655 * batadv_show_isolation_mark() - print the current isolation mark/mask
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100656 * @kobj: kobject representing the private mesh sysfs directory
657 * @attr: the batman-adv attribute the user is interacting with
658 * @buff: the buffer that will contain the data to send back to the user
659 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200660 * Return: the number of bytes written into 'buff' on success or a negative
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100661 * error code in case of failure
662 */
663static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
664 struct attribute *attr, char *buff)
665{
666 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
667
Sven Eckelmann1392f552019-03-03 18:02:59 +0100668 batadv_sysfs_deprecated(attr);
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100669 return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
670 bat_priv->isolation_mark_mask);
671}
672
673/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +0100674 * batadv_store_isolation_mark() - parse and store the isolation mark/mask
675 * entered by the user
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100676 * @kobj: kobject representing the private mesh sysfs directory
677 * @attr: the batman-adv attribute the user is interacting with
678 * @buff: the buffer containing the user data
679 * @count: number of bytes in the buffer
680 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200681 * Return: 'count' on success or a negative error code in case of failure
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100682 */
683static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
684 struct attribute *attr, char *buff,
685 size_t count)
686{
687 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
688 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200689 u32 mark, mask;
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100690 char *mask_ptr;
691
Sven Eckelmann1392f552019-03-03 18:02:59 +0100692 batadv_sysfs_deprecated(attr);
693
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100694 /* parse the mask if it has been specified, otherwise assume the mask is
695 * the biggest possible
696 */
697 mask = 0xFFFFFFFF;
698 mask_ptr = strchr(buff, '/');
699 if (mask_ptr) {
700 *mask_ptr = '\0';
701 mask_ptr++;
702
703 /* the mask must be entered in hex base as it is going to be a
704 * bitmask and not a prefix length
705 */
706 if (kstrtou32(mask_ptr, 16, &mask) < 0)
707 return -EINVAL;
708 }
709
710 /* the mark can be entered in any base */
711 if (kstrtou32(buff, 0, &mark) < 0)
712 return -EINVAL;
713
714 bat_priv->isolation_mark_mask = mask;
715 /* erase bits not covered by the mask */
716 bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;
717
718 batadv_info(net_dev,
719 "New skb mark for extended isolation: %#.8x/%#.8x\n",
720 bat_priv->isolation_mark, bat_priv->isolation_mark_mask);
721
Sven Eckelmann7e6f4612018-11-23 16:07:12 +0100722 batadv_netlink_notify_mesh(bat_priv);
723
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100724 return count;
725}
726
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200727BATADV_ATTR_SIF_BOOL(aggregated_ogms, 0644, NULL);
728BATADV_ATTR_SIF_BOOL(bonding, 0644, NULL);
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100729#ifdef CONFIG_BATMAN_ADV_BLA
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200730BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, 0644, batadv_bla_status_update);
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100731#endif
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200732#ifdef CONFIG_BATMAN_ADV_DAT
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200733BATADV_ATTR_SIF_BOOL(distributed_arp_table, 0644, batadv_dat_status_update);
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200734#endif
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200735BATADV_ATTR_SIF_BOOL(fragmentation, 0644, batadv_update_min_mtu);
736static BATADV_ATTR(routing_algo, 0444, batadv_show_bat_algo, NULL);
737static BATADV_ATTR(gw_mode, 0644, batadv_show_gw_mode, batadv_store_gw_mode);
738BATADV_ATTR_SIF_UINT(orig_interval, orig_interval, 0644, 2 * BATADV_JITTER,
739 INT_MAX, NULL);
740BATADV_ATTR_SIF_UINT(hop_penalty, hop_penalty, 0644, 0, BATADV_TQ_MAX_VALUE,
741 NULL);
742static BATADV_ATTR(gw_sel_class, 0644, batadv_show_gw_sel_class,
Antonio Quartulli08686942016-07-03 12:46:32 +0200743 batadv_store_gw_sel_class);
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200744static BATADV_ATTR(gw_bandwidth, 0644, batadv_show_gw_bwidth,
Sven Eckelmann347c80f02012-06-03 22:19:07 +0200745 batadv_store_gw_bwidth);
Linus Lüssing1d8ab8d2014-02-15 17:47:52 +0100746#ifdef CONFIG_BATMAN_ADV_MCAST
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200747BATADV_ATTR_SIF_BOOL(multicast_mode, 0644, NULL);
Linus Lüssing1d8ab8d2014-02-15 17:47:52 +0100748#endif
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000749#ifdef CONFIG_BATMAN_ADV_DEBUG
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200750BATADV_ATTR_SIF_UINT(log_level, log_level, 0644, 0, BATADV_DBG_ALL, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000751#endif
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100752#ifdef CONFIG_BATMAN_ADV_NC
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200753BATADV_ATTR_SIF_BOOL(network_coding, 0644, batadv_nc_status_update);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100754#endif
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200755static BATADV_ATTR(isolation_mark, 0644, batadv_show_isolation_mark,
756 batadv_store_isolation_mark);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000757
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200758static struct batadv_attribute *batadv_mesh_attrs[] = {
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200759 &batadv_attr_aggregated_ogms,
760 &batadv_attr_bonding,
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100761#ifdef CONFIG_BATMAN_ADV_BLA
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200762 &batadv_attr_bridge_loop_avoidance,
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100763#endif
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200764#ifdef CONFIG_BATMAN_ADV_DAT
765 &batadv_attr_distributed_arp_table,
766#endif
Linus Lüssing1d8ab8d2014-02-15 17:47:52 +0100767#ifdef CONFIG_BATMAN_ADV_MCAST
768 &batadv_attr_multicast_mode,
769#endif
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200770 &batadv_attr_fragmentation,
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200771 &batadv_attr_routing_algo,
772 &batadv_attr_gw_mode,
773 &batadv_attr_orig_interval,
774 &batadv_attr_hop_penalty,
775 &batadv_attr_gw_sel_class,
776 &batadv_attr_gw_bandwidth,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000777#ifdef CONFIG_BATMAN_ADV_DEBUG
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200778 &batadv_attr_log_level,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000779#endif
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100780#ifdef CONFIG_BATMAN_ADV_NC
781 &batadv_attr_network_coding,
782#endif
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100783 &batadv_attr_isolation_mark,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000784 NULL,
785};
786
Sven Eckelmann507b37c2016-09-01 10:25:12 +0200787BATADV_ATTR_VLAN_BOOL(ap_isolation, 0644, NULL);
Antonio Quartullib8cbd812013-07-02 11:04:36 +0200788
Sven Eckelmannf34ac9d2015-09-06 21:38:53 +0200789/* array of vlan specific sysfs attributes */
Antonio Quartulli90f44352013-07-02 11:04:35 +0200790static struct batadv_attribute *batadv_vlan_attrs[] = {
Antonio Quartullib8cbd812013-07-02 11:04:36 +0200791 &batadv_attr_vlan_ap_isolation,
Antonio Quartulli90f44352013-07-02 11:04:35 +0200792 NULL,
793};
794
Sven Eckelmannff15c272017-12-02 19:51:53 +0100795/**
796 * batadv_sysfs_add_meshif() - Add soft interface specific sysfs entries
797 * @dev: netdev struct of the soft interface
798 *
799 * Return: 0 on success or negative error number in case of failure
800 */
Sven Eckelmann5853e222012-05-12 02:09:24 +0200801int batadv_sysfs_add_meshif(struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000802{
803 struct kobject *batif_kobject = &dev->dev.kobj;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200804 struct batadv_priv *bat_priv = netdev_priv(dev);
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200805 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000806 int err;
807
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200808 bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000809 batif_kobject);
810 if (!bat_priv->mesh_obj) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200811 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200812 BATADV_SYSFS_IF_MESH_SUBDIR);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000813 goto out;
814 }
815
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200816 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000817 err = sysfs_create_file(bat_priv->mesh_obj,
818 &((*bat_attr)->attr));
819 if (err) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200820 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200821 dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
Sven Eckelmann3e348192012-05-16 20:23:22 +0200822 ((*bat_attr)->attr).name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000823 goto rem_attr;
824 }
825 }
826
827 return 0;
828
829rem_attr:
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200830 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000831 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
832
Sven Eckelmannf4acb102016-06-13 07:41:32 +0200833 kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
834 kobject_del(bat_priv->mesh_obj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000835 kobject_put(bat_priv->mesh_obj);
836 bat_priv->mesh_obj = NULL;
837out:
838 return -ENOMEM;
839}
840
Sven Eckelmannff15c272017-12-02 19:51:53 +0100841/**
842 * batadv_sysfs_del_meshif() - Remove soft interface specific sysfs entries
843 * @dev: netdev struct of the soft interface
844 */
Sven Eckelmann5853e222012-05-12 02:09:24 +0200845void batadv_sysfs_del_meshif(struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000846{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200847 struct batadv_priv *bat_priv = netdev_priv(dev);
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200848 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000849
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200850 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000851 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
852
Sven Eckelmannf4acb102016-06-13 07:41:32 +0200853 kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
854 kobject_del(bat_priv->mesh_obj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000855 kobject_put(bat_priv->mesh_obj);
856 bat_priv->mesh_obj = NULL;
857}
858
Antonio Quartulli90f44352013-07-02 11:04:35 +0200859/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +0100860 * batadv_sysfs_add_vlan() - add all the needed sysfs objects for the new vlan
Antonio Quartulli90f44352013-07-02 11:04:35 +0200861 * @dev: netdev of the mesh interface
862 * @vlan: private data of the newly added VLAN interface
863 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200864 * Return: 0 on success and -ENOMEM if any of the structure allocations fails.
Antonio Quartulli90f44352013-07-02 11:04:35 +0200865 */
866int batadv_sysfs_add_vlan(struct net_device *dev,
867 struct batadv_softif_vlan *vlan)
868{
869 char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
870 struct batadv_priv *bat_priv = netdev_priv(dev);
871 struct batadv_attribute **bat_attr;
872 int err;
873
874 if (vlan->vid & BATADV_VLAN_HAS_TAG) {
875 sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
876 vlan->vid & VLAN_VID_MASK);
877
878 vlan->kobj = kobject_create_and_add(vlan_subdir,
879 bat_priv->mesh_obj);
880 if (!vlan->kobj) {
881 batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
882 dev->name, vlan_subdir);
883 goto out;
884 }
885 } else {
886 /* the untagged LAN uses the root folder to store its "VLAN
887 * specific attributes"
888 */
889 vlan->kobj = bat_priv->mesh_obj;
890 kobject_get(bat_priv->mesh_obj);
891 }
892
893 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
894 err = sysfs_create_file(vlan->kobj,
895 &((*bat_attr)->attr));
896 if (err) {
897 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
898 dev->name, vlan_subdir,
899 ((*bat_attr)->attr).name);
900 goto rem_attr;
901 }
902 }
903
904 return 0;
905
906rem_attr:
907 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
908 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
909
Sven Eckelmannf4acb102016-06-13 07:41:32 +0200910 if (vlan->kobj != bat_priv->mesh_obj) {
911 kobject_uevent(vlan->kobj, KOBJ_REMOVE);
912 kobject_del(vlan->kobj);
913 }
Antonio Quartulli90f44352013-07-02 11:04:35 +0200914 kobject_put(vlan->kobj);
915 vlan->kobj = NULL;
916out:
917 return -ENOMEM;
918}
919
920/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +0100921 * batadv_sysfs_del_vlan() - remove all the sysfs objects for a given VLAN
Antonio Quartulli90f44352013-07-02 11:04:35 +0200922 * @bat_priv: the bat priv with all the soft interface information
923 * @vlan: the private data of the VLAN to destroy
924 */
925void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
926 struct batadv_softif_vlan *vlan)
927{
928 struct batadv_attribute **bat_attr;
929
930 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
931 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
932
Sven Eckelmannf4acb102016-06-13 07:41:32 +0200933 if (vlan->kobj != bat_priv->mesh_obj) {
934 kobject_uevent(vlan->kobj, KOBJ_REMOVE);
935 kobject_del(vlan->kobj);
936 }
Antonio Quartulli90f44352013-07-02 11:04:35 +0200937 kobject_put(vlan->kobj);
938 vlan->kobj = NULL;
939}
940
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200941static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
942 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000943{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200944 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200945 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000946 ssize_t length;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200947 const char *ifname;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000948
Sven Eckelmann1392f552019-03-03 18:02:59 +0100949 batadv_sysfs_deprecated(attr);
950
Sven Eckelmann56303d32012-06-05 22:31:31 +0200951 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000952 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000953 return 0;
954
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200955 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
956 ifname = "none";
957 else
958 ifname = hard_iface->soft_iface->name;
959
960 length = sprintf(buff, "%s\n", ifname);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000961
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100962 batadv_hardif_put(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000963
964 return length;
965}
966
Sven Eckelmann77d69d82016-06-13 07:41:30 +0200967/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +0100968 * batadv_store_mesh_iface_finish() - store new hardif mesh_iface state
Sven Eckelmann77d69d82016-06-13 07:41:30 +0200969 * @net_dev: netdevice to add/remove to/from batman-adv soft-interface
970 * @ifname: name of soft-interface to modify
971 *
972 * Changes the parts of the hard+soft interface which can not be modified under
973 * sysfs lock (to prevent deadlock situations).
974 *
975 * Return: 0 on success, 0 < on failure
976 */
977static int batadv_store_mesh_iface_finish(struct net_device *net_dev,
978 char ifname[IFNAMSIZ])
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000979{
Andrew Lunn2cd45a02016-04-21 12:57:27 +0200980 struct net *net = dev_net(net_dev);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200981 struct batadv_hard_iface *hard_iface;
Sven Eckelmann77d69d82016-06-13 07:41:30 +0200982 int status_tmp;
983 int ret = 0;
984
985 ASSERT_RTNL();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000986
Sven Eckelmann56303d32012-06-05 22:31:31 +0200987 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000988 if (!hard_iface)
Sven Eckelmann77d69d82016-06-13 07:41:30 +0200989 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000990
Sven Eckelmann77d69d82016-06-13 07:41:30 +0200991 if (strncmp(ifname, "none", 4) == 0)
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200992 status_tmp = BATADV_IF_NOT_IN_USE;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000993 else
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200994 status_tmp = BATADV_IF_I_WANT_YOU;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000995
Marek Lindnere6c10f42011-02-18 12:33:20 +0000996 if (hard_iface->if_status == status_tmp)
997 goto out;
998
Sven Eckelmann825ffe12017-08-23 21:52:13 +0200999 if (hard_iface->soft_iface &&
1000 strncmp(hard_iface->soft_iface->name, ifname, IFNAMSIZ) == 0)
Marek Lindnered75ccb2011-02-10 14:33:51 +00001001 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001002
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001003 if (status_tmp == BATADV_IF_NOT_IN_USE) {
Sven Eckelmanna15fd362013-02-11 17:10:24 +08001004 batadv_hardif_disable_interface(hard_iface,
1005 BATADV_IF_CLEANUP_AUTO);
Sven Eckelmann77d69d82016-06-13 07:41:30 +02001006 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001007 }
1008
Sven Eckelmann3a4375a2011-05-03 13:10:06 +02001009 /* if the interface already is in use */
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001010 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
Sven Eckelmanna15fd362013-02-11 17:10:24 +08001011 batadv_hardif_disable_interface(hard_iface,
1012 BATADV_IF_CLEANUP_AUTO);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001013
Sven Eckelmann77d69d82016-06-13 07:41:30 +02001014 ret = batadv_hardif_enable_interface(hard_iface, net, ifname);
Marek Lindnered75ccb2011-02-10 14:33:51 +00001015out:
Sven Eckelmann82047ad2016-01-17 11:01:10 +01001016 batadv_hardif_put(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001017 return ret;
1018}
1019
Sven Eckelmann77d69d82016-06-13 07:41:30 +02001020/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +01001021 * batadv_store_mesh_iface_work() - store new hardif mesh_iface state
Sven Eckelmann77d69d82016-06-13 07:41:30 +02001022 * @work: work queue item
1023 *
1024 * Changes the parts of the hard+soft interface which can not be modified under
1025 * sysfs lock (to prevent deadlock situations).
1026 */
1027static void batadv_store_mesh_iface_work(struct work_struct *work)
1028{
1029 struct batadv_store_mesh_work *store_work;
1030 int ret;
1031
1032 store_work = container_of(work, struct batadv_store_mesh_work, work);
1033
1034 rtnl_lock();
1035 ret = batadv_store_mesh_iface_finish(store_work->net_dev,
1036 store_work->soft_iface_name);
1037 rtnl_unlock();
1038
1039 if (ret < 0)
1040 pr_err("Failed to store new mesh_iface state %s for %s: %d\n",
1041 store_work->soft_iface_name, store_work->net_dev->name,
1042 ret);
1043
1044 dev_put(store_work->net_dev);
1045 kfree(store_work);
1046}
1047
1048static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
1049 struct attribute *attr, char *buff,
1050 size_t count)
1051{
1052 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1053 struct batadv_store_mesh_work *store_work;
1054
Sven Eckelmann1392f552019-03-03 18:02:59 +01001055 batadv_sysfs_deprecated(attr);
1056
Sven Eckelmann77d69d82016-06-13 07:41:30 +02001057 if (buff[count - 1] == '\n')
1058 buff[count - 1] = '\0';
1059
1060 if (strlen(buff) >= IFNAMSIZ) {
1061 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
1062 buff);
1063 return -EINVAL;
1064 }
1065
1066 store_work = kmalloc(sizeof(*store_work), GFP_KERNEL);
1067 if (!store_work)
1068 return -ENOMEM;
1069
1070 dev_hold(net_dev);
1071 INIT_WORK(&store_work->work, batadv_store_mesh_iface_work);
1072 store_work->net_dev = net_dev;
Sven Eckelmann529a8f92019-07-06 14:56:13 +02001073 strscpy(store_work->soft_iface_name, buff,
Sven Eckelmann77d69d82016-06-13 07:41:30 +02001074 sizeof(store_work->soft_iface_name));
1075
1076 queue_work(batadv_event_workqueue, &store_work->work);
1077
1078 return count;
1079}
1080
Sven Eckelmann0ff9b862012-05-12 18:33:52 +02001081static ssize_t batadv_show_iface_status(struct kobject *kobj,
1082 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001083{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +02001084 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +02001085 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001086 ssize_t length;
1087
Sven Eckelmann1392f552019-03-03 18:02:59 +01001088 batadv_sysfs_deprecated(attr);
1089
Sven Eckelmann56303d32012-06-05 22:31:31 +02001090 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +00001091 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001092 return 0;
1093
Marek Lindnere6c10f42011-02-18 12:33:20 +00001094 switch (hard_iface->if_status) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001095 case BATADV_IF_TO_BE_REMOVED:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001096 length = sprintf(buff, "disabling\n");
1097 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001098 case BATADV_IF_INACTIVE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001099 length = sprintf(buff, "inactive\n");
1100 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001101 case BATADV_IF_ACTIVE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001102 length = sprintf(buff, "active\n");
1103 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001104 case BATADV_IF_TO_BE_ACTIVATED:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001105 length = sprintf(buff, "enabling\n");
1106 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001107 case BATADV_IF_NOT_IN_USE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001108 default:
1109 length = sprintf(buff, "not in use\n");
1110 break;
1111 }
1112
Sven Eckelmann82047ad2016-01-17 11:01:10 +01001113 batadv_hardif_put(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001114
1115 return length;
1116}
1117
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001118#ifdef CONFIG_BATMAN_ADV_BATMAN_V
1119
1120/**
Sven Eckelmann7e9a8c22017-12-02 19:51:47 +01001121 * batadv_store_throughput_override() - parse and store throughput override
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001122 * entered by the user
1123 * @kobj: kobject representing the private mesh sysfs directory
1124 * @attr: the batman-adv attribute the user is interacting with
1125 * @buff: the buffer containing the user data
1126 * @count: number of bytes in the buffer
1127 *
1128 * Return: 'count' on success or a negative error code in case of failure
1129 */
1130static ssize_t batadv_store_throughput_override(struct kobject *kobj,
1131 struct attribute *attr,
1132 char *buff, size_t count)
1133{
1134 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1135 struct batadv_hard_iface *hard_iface;
Sven Eckelmann438b3d32019-03-03 19:25:26 +01001136 struct batadv_priv *bat_priv;
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001137 u32 tp_override;
1138 u32 old_tp_override;
1139 bool ret;
1140
Sven Eckelmann1392f552019-03-03 18:02:59 +01001141 batadv_sysfs_deprecated(attr);
1142
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001143 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1144 if (!hard_iface)
1145 return -EINVAL;
1146
1147 if (buff[count - 1] == '\n')
1148 buff[count - 1] = '\0';
1149
1150 ret = batadv_parse_throughput(net_dev, buff, "throughput_override",
1151 &tp_override);
1152 if (!ret)
1153 return count;
1154
1155 old_tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
1156 if (old_tp_override == tp_override)
1157 goto out;
1158
Sven Eckelmannb9fd14c2018-08-31 16:46:47 +02001159 batadv_info(hard_iface->soft_iface,
1160 "%s: %s: Changing from: %u.%u MBit to: %u.%u MBit\n",
1161 "throughput_override", net_dev->name,
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001162 old_tp_override / 10, old_tp_override % 10,
1163 tp_override / 10, tp_override % 10);
1164
1165 atomic_set(&hard_iface->bat_v.throughput_override, tp_override);
1166
Sven Eckelmann438b3d32019-03-03 19:25:26 +01001167 if (hard_iface->soft_iface) {
1168 bat_priv = netdev_priv(hard_iface->soft_iface);
1169 batadv_netlink_notify_hardif(bat_priv, hard_iface);
1170 }
Sven Eckelmann7e6f4612018-11-23 16:07:12 +01001171
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001172out:
1173 batadv_hardif_put(hard_iface);
1174 return count;
1175}
1176
1177static ssize_t batadv_show_throughput_override(struct kobject *kobj,
1178 struct attribute *attr,
1179 char *buff)
1180{
1181 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1182 struct batadv_hard_iface *hard_iface;
1183 u32 tp_override;
1184
Sven Eckelmann1392f552019-03-03 18:02:59 +01001185 batadv_sysfs_deprecated(attr);
1186
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001187 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1188 if (!hard_iface)
1189 return -EINVAL;
1190
1191 tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
1192
1193 return sprintf(buff, "%u.%u MBit\n", tp_override / 10,
1194 tp_override % 10);
1195}
1196
1197#endif
1198
Sven Eckelmann507b37c2016-09-01 10:25:12 +02001199static BATADV_ATTR(mesh_iface, 0644, batadv_show_mesh_iface,
Sven Eckelmann347c80f02012-06-03 22:19:07 +02001200 batadv_store_mesh_iface);
Sven Eckelmann507b37c2016-09-01 10:25:12 +02001201static BATADV_ATTR(iface_status, 0444, batadv_show_iface_status, NULL);
Linus Luessing7f136cd2016-01-16 16:40:11 +08001202#ifdef CONFIG_BATMAN_ADV_BATMAN_V
Sven Eckelmann507b37c2016-09-01 10:25:12 +02001203BATADV_ATTR_HIF_UINT(elp_interval, bat_v.elp_interval, 0644,
Linus Luessing7f136cd2016-01-16 16:40:11 +08001204 2 * BATADV_JITTER, INT_MAX, NULL);
Sven Eckelmann507b37c2016-09-01 10:25:12 +02001205static BATADV_ATTR(throughput_override, 0644, batadv_show_throughput_override,
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001206 batadv_store_throughput_override);
Linus Luessing7f136cd2016-01-16 16:40:11 +08001207#endif
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001208
Sven Eckelmannb4d66b82012-06-05 22:31:29 +02001209static struct batadv_attribute *batadv_batman_attrs[] = {
Sven Eckelmann0ff9b862012-05-12 18:33:52 +02001210 &batadv_attr_mesh_iface,
1211 &batadv_attr_iface_status,
Linus Luessing7f136cd2016-01-16 16:40:11 +08001212#ifdef CONFIG_BATMAN_ADV_BATMAN_V
1213 &batadv_attr_elp_interval,
Antonio Quartulli0b5ecc62016-01-16 16:40:14 +08001214 &batadv_attr_throughput_override,
Linus Luessing7f136cd2016-01-16 16:40:11 +08001215#endif
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001216 NULL,
1217};
1218
Sven Eckelmannff15c272017-12-02 19:51:53 +01001219/**
1220 * batadv_sysfs_add_hardif() - Add hard interface specific sysfs entries
1221 * @hardif_obj: address where to store the pointer to new sysfs folder
1222 * @dev: netdev struct of the hard interface
1223 *
1224 * Return: 0 on success or negative error number in case of failure
1225 */
Sven Eckelmann5853e222012-05-12 02:09:24 +02001226int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001227{
1228 struct kobject *hardif_kobject = &dev->dev.kobj;
Sven Eckelmannb4d66b82012-06-05 22:31:29 +02001229 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001230 int err;
1231
Sven Eckelmann036cbfe2012-06-03 22:19:09 +02001232 *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
1233 hardif_kobject);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001234
1235 if (!*hardif_obj) {
Sven Eckelmann3e348192012-05-16 20:23:22 +02001236 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
Sven Eckelmann036cbfe2012-06-03 22:19:09 +02001237 BATADV_SYSFS_IF_BAT_SUBDIR);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001238 goto out;
1239 }
1240
Sven Eckelmann0ff9b862012-05-12 18:33:52 +02001241 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001242 err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
1243 if (err) {
Sven Eckelmann3e348192012-05-16 20:23:22 +02001244 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
Sven Eckelmann036cbfe2012-06-03 22:19:09 +02001245 dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
Sven Eckelmann3e348192012-05-16 20:23:22 +02001246 ((*bat_attr)->attr).name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001247 goto rem_attr;
1248 }
1249 }
1250
1251 return 0;
1252
1253rem_attr:
Sven Eckelmann0ff9b862012-05-12 18:33:52 +02001254 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001255 sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
1256out:
1257 return -ENOMEM;
1258}
1259
Sven Eckelmannff15c272017-12-02 19:51:53 +01001260/**
1261 * batadv_sysfs_del_hardif() - Remove hard interface specific sysfs entries
1262 * @hardif_obj: address to the pointer to which stores batman-adv sysfs folder
1263 * of the hard interface
1264 */
Sven Eckelmann5853e222012-05-12 02:09:24 +02001265void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001266{
Sven Eckelmannf4acb102016-06-13 07:41:32 +02001267 kobject_uevent(*hardif_obj, KOBJ_REMOVE);
1268 kobject_del(*hardif_obj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001269 kobject_put(*hardif_obj);
1270 *hardif_obj = NULL;
1271}