blob: f40cb0436eba1ece028c9852d5f69b9c504f62b4 [file] [log] [blame]
Simon Wunderliche19f9752014-01-04 18:04:25 +01001/* Copyright (C) 2010-2014 B.A.T.M.A.N. contributors:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00002 *
3 * Marek Lindner
4 *
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.
8 *
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.
13 *
14 * You should have received a copy of the GNU General Public License
Antonio Quartulliebf38fb2013-11-03 20:40:48 +010015 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000016 */
17
18#include "main.h"
Sven Eckelmannb706b132012-06-10 23:58:51 +020019#include "sysfs.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000020#include "translation-table.h"
Antonio Quartulli33af49a2012-08-08 18:50:57 +020021#include "distributed-arp-table.h"
Marek Lindner3f4841f2013-04-23 21:40:00 +080022#include "network-coding.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000023#include "originator.h"
24#include "hard-interface.h"
Antonio Quartulli90f44352013-07-02 11:04:35 +020025#include "soft-interface.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000026#include "gateway_common.h"
27#include "gateway_client.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000028
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020029static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020030{
31 struct device *dev = container_of(obj->parent, struct device, kobj);
Antonio Quartullif1386942014-05-10 18:56:37 +020032
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020033 return to_net_dev(dev);
34}
35
Sven Eckelmann56303d32012-06-05 22:31:31 +020036static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020037{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020038 struct net_device *net_dev = batadv_kobj_to_netdev(obj);
Antonio Quartullif1386942014-05-10 18:56:37 +020039
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020040 return netdev_priv(net_dev);
41}
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000042
Antonio Quartulli90f44352013-07-02 11:04:35 +020043/**
44 * batadv_vlan_kobj_to_batpriv - convert a vlan kobj in the associated batpriv
45 * @obj: kobject to covert
46 *
47 * Returns the associated batadv_priv struct.
48 */
49static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
50{
51 /* VLAN specific attributes are located in the root sysfs folder if they
52 * refer to the untagged VLAN..
53 */
54 if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
55 return batadv_kobj_to_batpriv(obj);
56
57 /* ..while the attributes for the tagged vlans are located in
58 * the in the corresponding "vlan%VID" subfolder
59 */
60 return batadv_kobj_to_batpriv(obj->parent);
61}
62
63/**
64 * batadv_kobj_to_vlan - convert a kobj in the associated softif_vlan struct
65 * @obj: kobject to covert
66 *
67 * Returns the associated softif_vlan struct if found, NULL otherwise.
68 */
69static struct batadv_softif_vlan *
70batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
71{
72 struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
73
74 rcu_read_lock();
75 hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
76 if (vlan_tmp->kobj != obj)
77 continue;
78
79 if (!atomic_inc_not_zero(&vlan_tmp->refcount))
80 continue;
81
82 vlan = vlan_tmp;
83 break;
84 }
85 rcu_read_unlock();
86
87 return vlan;
88}
89
Sven Eckelmann347c80f2012-06-03 22:19:07 +020090#define BATADV_UEV_TYPE_VAR "BATTYPE="
91#define BATADV_UEV_ACTION_VAR "BATACTION="
92#define BATADV_UEV_DATA_VAR "BATDATA="
Antonio Quartullic6bda682011-04-26 18:26:01 +020093
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020094static char *batadv_uev_action_str[] = {
Antonio Quartullic6bda682011-04-26 18:26:01 +020095 "add",
96 "del",
97 "change"
98};
99
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200100static char *batadv_uev_type_str[] = {
Antonio Quartullic6bda682011-04-26 18:26:01 +0200101 "gw"
102};
103
Antonio Quartulli90f44352013-07-02 11:04:35 +0200104/* Use this, if you have customized show and store functions for vlan attrs */
105#define BATADV_ATTR_VLAN(_name, _mode, _show, _store) \
106struct batadv_attribute batadv_attr_vlan_##_name = { \
107 .attr = {.name = __stringify(_name), \
108 .mode = _mode }, \
109 .show = _show, \
110 .store = _store, \
Antonio Quartulli2b64df22014-05-15 11:24:26 +0200111}
Antonio Quartulli90f44352013-07-02 11:04:35 +0200112
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000113/* Use this, if you have customized show and store functions */
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200114#define BATADV_ATTR(_name, _mode, _show, _store) \
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200115struct batadv_attribute batadv_attr_##_name = { \
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200116 .attr = {.name = __stringify(_name), \
117 .mode = _mode }, \
118 .show = _show, \
119 .store = _store, \
Antonio Quartulli2b64df22014-05-15 11:24:26 +0200120}
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000121
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200122#define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200123ssize_t batadv_store_##_name(struct kobject *kobj, \
124 struct attribute *attr, char *buff, \
125 size_t count) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000126{ \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200127 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200128 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200129 \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200130 return __batadv_store_bool_attr(buff, count, _post_func, attr, \
131 &bat_priv->_name, net_dev); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000132}
133
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200134#define BATADV_ATTR_SIF_SHOW_BOOL(_name) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200135ssize_t batadv_show_##_name(struct kobject *kobj, \
136 struct attribute *attr, char *buff) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000137{ \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200138 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200139 \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000140 return sprintf(buff, "%s\n", \
141 atomic_read(&bat_priv->_name) == 0 ? \
142 "disabled" : "enabled"); \
143} \
144
Marek Lindnerf245c382012-03-11 06:17:51 +0800145/* Use this, if you are going to turn a [name] in the soft-interface
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200146 * (bat_priv) on or off
147 */
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200148#define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func) \
149 static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
150 static BATADV_ATTR_SIF_SHOW_BOOL(_name) \
151 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
152 batadv_store_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000153
154
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200155#define BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200156ssize_t batadv_store_##_name(struct kobject *kobj, \
157 struct attribute *attr, char *buff, \
158 size_t count) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000159{ \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200160 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200161 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200162 \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200163 return __batadv_store_uint_attr(buff, count, _min, _max, \
164 _post_func, attr, \
165 &bat_priv->_name, net_dev); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000166}
167
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200168#define BATADV_ATTR_SIF_SHOW_UINT(_name) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200169ssize_t batadv_show_##_name(struct kobject *kobj, \
170 struct attribute *attr, char *buff) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000171{ \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200172 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200173 \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000174 return sprintf(buff, "%i\n", atomic_read(&bat_priv->_name)); \
175} \
176
Marek Lindnerf245c382012-03-11 06:17:51 +0800177/* Use this, if you are going to set [name] in the soft-interface
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200178 * (bat_priv) to an unsigned integer value
179 */
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200180#define BATADV_ATTR_SIF_UINT(_name, _mode, _min, _max, _post_func) \
181 static BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func)\
182 static BATADV_ATTR_SIF_SHOW_UINT(_name) \
183 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
184 batadv_store_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000185
Antonio Quartulli90f44352013-07-02 11:04:35 +0200186#define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
187ssize_t batadv_store_vlan_##_name(struct kobject *kobj, \
188 struct attribute *attr, char *buff, \
189 size_t count) \
190{ \
191 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
192 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
193 kobj); \
194 size_t res = __batadv_store_bool_attr(buff, count, _post_func, \
195 attr, &vlan->_name, \
196 bat_priv->soft_iface); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200197 \
Antonio Quartulli90f44352013-07-02 11:04:35 +0200198 batadv_softif_vlan_free_ref(vlan); \
199 return res; \
200}
201
202#define BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
203ssize_t batadv_show_vlan_##_name(struct kobject *kobj, \
204 struct attribute *attr, char *buff) \
205{ \
206 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
207 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
208 kobj); \
209 size_t res = sprintf(buff, "%s\n", \
210 atomic_read(&vlan->_name) == 0 ? \
211 "disabled" : "enabled"); \
Antonio Quartullif1386942014-05-10 18:56:37 +0200212 \
Antonio Quartulli90f44352013-07-02 11:04:35 +0200213 batadv_softif_vlan_free_ref(vlan); \
214 return res; \
215}
216
217/* Use this, if you are going to turn a [name] in the vlan struct on or off */
218#define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func) \
219 static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
220 static BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
221 static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name, \
222 batadv_store_vlan_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000223
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200224static int batadv_store_bool_attr(char *buff, size_t count,
225 struct net_device *net_dev,
226 const char *attr_name, atomic_t *attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000227{
228 int enabled = -1;
229
230 if (buff[count - 1] == '\n')
231 buff[count - 1] = '\0';
232
233 if ((strncmp(buff, "1", 2) == 0) ||
234 (strncmp(buff, "enable", 7) == 0) ||
235 (strncmp(buff, "enabled", 8) == 0))
236 enabled = 1;
237
238 if ((strncmp(buff, "0", 2) == 0) ||
239 (strncmp(buff, "disable", 8) == 0) ||
240 (strncmp(buff, "disabled", 9) == 0))
241 enabled = 0;
242
243 if (enabled < 0) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200244 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
245 attr_name, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000246 return -EINVAL;
247 }
248
249 if (atomic_read(attr) == enabled)
250 return count;
251
Sven Eckelmann3e348192012-05-16 20:23:22 +0200252 batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
253 atomic_read(attr) == 1 ? "enabled" : "disabled",
254 enabled == 1 ? "enabled" : "disabled");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000255
Eric Dumazet95c96172012-04-15 05:58:06 +0000256 atomic_set(attr, (unsigned int)enabled);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000257 return count;
258}
259
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200260static inline ssize_t
261__batadv_store_bool_attr(char *buff, size_t count,
262 void (*post_func)(struct net_device *),
263 struct attribute *attr,
264 atomic_t *attr_store, struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000265{
266 int ret;
267
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200268 ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
269 attr_store);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000270 if (post_func && ret)
271 post_func(net_dev);
272
273 return ret;
274}
275
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200276static int batadv_store_uint_attr(const char *buff, size_t count,
277 struct net_device *net_dev,
278 const char *attr_name,
279 unsigned int min, unsigned int max,
280 atomic_t *attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000281{
282 unsigned long uint_val;
283 int ret;
284
Sven Eckelmann25a92b12011-09-30 13:32:01 +0200285 ret = kstrtoul(buff, 10, &uint_val);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000286 if (ret) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200287 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
288 attr_name, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000289 return -EINVAL;
290 }
291
292 if (uint_val < min) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200293 batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
294 attr_name, uint_val, min);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000295 return -EINVAL;
296 }
297
298 if (uint_val > max) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200299 batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
300 attr_name, uint_val, max);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000301 return -EINVAL;
302 }
303
304 if (atomic_read(attr) == uint_val)
305 return count;
306
Sven Eckelmann3e348192012-05-16 20:23:22 +0200307 batadv_info(net_dev, "%s: Changing from: %i to: %lu\n",
308 attr_name, atomic_read(attr), uint_val);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000309
310 atomic_set(attr, uint_val);
311 return count;
312}
313
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200314static inline ssize_t
315__batadv_store_uint_attr(const char *buff, size_t count,
316 int min, int max,
317 void (*post_func)(struct net_device *),
318 const struct attribute *attr,
319 atomic_t *attr_store, struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000320{
321 int ret;
322
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200323 ret = batadv_store_uint_attr(buff, count, net_dev, attr->name, min, max,
324 attr_store);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000325 if (post_func && ret)
326 post_func(net_dev);
327
328 return ret;
329}
330
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200331static ssize_t batadv_show_bat_algo(struct kobject *kobj,
332 struct attribute *attr, char *buff)
Marek Lindnerea3d2fd2011-11-29 00:15:37 +0800333{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200334 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Antonio Quartullif1386942014-05-10 18:56:37 +0200335
Marek Lindnerea3d2fd2011-11-29 00:15:37 +0800336 return sprintf(buff, "%s\n", bat_priv->bat_algo_ops->name);
337}
338
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100339static void batadv_post_gw_reselect(struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000340{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200341 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Antonio Quartullif1386942014-05-10 18:56:37 +0200342
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100343 batadv_gw_reselect(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000344}
345
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200346static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
347 char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000348{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200349 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000350 int bytes_written;
351
352 switch (atomic_read(&bat_priv->gw_mode)) {
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200353 case BATADV_GW_MODE_CLIENT:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200354 bytes_written = sprintf(buff, "%s\n",
355 BATADV_GW_MODE_CLIENT_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000356 break;
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200357 case BATADV_GW_MODE_SERVER:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200358 bytes_written = sprintf(buff, "%s\n",
359 BATADV_GW_MODE_SERVER_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000360 break;
361 default:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200362 bytes_written = sprintf(buff, "%s\n",
363 BATADV_GW_MODE_OFF_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000364 break;
365 }
366
367 return bytes_written;
368}
369
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200370static ssize_t batadv_store_gw_mode(struct kobject *kobj,
371 struct attribute *attr, char *buff,
372 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000373{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200374 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200375 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000376 char *curr_gw_mode_str;
377 int gw_mode_tmp = -1;
378
379 if (buff[count - 1] == '\n')
380 buff[count - 1] = '\0';
381
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200382 if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
383 strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200384 gw_mode_tmp = BATADV_GW_MODE_OFF;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000385
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200386 if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
387 strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200388 gw_mode_tmp = BATADV_GW_MODE_CLIENT;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000389
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200390 if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
391 strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200392 gw_mode_tmp = BATADV_GW_MODE_SERVER;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000393
394 if (gw_mode_tmp < 0) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200395 batadv_info(net_dev,
396 "Invalid parameter for 'gw mode' setting received: %s\n",
397 buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000398 return -EINVAL;
399 }
400
401 if (atomic_read(&bat_priv->gw_mode) == gw_mode_tmp)
402 return count;
403
404 switch (atomic_read(&bat_priv->gw_mode)) {
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200405 case BATADV_GW_MODE_CLIENT:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200406 curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000407 break;
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200408 case BATADV_GW_MODE_SERVER:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200409 curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000410 break;
411 default:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200412 curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000413 break;
414 }
415
Sven Eckelmann3e348192012-05-16 20:23:22 +0200416 batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
417 curr_gw_mode_str, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000418
Antonio Quartullif3163182013-11-04 20:59:40 +0100419 /* Invoking batadv_gw_reselect() is not enough to really de-select the
420 * current GW. It will only instruct the gateway client code to perform
421 * a re-election the next time that this is needed.
422 *
423 * When gw client mode is being switched off the current GW must be
424 * de-selected explicitly otherwise no GW_ADD uevent is thrown on
425 * client mode re-activation. This is operation is performed in
426 * batadv_gw_check_client_stop().
427 */
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100428 batadv_gw_reselect(bat_priv);
Antonio Quartullic6eaa3f2013-07-13 00:06:00 +0200429 /* always call batadv_gw_check_client_stop() before changing the gateway
430 * state
431 */
432 batadv_gw_check_client_stop(bat_priv);
Eric Dumazet95c96172012-04-15 05:58:06 +0000433 atomic_set(&bat_priv->gw_mode, (unsigned int)gw_mode_tmp);
Marek Lindner414254e2013-04-23 21:39:58 +0800434 batadv_gw_tvlv_container_update(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000435 return count;
436}
437
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200438static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
439 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000440{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200441 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Marek Lindner414254e2013-04-23 21:39:58 +0800442 uint32_t down, up;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000443
Marek Lindner414254e2013-04-23 21:39:58 +0800444 down = atomic_read(&bat_priv->gw.bandwidth_down);
445 up = atomic_read(&bat_priv->gw.bandwidth_up);
446
447 return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
448 down % 10, up / 10, up % 10);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000449}
450
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200451static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
452 struct attribute *attr, char *buff,
453 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000454{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200455 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000456
457 if (buff[count - 1] == '\n')
458 buff[count - 1] = '\0';
459
Sven Eckelmann84d5e5e2012-05-12 02:09:30 +0200460 return batadv_gw_bandwidth_set(net_dev, buff, count);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000461}
462
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100463/**
464 * batadv_show_isolation_mark - print the current isolation mark/mask
465 * @kobj: kobject representing the private mesh sysfs directory
466 * @attr: the batman-adv attribute the user is interacting with
467 * @buff: the buffer that will contain the data to send back to the user
468 *
469 * Returns the number of bytes written into 'buff' on success or a negative
470 * error code in case of failure
471 */
472static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
473 struct attribute *attr, char *buff)
474{
475 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
476
477 return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
478 bat_priv->isolation_mark_mask);
479}
480
481/**
482 * batadv_store_isolation_mark - parse and store the isolation mark/mask entered
483 * by the user
484 * @kobj: kobject representing the private mesh sysfs directory
485 * @attr: the batman-adv attribute the user is interacting with
486 * @buff: the buffer containing the user data
487 * @count: number of bytes in the buffer
488 *
489 * Returns 'count' on success or a negative error code in case of failure
490 */
491static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
492 struct attribute *attr, char *buff,
493 size_t count)
494{
495 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
496 struct batadv_priv *bat_priv = netdev_priv(net_dev);
497 uint32_t mark, mask;
498 char *mask_ptr;
499
500 /* parse the mask if it has been specified, otherwise assume the mask is
501 * the biggest possible
502 */
503 mask = 0xFFFFFFFF;
504 mask_ptr = strchr(buff, '/');
505 if (mask_ptr) {
506 *mask_ptr = '\0';
507 mask_ptr++;
508
509 /* the mask must be entered in hex base as it is going to be a
510 * bitmask and not a prefix length
511 */
512 if (kstrtou32(mask_ptr, 16, &mask) < 0)
513 return -EINVAL;
514 }
515
516 /* the mark can be entered in any base */
517 if (kstrtou32(buff, 0, &mark) < 0)
518 return -EINVAL;
519
520 bat_priv->isolation_mark_mask = mask;
521 /* erase bits not covered by the mask */
522 bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;
523
524 batadv_info(net_dev,
525 "New skb mark for extended isolation: %#.8x/%#.8x\n",
526 bat_priv->isolation_mark, bat_priv->isolation_mark_mask);
527
528 return count;
529}
530
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200531BATADV_ATTR_SIF_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL);
532BATADV_ATTR_SIF_BOOL(bonding, S_IRUGO | S_IWUSR, NULL);
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100533#ifdef CONFIG_BATMAN_ADV_BLA
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200534BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, S_IRUGO | S_IWUSR, NULL);
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100535#endif
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200536#ifdef CONFIG_BATMAN_ADV_DAT
Marek Lindner17cf0ea2013-04-23 21:39:59 +0800537BATADV_ATTR_SIF_BOOL(distributed_arp_table, S_IRUGO | S_IWUSR,
538 batadv_dat_status_update);
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200539#endif
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200540BATADV_ATTR_SIF_BOOL(fragmentation, S_IRUGO | S_IWUSR, batadv_update_min_mtu);
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200541static BATADV_ATTR(routing_algo, S_IRUGO, batadv_show_bat_algo, NULL);
542static BATADV_ATTR(gw_mode, S_IRUGO | S_IWUSR, batadv_show_gw_mode,
543 batadv_store_gw_mode);
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200544BATADV_ATTR_SIF_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * BATADV_JITTER,
545 INT_MAX, NULL);
546BATADV_ATTR_SIF_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, BATADV_TQ_MAX_VALUE,
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200547 NULL);
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200548BATADV_ATTR_SIF_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, BATADV_TQ_MAX_VALUE,
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100549 batadv_post_gw_reselect);
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200550static BATADV_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, batadv_show_gw_bwidth,
551 batadv_store_gw_bwidth);
Linus Lüssing1d8ab8d2014-02-15 17:47:52 +0100552#ifdef CONFIG_BATMAN_ADV_MCAST
553BATADV_ATTR_SIF_BOOL(multicast_mode, S_IRUGO | S_IWUSR, NULL);
554#endif
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000555#ifdef CONFIG_BATMAN_ADV_DEBUG
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200556BATADV_ATTR_SIF_UINT(log_level, S_IRUGO | S_IWUSR, 0, BATADV_DBG_ALL, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000557#endif
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100558#ifdef CONFIG_BATMAN_ADV_NC
Marek Lindner3f4841f2013-04-23 21:40:00 +0800559BATADV_ATTR_SIF_BOOL(network_coding, S_IRUGO | S_IWUSR,
560 batadv_nc_status_update);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100561#endif
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100562static BATADV_ATTR(isolation_mark, S_IRUGO | S_IWUSR,
563 batadv_show_isolation_mark, batadv_store_isolation_mark);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000564
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200565static struct batadv_attribute *batadv_mesh_attrs[] = {
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200566 &batadv_attr_aggregated_ogms,
567 &batadv_attr_bonding,
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100568#ifdef CONFIG_BATMAN_ADV_BLA
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200569 &batadv_attr_bridge_loop_avoidance,
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100570#endif
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200571#ifdef CONFIG_BATMAN_ADV_DAT
572 &batadv_attr_distributed_arp_table,
573#endif
Linus Lüssing1d8ab8d2014-02-15 17:47:52 +0100574#ifdef CONFIG_BATMAN_ADV_MCAST
575 &batadv_attr_multicast_mode,
576#endif
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200577 &batadv_attr_fragmentation,
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200578 &batadv_attr_routing_algo,
579 &batadv_attr_gw_mode,
580 &batadv_attr_orig_interval,
581 &batadv_attr_hop_penalty,
582 &batadv_attr_gw_sel_class,
583 &batadv_attr_gw_bandwidth,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000584#ifdef CONFIG_BATMAN_ADV_DEBUG
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200585 &batadv_attr_log_level,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000586#endif
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100587#ifdef CONFIG_BATMAN_ADV_NC
588 &batadv_attr_network_coding,
589#endif
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100590 &batadv_attr_isolation_mark,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000591 NULL,
592};
593
Antonio Quartullib8cbd812013-07-02 11:04:36 +0200594BATADV_ATTR_VLAN_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL);
595
Antonio Quartulli90f44352013-07-02 11:04:35 +0200596/**
597 * batadv_vlan_attrs - array of vlan specific sysfs attributes
598 */
599static struct batadv_attribute *batadv_vlan_attrs[] = {
Antonio Quartullib8cbd812013-07-02 11:04:36 +0200600 &batadv_attr_vlan_ap_isolation,
Antonio Quartulli90f44352013-07-02 11:04:35 +0200601 NULL,
602};
603
Sven Eckelmann5853e222012-05-12 02:09:24 +0200604int batadv_sysfs_add_meshif(struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000605{
606 struct kobject *batif_kobject = &dev->dev.kobj;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200607 struct batadv_priv *bat_priv = netdev_priv(dev);
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200608 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000609 int err;
610
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200611 bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000612 batif_kobject);
613 if (!bat_priv->mesh_obj) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200614 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200615 BATADV_SYSFS_IF_MESH_SUBDIR);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000616 goto out;
617 }
618
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200619 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000620 err = sysfs_create_file(bat_priv->mesh_obj,
621 &((*bat_attr)->attr));
622 if (err) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200623 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200624 dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
Sven Eckelmann3e348192012-05-16 20:23:22 +0200625 ((*bat_attr)->attr).name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000626 goto rem_attr;
627 }
628 }
629
630 return 0;
631
632rem_attr:
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200633 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000634 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
635
636 kobject_put(bat_priv->mesh_obj);
637 bat_priv->mesh_obj = NULL;
638out:
639 return -ENOMEM;
640}
641
Sven Eckelmann5853e222012-05-12 02:09:24 +0200642void batadv_sysfs_del_meshif(struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000643{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200644 struct batadv_priv *bat_priv = netdev_priv(dev);
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200645 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000646
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200647 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000648 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
649
650 kobject_put(bat_priv->mesh_obj);
651 bat_priv->mesh_obj = NULL;
652}
653
Antonio Quartulli90f44352013-07-02 11:04:35 +0200654/**
655 * batadv_sysfs_add_vlan - add all the needed sysfs objects for the new vlan
656 * @dev: netdev of the mesh interface
657 * @vlan: private data of the newly added VLAN interface
658 *
659 * Returns 0 on success and -ENOMEM if any of the structure allocations fails.
660 */
661int batadv_sysfs_add_vlan(struct net_device *dev,
662 struct batadv_softif_vlan *vlan)
663{
664 char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
665 struct batadv_priv *bat_priv = netdev_priv(dev);
666 struct batadv_attribute **bat_attr;
667 int err;
668
669 if (vlan->vid & BATADV_VLAN_HAS_TAG) {
670 sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
671 vlan->vid & VLAN_VID_MASK);
672
673 vlan->kobj = kobject_create_and_add(vlan_subdir,
674 bat_priv->mesh_obj);
675 if (!vlan->kobj) {
676 batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
677 dev->name, vlan_subdir);
678 goto out;
679 }
680 } else {
681 /* the untagged LAN uses the root folder to store its "VLAN
682 * specific attributes"
683 */
684 vlan->kobj = bat_priv->mesh_obj;
685 kobject_get(bat_priv->mesh_obj);
686 }
687
688 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
689 err = sysfs_create_file(vlan->kobj,
690 &((*bat_attr)->attr));
691 if (err) {
692 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
693 dev->name, vlan_subdir,
694 ((*bat_attr)->attr).name);
695 goto rem_attr;
696 }
697 }
698
699 return 0;
700
701rem_attr:
702 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
703 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
704
705 kobject_put(vlan->kobj);
706 vlan->kobj = NULL;
707out:
708 return -ENOMEM;
709}
710
711/**
712 * batadv_sysfs_del_vlan - remove all the sysfs objects for a given VLAN
713 * @bat_priv: the bat priv with all the soft interface information
714 * @vlan: the private data of the VLAN to destroy
715 */
716void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
717 struct batadv_softif_vlan *vlan)
718{
719 struct batadv_attribute **bat_attr;
720
721 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
722 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
723
724 kobject_put(vlan->kobj);
725 vlan->kobj = NULL;
726}
727
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200728static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
729 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000730{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200731 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200732 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000733 ssize_t length;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200734 const char *ifname;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000735
Sven Eckelmann56303d32012-06-05 22:31:31 +0200736 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000737 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000738 return 0;
739
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200740 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
741 ifname = "none";
742 else
743 ifname = hard_iface->soft_iface->name;
744
745 length = sprintf(buff, "%s\n", ifname);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000746
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200747 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000748
749 return length;
750}
751
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200752static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
753 struct attribute *attr, char *buff,
754 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000755{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200756 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200757 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000758 int status_tmp = -1;
Marek Lindnered75ccb2011-02-10 14:33:51 +0000759 int ret = count;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000760
Sven Eckelmann56303d32012-06-05 22:31:31 +0200761 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000762 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000763 return count;
764
765 if (buff[count - 1] == '\n')
766 buff[count - 1] = '\0';
767
768 if (strlen(buff) >= IFNAMSIZ) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100769 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
770 buff);
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200771 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000772 return -EINVAL;
773 }
774
775 if (strncmp(buff, "none", 4) == 0)
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200776 status_tmp = BATADV_IF_NOT_IN_USE;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000777 else
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200778 status_tmp = BATADV_IF_I_WANT_YOU;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000779
Marek Lindnere6c10f42011-02-18 12:33:20 +0000780 if (hard_iface->if_status == status_tmp)
781 goto out;
782
783 if ((hard_iface->soft_iface) &&
784 (strncmp(hard_iface->soft_iface->name, buff, IFNAMSIZ) == 0))
Marek Lindnered75ccb2011-02-10 14:33:51 +0000785 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000786
Matthias Schifferac16d142013-05-28 17:32:32 +0200787 rtnl_lock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000788
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200789 if (status_tmp == BATADV_IF_NOT_IN_USE) {
Sven Eckelmanna15fd362013-02-11 17:10:24 +0800790 batadv_hardif_disable_interface(hard_iface,
791 BATADV_IF_CLEANUP_AUTO);
Sven Eckelmann3a4375a2011-05-03 13:10:06 +0200792 goto unlock;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000793 }
794
Sven Eckelmann3a4375a2011-05-03 13:10:06 +0200795 /* if the interface already is in use */
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200796 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
Sven Eckelmanna15fd362013-02-11 17:10:24 +0800797 batadv_hardif_disable_interface(hard_iface,
798 BATADV_IF_CLEANUP_AUTO);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000799
Sven Eckelmann95638772012-05-12 02:09:31 +0200800 ret = batadv_hardif_enable_interface(hard_iface, buff);
Sven Eckelmann3a4375a2011-05-03 13:10:06 +0200801
802unlock:
803 rtnl_unlock();
Marek Lindnered75ccb2011-02-10 14:33:51 +0000804out:
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200805 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000806 return ret;
807}
808
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200809static ssize_t batadv_show_iface_status(struct kobject *kobj,
810 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000811{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200812 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200813 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000814 ssize_t length;
815
Sven Eckelmann56303d32012-06-05 22:31:31 +0200816 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000817 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000818 return 0;
819
Marek Lindnere6c10f42011-02-18 12:33:20 +0000820 switch (hard_iface->if_status) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200821 case BATADV_IF_TO_BE_REMOVED:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000822 length = sprintf(buff, "disabling\n");
823 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200824 case BATADV_IF_INACTIVE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000825 length = sprintf(buff, "inactive\n");
826 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200827 case BATADV_IF_ACTIVE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000828 length = sprintf(buff, "active\n");
829 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200830 case BATADV_IF_TO_BE_ACTIVATED:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000831 length = sprintf(buff, "enabling\n");
832 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200833 case BATADV_IF_NOT_IN_USE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000834 default:
835 length = sprintf(buff, "not in use\n");
836 break;
837 }
838
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200839 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000840
841 return length;
842}
843
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200844static BATADV_ATTR(mesh_iface, S_IRUGO | S_IWUSR, batadv_show_mesh_iface,
845 batadv_store_mesh_iface);
846static BATADV_ATTR(iface_status, S_IRUGO, batadv_show_iface_status, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000847
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200848static struct batadv_attribute *batadv_batman_attrs[] = {
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200849 &batadv_attr_mesh_iface,
850 &batadv_attr_iface_status,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000851 NULL,
852};
853
Sven Eckelmann5853e222012-05-12 02:09:24 +0200854int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000855{
856 struct kobject *hardif_kobject = &dev->dev.kobj;
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200857 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000858 int err;
859
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200860 *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
861 hardif_kobject);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000862
863 if (!*hardif_obj) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200864 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200865 BATADV_SYSFS_IF_BAT_SUBDIR);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000866 goto out;
867 }
868
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200869 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000870 err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
871 if (err) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200872 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200873 dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
Sven Eckelmann3e348192012-05-16 20:23:22 +0200874 ((*bat_attr)->attr).name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000875 goto rem_attr;
876 }
877 }
878
879 return 0;
880
881rem_attr:
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200882 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000883 sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
884out:
885 return -ENOMEM;
886}
887
Sven Eckelmann5853e222012-05-12 02:09:24 +0200888void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000889{
890 kobject_put(*hardif_obj);
891 *hardif_obj = NULL;
892}
Antonio Quartullic6bda682011-04-26 18:26:01 +0200893
Sven Eckelmann56303d32012-06-05 22:31:31 +0200894int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200895 enum batadv_uev_action action, const char *data)
Antonio Quartullic6bda682011-04-26 18:26:01 +0200896{
Sven Eckelmann5346c352012-05-05 13:27:28 +0200897 int ret = -ENOMEM;
Antonio Quartullic6bda682011-04-26 18:26:01 +0200898 struct kobject *bat_kobj;
899 char *uevent_env[4] = { NULL, NULL, NULL, NULL };
900
Marek Lindner736292c2013-01-12 19:19:06 +0800901 bat_kobj = &bat_priv->soft_iface->dev.kobj;
Antonio Quartullic6bda682011-04-26 18:26:01 +0200902
Himangi Saraogib98fe242014-06-29 00:06:29 +0530903 uevent_env[0] = kasprintf(GFP_ATOMIC,
904 "%s%s", BATADV_UEV_TYPE_VAR,
905 batadv_uev_type_str[type]);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200906 if (!uevent_env[0])
907 goto out;
908
Himangi Saraogib98fe242014-06-29 00:06:29 +0530909 uevent_env[1] = kasprintf(GFP_ATOMIC,
910 "%s%s", BATADV_UEV_ACTION_VAR,
911 batadv_uev_action_str[action]);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200912 if (!uevent_env[1])
913 goto out;
914
Antonio Quartullic6bda682011-04-26 18:26:01 +0200915 /* If the event is DEL, ignore the data field */
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200916 if (action != BATADV_UEV_DEL) {
Himangi Saraogib98fe242014-06-29 00:06:29 +0530917 uevent_env[2] = kasprintf(GFP_ATOMIC,
918 "%s%s", BATADV_UEV_DATA_VAR, data);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200919 if (!uevent_env[2])
920 goto out;
Antonio Quartullic6bda682011-04-26 18:26:01 +0200921 }
922
923 ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
924out:
925 kfree(uevent_env[0]);
926 kfree(uevent_env[1]);
927 kfree(uevent_env[2]);
928
Antonio Quartullic6bda682011-04-26 18:26:01 +0200929 if (ret)
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200930 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200931 "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200932 batadv_uev_type_str[type],
933 batadv_uev_action_str[action],
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200934 (action == BATADV_UEV_DEL ? "NULL" : data), ret);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200935 return ret;
936}