blob: e456bf6bb2844e61560fa961a6984d5ef83a8817 [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);
32 return to_net_dev(dev);
33}
34
Sven Eckelmann56303d32012-06-05 22:31:31 +020035static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020036{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020037 struct net_device *net_dev = batadv_kobj_to_netdev(obj);
Sven Eckelmann3d222bb2011-06-05 10:20:19 +020038 return netdev_priv(net_dev);
39}
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000040
Antonio Quartulli90f44352013-07-02 11:04:35 +020041/**
42 * batadv_vlan_kobj_to_batpriv - convert a vlan kobj in the associated batpriv
43 * @obj: kobject to covert
44 *
45 * Returns the associated batadv_priv struct.
46 */
47static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
48{
49 /* VLAN specific attributes are located in the root sysfs folder if they
50 * refer to the untagged VLAN..
51 */
52 if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
53 return batadv_kobj_to_batpriv(obj);
54
55 /* ..while the attributes for the tagged vlans are located in
56 * the in the corresponding "vlan%VID" subfolder
57 */
58 return batadv_kobj_to_batpriv(obj->parent);
59}
60
61/**
62 * batadv_kobj_to_vlan - convert a kobj in the associated softif_vlan struct
63 * @obj: kobject to covert
64 *
65 * Returns the associated softif_vlan struct if found, NULL otherwise.
66 */
67static struct batadv_softif_vlan *
68batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
69{
70 struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
71
72 rcu_read_lock();
73 hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
74 if (vlan_tmp->kobj != obj)
75 continue;
76
77 if (!atomic_inc_not_zero(&vlan_tmp->refcount))
78 continue;
79
80 vlan = vlan_tmp;
81 break;
82 }
83 rcu_read_unlock();
84
85 return vlan;
86}
87
Sven Eckelmann347c80f2012-06-03 22:19:07 +020088#define BATADV_UEV_TYPE_VAR "BATTYPE="
89#define BATADV_UEV_ACTION_VAR "BATACTION="
90#define BATADV_UEV_DATA_VAR "BATDATA="
Antonio Quartullic6bda682011-04-26 18:26:01 +020091
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020092static char *batadv_uev_action_str[] = {
Antonio Quartullic6bda682011-04-26 18:26:01 +020093 "add",
94 "del",
95 "change"
96};
97
Sven Eckelmann0ff9b862012-05-12 18:33:52 +020098static char *batadv_uev_type_str[] = {
Antonio Quartullic6bda682011-04-26 18:26:01 +020099 "gw"
100};
101
Antonio Quartulli90f44352013-07-02 11:04:35 +0200102/* Use this, if you have customized show and store functions for vlan attrs */
103#define BATADV_ATTR_VLAN(_name, _mode, _show, _store) \
104struct batadv_attribute batadv_attr_vlan_##_name = { \
105 .attr = {.name = __stringify(_name), \
106 .mode = _mode }, \
107 .show = _show, \
108 .store = _store, \
109};
110
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000111/* Use this, if you have customized show and store functions */
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200112#define BATADV_ATTR(_name, _mode, _show, _store) \
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200113struct batadv_attribute batadv_attr_##_name = { \
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200114 .attr = {.name = __stringify(_name), \
115 .mode = _mode }, \
116 .show = _show, \
117 .store = _store, \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000118};
119
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200120#define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200121ssize_t batadv_store_##_name(struct kobject *kobj, \
122 struct attribute *attr, char *buff, \
123 size_t count) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000124{ \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200125 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200126 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200127 return __batadv_store_bool_attr(buff, count, _post_func, attr, \
128 &bat_priv->_name, net_dev); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000129}
130
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200131#define BATADV_ATTR_SIF_SHOW_BOOL(_name) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200132ssize_t batadv_show_##_name(struct kobject *kobj, \
133 struct attribute *attr, char *buff) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000134{ \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200135 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000136 return sprintf(buff, "%s\n", \
137 atomic_read(&bat_priv->_name) == 0 ? \
138 "disabled" : "enabled"); \
139} \
140
Marek Lindnerf245c382012-03-11 06:17:51 +0800141/* Use this, if you are going to turn a [name] in the soft-interface
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200142 * (bat_priv) on or off
143 */
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200144#define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func) \
145 static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
146 static BATADV_ATTR_SIF_SHOW_BOOL(_name) \
147 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
148 batadv_store_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000149
150
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200151#define BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200152ssize_t batadv_store_##_name(struct kobject *kobj, \
153 struct attribute *attr, char *buff, \
154 size_t count) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000155{ \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200156 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200157 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200158 return __batadv_store_uint_attr(buff, count, _min, _max, \
159 _post_func, attr, \
160 &bat_priv->_name, net_dev); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000161}
162
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200163#define BATADV_ATTR_SIF_SHOW_UINT(_name) \
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200164ssize_t batadv_show_##_name(struct kobject *kobj, \
165 struct attribute *attr, char *buff) \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000166{ \
Sven Eckelmann56303d32012-06-05 22:31:31 +0200167 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000168 return sprintf(buff, "%i\n", atomic_read(&bat_priv->_name)); \
169} \
170
Marek Lindnerf245c382012-03-11 06:17:51 +0800171/* Use this, if you are going to set [name] in the soft-interface
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200172 * (bat_priv) to an unsigned integer value
173 */
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200174#define BATADV_ATTR_SIF_UINT(_name, _mode, _min, _max, _post_func) \
175 static BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func)\
176 static BATADV_ATTR_SIF_SHOW_UINT(_name) \
177 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
178 batadv_store_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000179
Antonio Quartulli90f44352013-07-02 11:04:35 +0200180#define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
181ssize_t batadv_store_vlan_##_name(struct kobject *kobj, \
182 struct attribute *attr, char *buff, \
183 size_t count) \
184{ \
185 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
186 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
187 kobj); \
188 size_t res = __batadv_store_bool_attr(buff, count, _post_func, \
189 attr, &vlan->_name, \
190 bat_priv->soft_iface); \
191 batadv_softif_vlan_free_ref(vlan); \
192 return res; \
193}
194
195#define BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
196ssize_t batadv_show_vlan_##_name(struct kobject *kobj, \
197 struct attribute *attr, char *buff) \
198{ \
199 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
200 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
201 kobj); \
202 size_t res = sprintf(buff, "%s\n", \
203 atomic_read(&vlan->_name) == 0 ? \
204 "disabled" : "enabled"); \
205 batadv_softif_vlan_free_ref(vlan); \
206 return res; \
207}
208
209/* Use this, if you are going to turn a [name] in the vlan struct on or off */
210#define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func) \
211 static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
212 static BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
213 static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name, \
214 batadv_store_vlan_##_name)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000215
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200216static int batadv_store_bool_attr(char *buff, size_t count,
217 struct net_device *net_dev,
218 const char *attr_name, atomic_t *attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000219{
220 int enabled = -1;
221
222 if (buff[count - 1] == '\n')
223 buff[count - 1] = '\0';
224
225 if ((strncmp(buff, "1", 2) == 0) ||
226 (strncmp(buff, "enable", 7) == 0) ||
227 (strncmp(buff, "enabled", 8) == 0))
228 enabled = 1;
229
230 if ((strncmp(buff, "0", 2) == 0) ||
231 (strncmp(buff, "disable", 8) == 0) ||
232 (strncmp(buff, "disabled", 9) == 0))
233 enabled = 0;
234
235 if (enabled < 0) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200236 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
237 attr_name, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000238 return -EINVAL;
239 }
240
241 if (atomic_read(attr) == enabled)
242 return count;
243
Sven Eckelmann3e348192012-05-16 20:23:22 +0200244 batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
245 atomic_read(attr) == 1 ? "enabled" : "disabled",
246 enabled == 1 ? "enabled" : "disabled");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000247
Eric Dumazet95c96172012-04-15 05:58:06 +0000248 atomic_set(attr, (unsigned int)enabled);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000249 return count;
250}
251
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200252static inline ssize_t
253__batadv_store_bool_attr(char *buff, size_t count,
254 void (*post_func)(struct net_device *),
255 struct attribute *attr,
256 atomic_t *attr_store, struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000257{
258 int ret;
259
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200260 ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
261 attr_store);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000262 if (post_func && ret)
263 post_func(net_dev);
264
265 return ret;
266}
267
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200268static int batadv_store_uint_attr(const char *buff, size_t count,
269 struct net_device *net_dev,
270 const char *attr_name,
271 unsigned int min, unsigned int max,
272 atomic_t *attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000273{
274 unsigned long uint_val;
275 int ret;
276
Sven Eckelmann25a92b12011-09-30 13:32:01 +0200277 ret = kstrtoul(buff, 10, &uint_val);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000278 if (ret) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200279 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
280 attr_name, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000281 return -EINVAL;
282 }
283
284 if (uint_val < min) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200285 batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
286 attr_name, uint_val, min);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000287 return -EINVAL;
288 }
289
290 if (uint_val > max) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200291 batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
292 attr_name, uint_val, max);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000293 return -EINVAL;
294 }
295
296 if (atomic_read(attr) == uint_val)
297 return count;
298
Sven Eckelmann3e348192012-05-16 20:23:22 +0200299 batadv_info(net_dev, "%s: Changing from: %i to: %lu\n",
300 attr_name, atomic_read(attr), uint_val);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000301
302 atomic_set(attr, uint_val);
303 return count;
304}
305
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200306static inline ssize_t
307__batadv_store_uint_attr(const char *buff, size_t count,
308 int min, int max,
309 void (*post_func)(struct net_device *),
310 const struct attribute *attr,
311 atomic_t *attr_store, struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000312{
313 int ret;
314
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200315 ret = batadv_store_uint_attr(buff, count, net_dev, attr->name, min, max,
316 attr_store);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000317 if (post_func && ret)
318 post_func(net_dev);
319
320 return ret;
321}
322
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200323static ssize_t batadv_show_bat_algo(struct kobject *kobj,
324 struct attribute *attr, char *buff)
Marek Lindnerea3d2fd2011-11-29 00:15:37 +0800325{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200326 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Marek Lindnerea3d2fd2011-11-29 00:15:37 +0800327 return sprintf(buff, "%s\n", bat_priv->bat_algo_ops->name);
328}
329
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100330static void batadv_post_gw_reselect(struct net_device *net_dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000331{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200332 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100333 batadv_gw_reselect(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000334}
335
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200336static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
337 char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000338{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200339 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000340 int bytes_written;
341
342 switch (atomic_read(&bat_priv->gw_mode)) {
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200343 case BATADV_GW_MODE_CLIENT:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200344 bytes_written = sprintf(buff, "%s\n",
345 BATADV_GW_MODE_CLIENT_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000346 break;
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200347 case BATADV_GW_MODE_SERVER:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200348 bytes_written = sprintf(buff, "%s\n",
349 BATADV_GW_MODE_SERVER_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000350 break;
351 default:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200352 bytes_written = sprintf(buff, "%s\n",
353 BATADV_GW_MODE_OFF_NAME);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000354 break;
355 }
356
357 return bytes_written;
358}
359
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200360static ssize_t batadv_store_gw_mode(struct kobject *kobj,
361 struct attribute *attr, char *buff,
362 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000363{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200364 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200365 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000366 char *curr_gw_mode_str;
367 int gw_mode_tmp = -1;
368
369 if (buff[count - 1] == '\n')
370 buff[count - 1] = '\0';
371
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200372 if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
373 strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200374 gw_mode_tmp = BATADV_GW_MODE_OFF;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000375
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200376 if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
377 strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200378 gw_mode_tmp = BATADV_GW_MODE_CLIENT;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000379
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200380 if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
381 strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200382 gw_mode_tmp = BATADV_GW_MODE_SERVER;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000383
384 if (gw_mode_tmp < 0) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200385 batadv_info(net_dev,
386 "Invalid parameter for 'gw mode' setting received: %s\n",
387 buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000388 return -EINVAL;
389 }
390
391 if (atomic_read(&bat_priv->gw_mode) == gw_mode_tmp)
392 return count;
393
394 switch (atomic_read(&bat_priv->gw_mode)) {
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200395 case BATADV_GW_MODE_CLIENT:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200396 curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000397 break;
Sven Eckelmanncd646ab2012-06-03 22:19:18 +0200398 case BATADV_GW_MODE_SERVER:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200399 curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000400 break;
401 default:
Sven Eckelmann97ea4ba2012-06-03 22:19:11 +0200402 curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000403 break;
404 }
405
Sven Eckelmann3e348192012-05-16 20:23:22 +0200406 batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
407 curr_gw_mode_str, buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000408
Antonio Quartullif3163182013-11-04 20:59:40 +0100409 /* Invoking batadv_gw_reselect() is not enough to really de-select the
410 * current GW. It will only instruct the gateway client code to perform
411 * a re-election the next time that this is needed.
412 *
413 * When gw client mode is being switched off the current GW must be
414 * de-selected explicitly otherwise no GW_ADD uevent is thrown on
415 * client mode re-activation. This is operation is performed in
416 * batadv_gw_check_client_stop().
417 */
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100418 batadv_gw_reselect(bat_priv);
Antonio Quartullic6eaa3f2013-07-13 00:06:00 +0200419 /* always call batadv_gw_check_client_stop() before changing the gateway
420 * state
421 */
422 batadv_gw_check_client_stop(bat_priv);
Eric Dumazet95c96172012-04-15 05:58:06 +0000423 atomic_set(&bat_priv->gw_mode, (unsigned int)gw_mode_tmp);
Marek Lindner414254e2013-04-23 21:39:58 +0800424 batadv_gw_tvlv_container_update(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000425 return count;
426}
427
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200428static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
429 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000430{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200431 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
Marek Lindner414254e2013-04-23 21:39:58 +0800432 uint32_t down, up;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000433
Marek Lindner414254e2013-04-23 21:39:58 +0800434 down = atomic_read(&bat_priv->gw.bandwidth_down);
435 up = atomic_read(&bat_priv->gw.bandwidth_up);
436
437 return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
438 down % 10, up / 10, up % 10);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000439}
440
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200441static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
442 struct attribute *attr, char *buff,
443 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000444{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200445 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000446
447 if (buff[count - 1] == '\n')
448 buff[count - 1] = '\0';
449
Sven Eckelmann84d5e5e2012-05-12 02:09:30 +0200450 return batadv_gw_bandwidth_set(net_dev, buff, count);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000451}
452
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100453/**
454 * batadv_show_isolation_mark - print the current isolation mark/mask
455 * @kobj: kobject representing the private mesh sysfs directory
456 * @attr: the batman-adv attribute the user is interacting with
457 * @buff: the buffer that will contain the data to send back to the user
458 *
459 * Returns the number of bytes written into 'buff' on success or a negative
460 * error code in case of failure
461 */
462static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
463 struct attribute *attr, char *buff)
464{
465 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
466
467 return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
468 bat_priv->isolation_mark_mask);
469}
470
471/**
472 * batadv_store_isolation_mark - parse and store the isolation mark/mask entered
473 * by the user
474 * @kobj: kobject representing the private mesh sysfs directory
475 * @attr: the batman-adv attribute the user is interacting with
476 * @buff: the buffer containing the user data
477 * @count: number of bytes in the buffer
478 *
479 * Returns 'count' on success or a negative error code in case of failure
480 */
481static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
482 struct attribute *attr, char *buff,
483 size_t count)
484{
485 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
486 struct batadv_priv *bat_priv = netdev_priv(net_dev);
487 uint32_t mark, mask;
488 char *mask_ptr;
489
490 /* parse the mask if it has been specified, otherwise assume the mask is
491 * the biggest possible
492 */
493 mask = 0xFFFFFFFF;
494 mask_ptr = strchr(buff, '/');
495 if (mask_ptr) {
496 *mask_ptr = '\0';
497 mask_ptr++;
498
499 /* the mask must be entered in hex base as it is going to be a
500 * bitmask and not a prefix length
501 */
502 if (kstrtou32(mask_ptr, 16, &mask) < 0)
503 return -EINVAL;
504 }
505
506 /* the mark can be entered in any base */
507 if (kstrtou32(buff, 0, &mark) < 0)
508 return -EINVAL;
509
510 bat_priv->isolation_mark_mask = mask;
511 /* erase bits not covered by the mask */
512 bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;
513
514 batadv_info(net_dev,
515 "New skb mark for extended isolation: %#.8x/%#.8x\n",
516 bat_priv->isolation_mark, bat_priv->isolation_mark_mask);
517
518 return count;
519}
520
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200521BATADV_ATTR_SIF_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL);
522BATADV_ATTR_SIF_BOOL(bonding, S_IRUGO | S_IWUSR, NULL);
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100523#ifdef CONFIG_BATMAN_ADV_BLA
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200524BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, S_IRUGO | S_IWUSR, NULL);
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100525#endif
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200526#ifdef CONFIG_BATMAN_ADV_DAT
Marek Lindner17cf0ea2013-04-23 21:39:59 +0800527BATADV_ATTR_SIF_BOOL(distributed_arp_table, S_IRUGO | S_IWUSR,
528 batadv_dat_status_update);
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200529#endif
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200530BATADV_ATTR_SIF_BOOL(fragmentation, S_IRUGO | S_IWUSR, batadv_update_min_mtu);
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200531static BATADV_ATTR(routing_algo, S_IRUGO, batadv_show_bat_algo, NULL);
532static BATADV_ATTR(gw_mode, S_IRUGO | S_IWUSR, batadv_show_gw_mode,
533 batadv_store_gw_mode);
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200534BATADV_ATTR_SIF_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * BATADV_JITTER,
535 INT_MAX, NULL);
536BATADV_ATTR_SIF_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, BATADV_TQ_MAX_VALUE,
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200537 NULL);
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200538BATADV_ATTR_SIF_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, BATADV_TQ_MAX_VALUE,
Antonio Quartulli4e820e72013-11-04 20:59:41 +0100539 batadv_post_gw_reselect);
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200540static BATADV_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, batadv_show_gw_bwidth,
541 batadv_store_gw_bwidth);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000542#ifdef CONFIG_BATMAN_ADV_DEBUG
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200543BATADV_ATTR_SIF_UINT(log_level, S_IRUGO | S_IWUSR, 0, BATADV_DBG_ALL, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000544#endif
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100545#ifdef CONFIG_BATMAN_ADV_NC
Marek Lindner3f4841f2013-04-23 21:40:00 +0800546BATADV_ATTR_SIF_BOOL(network_coding, S_IRUGO | S_IWUSR,
547 batadv_nc_status_update);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100548#endif
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100549static BATADV_ATTR(isolation_mark, S_IRUGO | S_IWUSR,
550 batadv_show_isolation_mark, batadv_store_isolation_mark);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000551
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200552static struct batadv_attribute *batadv_mesh_attrs[] = {
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200553 &batadv_attr_aggregated_ogms,
554 &batadv_attr_bonding,
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100555#ifdef CONFIG_BATMAN_ADV_BLA
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200556 &batadv_attr_bridge_loop_avoidance,
Simon Wunderlich7a5cc242012-01-22 20:00:27 +0100557#endif
Antonio Quartulli33af49a2012-08-08 18:50:57 +0200558#ifdef CONFIG_BATMAN_ADV_DAT
559 &batadv_attr_distributed_arp_table,
560#endif
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200561 &batadv_attr_fragmentation,
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200562 &batadv_attr_routing_algo,
563 &batadv_attr_gw_mode,
564 &batadv_attr_orig_interval,
565 &batadv_attr_hop_penalty,
566 &batadv_attr_gw_sel_class,
567 &batadv_attr_gw_bandwidth,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000568#ifdef CONFIG_BATMAN_ADV_DEBUG
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200569 &batadv_attr_log_level,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000570#endif
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100571#ifdef CONFIG_BATMAN_ADV_NC
572 &batadv_attr_network_coding,
573#endif
Antonio Quartullic42edfe2013-11-16 12:03:47 +0100574 &batadv_attr_isolation_mark,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000575 NULL,
576};
577
Antonio Quartullib8cbd812013-07-02 11:04:36 +0200578BATADV_ATTR_VLAN_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL);
579
Antonio Quartulli90f44352013-07-02 11:04:35 +0200580/**
581 * batadv_vlan_attrs - array of vlan specific sysfs attributes
582 */
583static struct batadv_attribute *batadv_vlan_attrs[] = {
Antonio Quartullib8cbd812013-07-02 11:04:36 +0200584 &batadv_attr_vlan_ap_isolation,
Antonio Quartulli90f44352013-07-02 11:04:35 +0200585 NULL,
586};
587
Sven Eckelmann5853e222012-05-12 02:09:24 +0200588int batadv_sysfs_add_meshif(struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000589{
590 struct kobject *batif_kobject = &dev->dev.kobj;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200591 struct batadv_priv *bat_priv = netdev_priv(dev);
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200592 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000593 int err;
594
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200595 bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000596 batif_kobject);
597 if (!bat_priv->mesh_obj) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200598 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200599 BATADV_SYSFS_IF_MESH_SUBDIR);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000600 goto out;
601 }
602
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200603 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000604 err = sysfs_create_file(bat_priv->mesh_obj,
605 &((*bat_attr)->attr));
606 if (err) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200607 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200608 dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
Sven Eckelmann3e348192012-05-16 20:23:22 +0200609 ((*bat_attr)->attr).name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000610 goto rem_attr;
611 }
612 }
613
614 return 0;
615
616rem_attr:
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200617 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000618 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
619
620 kobject_put(bat_priv->mesh_obj);
621 bat_priv->mesh_obj = NULL;
622out:
623 return -ENOMEM;
624}
625
Sven Eckelmann5853e222012-05-12 02:09:24 +0200626void batadv_sysfs_del_meshif(struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000627{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200628 struct batadv_priv *bat_priv = netdev_priv(dev);
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200629 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000630
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200631 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000632 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
633
634 kobject_put(bat_priv->mesh_obj);
635 bat_priv->mesh_obj = NULL;
636}
637
Antonio Quartulli90f44352013-07-02 11:04:35 +0200638/**
639 * batadv_sysfs_add_vlan - add all the needed sysfs objects for the new vlan
640 * @dev: netdev of the mesh interface
641 * @vlan: private data of the newly added VLAN interface
642 *
643 * Returns 0 on success and -ENOMEM if any of the structure allocations fails.
644 */
645int batadv_sysfs_add_vlan(struct net_device *dev,
646 struct batadv_softif_vlan *vlan)
647{
648 char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
649 struct batadv_priv *bat_priv = netdev_priv(dev);
650 struct batadv_attribute **bat_attr;
651 int err;
652
653 if (vlan->vid & BATADV_VLAN_HAS_TAG) {
654 sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
655 vlan->vid & VLAN_VID_MASK);
656
657 vlan->kobj = kobject_create_and_add(vlan_subdir,
658 bat_priv->mesh_obj);
659 if (!vlan->kobj) {
660 batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
661 dev->name, vlan_subdir);
662 goto out;
663 }
664 } else {
665 /* the untagged LAN uses the root folder to store its "VLAN
666 * specific attributes"
667 */
668 vlan->kobj = bat_priv->mesh_obj;
669 kobject_get(bat_priv->mesh_obj);
670 }
671
672 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
673 err = sysfs_create_file(vlan->kobj,
674 &((*bat_attr)->attr));
675 if (err) {
676 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
677 dev->name, vlan_subdir,
678 ((*bat_attr)->attr).name);
679 goto rem_attr;
680 }
681 }
682
683 return 0;
684
685rem_attr:
686 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
687 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
688
689 kobject_put(vlan->kobj);
690 vlan->kobj = NULL;
691out:
692 return -ENOMEM;
693}
694
695/**
696 * batadv_sysfs_del_vlan - remove all the sysfs objects for a given VLAN
697 * @bat_priv: the bat priv with all the soft interface information
698 * @vlan: the private data of the VLAN to destroy
699 */
700void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
701 struct batadv_softif_vlan *vlan)
702{
703 struct batadv_attribute **bat_attr;
704
705 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
706 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
707
708 kobject_put(vlan->kobj);
709 vlan->kobj = NULL;
710}
711
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200712static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
713 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000714{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200715 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200716 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000717 ssize_t length;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200718 const char *ifname;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000719
Sven Eckelmann56303d32012-06-05 22:31:31 +0200720 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000721 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000722 return 0;
723
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200724 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
725 ifname = "none";
726 else
727 ifname = hard_iface->soft_iface->name;
728
729 length = sprintf(buff, "%s\n", ifname);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000730
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200731 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000732
733 return length;
734}
735
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200736static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
737 struct attribute *attr, char *buff,
738 size_t count)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000739{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200740 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200741 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000742 int status_tmp = -1;
Marek Lindnered75ccb2011-02-10 14:33:51 +0000743 int ret = count;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000744
Sven Eckelmann56303d32012-06-05 22:31:31 +0200745 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000746 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000747 return count;
748
749 if (buff[count - 1] == '\n')
750 buff[count - 1] = '\0';
751
752 if (strlen(buff) >= IFNAMSIZ) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100753 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
754 buff);
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200755 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000756 return -EINVAL;
757 }
758
759 if (strncmp(buff, "none", 4) == 0)
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200760 status_tmp = BATADV_IF_NOT_IN_USE;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000761 else
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200762 status_tmp = BATADV_IF_I_WANT_YOU;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000763
Marek Lindnere6c10f42011-02-18 12:33:20 +0000764 if (hard_iface->if_status == status_tmp)
765 goto out;
766
767 if ((hard_iface->soft_iface) &&
768 (strncmp(hard_iface->soft_iface->name, buff, IFNAMSIZ) == 0))
Marek Lindnered75ccb2011-02-10 14:33:51 +0000769 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000770
Matthias Schifferac16d142013-05-28 17:32:32 +0200771 rtnl_lock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000772
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200773 if (status_tmp == BATADV_IF_NOT_IN_USE) {
Sven Eckelmanna15fd362013-02-11 17:10:24 +0800774 batadv_hardif_disable_interface(hard_iface,
775 BATADV_IF_CLEANUP_AUTO);
Sven Eckelmann3a4375a2011-05-03 13:10:06 +0200776 goto unlock;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000777 }
778
Sven Eckelmann3a4375a2011-05-03 13:10:06 +0200779 /* if the interface already is in use */
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200780 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
Sven Eckelmanna15fd362013-02-11 17:10:24 +0800781 batadv_hardif_disable_interface(hard_iface,
782 BATADV_IF_CLEANUP_AUTO);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000783
Sven Eckelmann95638772012-05-12 02:09:31 +0200784 ret = batadv_hardif_enable_interface(hard_iface, buff);
Sven Eckelmann3a4375a2011-05-03 13:10:06 +0200785
786unlock:
787 rtnl_unlock();
Marek Lindnered75ccb2011-02-10 14:33:51 +0000788out:
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200789 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000790 return ret;
791}
792
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200793static ssize_t batadv_show_iface_status(struct kobject *kobj,
794 struct attribute *attr, char *buff)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000795{
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200796 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
Sven Eckelmann56303d32012-06-05 22:31:31 +0200797 struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000798 ssize_t length;
799
Sven Eckelmann56303d32012-06-05 22:31:31 +0200800 hard_iface = batadv_hardif_get_by_netdev(net_dev);
Marek Lindnere6c10f42011-02-18 12:33:20 +0000801 if (!hard_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000802 return 0;
803
Marek Lindnere6c10f42011-02-18 12:33:20 +0000804 switch (hard_iface->if_status) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200805 case BATADV_IF_TO_BE_REMOVED:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000806 length = sprintf(buff, "disabling\n");
807 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200808 case BATADV_IF_INACTIVE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000809 length = sprintf(buff, "inactive\n");
810 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200811 case BATADV_IF_ACTIVE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000812 length = sprintf(buff, "active\n");
813 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200814 case BATADV_IF_TO_BE_ACTIVATED:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000815 length = sprintf(buff, "enabling\n");
816 break;
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200817 case BATADV_IF_NOT_IN_USE:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000818 default:
819 length = sprintf(buff, "not in use\n");
820 break;
821 }
822
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200823 batadv_hardif_free_ref(hard_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000824
825 return length;
826}
827
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200828static BATADV_ATTR(mesh_iface, S_IRUGO | S_IWUSR, batadv_show_mesh_iface,
829 batadv_store_mesh_iface);
830static BATADV_ATTR(iface_status, S_IRUGO, batadv_show_iface_status, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000831
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200832static struct batadv_attribute *batadv_batman_attrs[] = {
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200833 &batadv_attr_mesh_iface,
834 &batadv_attr_iface_status,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000835 NULL,
836};
837
Sven Eckelmann5853e222012-05-12 02:09:24 +0200838int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000839{
840 struct kobject *hardif_kobject = &dev->dev.kobj;
Sven Eckelmannb4d66b82012-06-05 22:31:29 +0200841 struct batadv_attribute **bat_attr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000842 int err;
843
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200844 *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
845 hardif_kobject);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000846
847 if (!*hardif_obj) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200848 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200849 BATADV_SYSFS_IF_BAT_SUBDIR);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000850 goto out;
851 }
852
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200853 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000854 err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
855 if (err) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200856 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
Sven Eckelmann036cbfe2012-06-03 22:19:09 +0200857 dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
Sven Eckelmann3e348192012-05-16 20:23:22 +0200858 ((*bat_attr)->attr).name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000859 goto rem_attr;
860 }
861 }
862
863 return 0;
864
865rem_attr:
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200866 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000867 sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
868out:
869 return -ENOMEM;
870}
871
Sven Eckelmann5853e222012-05-12 02:09:24 +0200872void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000873{
874 kobject_put(*hardif_obj);
875 *hardif_obj = NULL;
876}
Antonio Quartullic6bda682011-04-26 18:26:01 +0200877
Sven Eckelmann56303d32012-06-05 22:31:31 +0200878int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200879 enum batadv_uev_action action, const char *data)
Antonio Quartullic6bda682011-04-26 18:26:01 +0200880{
Sven Eckelmann5346c352012-05-05 13:27:28 +0200881 int ret = -ENOMEM;
Antonio Quartullic6bda682011-04-26 18:26:01 +0200882 struct kobject *bat_kobj;
883 char *uevent_env[4] = { NULL, NULL, NULL, NULL };
884
Marek Lindner736292c2013-01-12 19:19:06 +0800885 bat_kobj = &bat_priv->soft_iface->dev.kobj;
Antonio Quartullic6bda682011-04-26 18:26:01 +0200886
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200887 uevent_env[0] = kmalloc(strlen(BATADV_UEV_TYPE_VAR) +
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200888 strlen(batadv_uev_type_str[type]) + 1,
Antonio Quartullic6bda682011-04-26 18:26:01 +0200889 GFP_ATOMIC);
890 if (!uevent_env[0])
891 goto out;
892
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200893 sprintf(uevent_env[0], "%s%s", BATADV_UEV_TYPE_VAR,
894 batadv_uev_type_str[type]);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200895
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200896 uevent_env[1] = kmalloc(strlen(BATADV_UEV_ACTION_VAR) +
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200897 strlen(batadv_uev_action_str[action]) + 1,
Antonio Quartullic6bda682011-04-26 18:26:01 +0200898 GFP_ATOMIC);
899 if (!uevent_env[1])
900 goto out;
901
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200902 sprintf(uevent_env[1], "%s%s", BATADV_UEV_ACTION_VAR,
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200903 batadv_uev_action_str[action]);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200904
905 /* If the event is DEL, ignore the data field */
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200906 if (action != BATADV_UEV_DEL) {
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200907 uevent_env[2] = kmalloc(strlen(BATADV_UEV_DATA_VAR) +
Antonio Quartullic6bda682011-04-26 18:26:01 +0200908 strlen(data) + 1, GFP_ATOMIC);
909 if (!uevent_env[2])
910 goto out;
911
Sven Eckelmann347c80f2012-06-03 22:19:07 +0200912 sprintf(uevent_env[2], "%s%s", BATADV_UEV_DATA_VAR, data);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200913 }
914
915 ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
916out:
917 kfree(uevent_env[0]);
918 kfree(uevent_env[1]);
919 kfree(uevent_env[2]);
920
Antonio Quartullic6bda682011-04-26 18:26:01 +0200921 if (ret)
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200922 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200923 "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
Sven Eckelmann0ff9b862012-05-12 18:33:52 +0200924 batadv_uev_type_str[type],
925 batadv_uev_action_str[action],
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200926 (action == BATADV_UEV_DEL ? "NULL" : data), ret);
Antonio Quartullic6bda682011-04-26 18:26:01 +0200927 return ret;
928}