sysfs.c 30.4 KB
Newer Older
1
/* Copyright (C) 2010-2016  B.A.T.M.A.N. contributors:
2 3 4 5 6 7 8 9 10 11 12 13 14
 *
 * Marek Lindner
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
15
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 17
 */

18
#include "sysfs.h"
19 20 21 22 23 24 25 26 27 28
#include "main.h"

#include <linux/atomic.h>
#include <linux/compiler.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/if.h>
#include <linux/if_vlan.h>
#include <linux/kernel.h>
29
#include <linux/kref.h>
30 31 32 33 34 35 36 37 38 39 40
#include <linux/netdevice.h>
#include <linux/printk.h>
#include <linux/rculist.h>
#include <linux/rcupdate.h>
#include <linux/rtnetlink.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/stddef.h>
#include <linux/string.h>
#include <linux/stringify.h>

41
#include "bridge_loop_avoidance.h"
42
#include "distributed-arp-table.h"
43 44
#include "gateway_client.h"
#include "gateway_common.h"
45
#include "hard-interface.h"
46 47
#include "network-coding.h"
#include "packet.h"
48
#include "soft-interface.h"
49

50
static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
51 52
{
	struct device *dev = container_of(obj->parent, struct device, kobj);
53

54 55 56
	return to_net_dev(dev);
}

57
static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
58
{
59
	struct net_device *net_dev = batadv_kobj_to_netdev(obj);
60

61 62
	return netdev_priv(net_dev);
}
63

64 65 66 67
/**
 * batadv_vlan_kobj_to_batpriv - convert a vlan kobj in the associated batpriv
 * @obj: kobject to covert
 *
68
 * Return: the associated batadv_priv struct.
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
 */
static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
{
	/* VLAN specific attributes are located in the root sysfs folder if they
	 * refer to the untagged VLAN..
	 */
	if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
		return batadv_kobj_to_batpriv(obj);

	/* ..while the attributes for the tagged vlans are located in
	 * the in the corresponding "vlan%VID" subfolder
	 */
	return batadv_kobj_to_batpriv(obj->parent);
}

/**
 * batadv_kobj_to_vlan - convert a kobj in the associated softif_vlan struct
86
 * @bat_priv: the bat priv with all the soft interface information
87 88
 * @obj: kobject to covert
 *
89
 * Return: the associated softif_vlan struct if found, NULL otherwise.
90 91 92 93 94 95 96 97 98 99 100
 */
static struct batadv_softif_vlan *
batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
{
	struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;

	rcu_read_lock();
	hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
		if (vlan_tmp->kobj != obj)
			continue;

101
		if (!kref_get_unless_zero(&vlan_tmp->refcount))
102 103 104 105 106 107 108 109 110 111
			continue;

		vlan = vlan_tmp;
		break;
	}
	rcu_read_unlock();

	return vlan;
}

112 113 114
#define BATADV_UEV_TYPE_VAR	"BATTYPE="
#define BATADV_UEV_ACTION_VAR	"BATACTION="
#define BATADV_UEV_DATA_VAR	"BATDATA="
115

116
static char *batadv_uev_action_str[] = {
117 118
	"add",
	"del",
119 120
	"change",
	"loopdetect",
121 122
};

123
static char *batadv_uev_type_str[] = {
124 125
	"gw",
	"bla",
126 127
};

128 129 130 131 132 133 134
/* Use this, if you have customized show and store functions for vlan attrs */
#define BATADV_ATTR_VLAN(_name, _mode, _show, _store)	\
struct batadv_attribute batadv_attr_vlan_##_name = {	\
	.attr = {.name = __stringify(_name),		\
		 .mode = _mode },			\
	.show   = _show,				\
	.store  = _store,				\
135
}
136

137
/* Use this, if you have customized show and store functions */
138
#define BATADV_ATTR(_name, _mode, _show, _store)	\
139
struct batadv_attribute batadv_attr_##_name = {		\
140 141 142 143
	.attr = {.name = __stringify(_name),		\
		 .mode = _mode },			\
	.show   = _show,				\
	.store  = _store,				\
144
}
145

146
#define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func)			\
147 148 149
ssize_t batadv_store_##_name(struct kobject *kobj,			\
			     struct attribute *attr, char *buff,	\
			     size_t count)				\
150
{									\
151
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
152
	struct batadv_priv *bat_priv = netdev_priv(net_dev);		\
153
									\
154 155
	return __batadv_store_bool_attr(buff, count, _post_func, attr,	\
					&bat_priv->_name, net_dev);	\
156 157
}

158
#define BATADV_ATTR_SIF_SHOW_BOOL(_name)				\
159 160
ssize_t batadv_show_##_name(struct kobject *kobj,			\
			    struct attribute *attr, char *buff)		\
161
{									\
162
	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);	\
163
									\
164 165 166 167 168
	return sprintf(buff, "%s\n",					\
		       atomic_read(&bat_priv->_name) == 0 ?		\
		       "disabled" : "enabled");				\
}									\

169
/* Use this, if you are going to turn a [name] in the soft-interface
170 171
 * (bat_priv) on or off
 */
172 173 174 175 176
#define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func)			\
	static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func)		\
	static BATADV_ATTR_SIF_SHOW_BOOL(_name)				\
	static BATADV_ATTR(_name, _mode, batadv_show_##_name,		\
			   batadv_store_##_name)
177

178
#define BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func)	\
179 180 181
ssize_t batadv_store_##_name(struct kobject *kobj,			\
			     struct attribute *attr, char *buff,	\
			     size_t count)				\
182
{									\
183
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
184
	struct batadv_priv *bat_priv = netdev_priv(net_dev);		\
185
									\
186 187
	return __batadv_store_uint_attr(buff, count, _min, _max,	\
					_post_func, attr,		\
188
					&bat_priv->_var, net_dev);	\
189 190
}

191
#define BATADV_ATTR_SIF_SHOW_UINT(_name, _var)				\
192 193
ssize_t batadv_show_##_name(struct kobject *kobj,			\
			    struct attribute *attr, char *buff)		\
194
{									\
195
	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);	\
196
									\
197
	return sprintf(buff, "%i\n", atomic_read(&bat_priv->_var));	\
198 199
}									\

200
/* Use this, if you are going to set [name] in the soft-interface
201 202
 * (bat_priv) to an unsigned integer value
 */
203 204 205
#define BATADV_ATTR_SIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
	static BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func)\
	static BATADV_ATTR_SIF_SHOW_UINT(_name, _var)			\
206 207
	static BATADV_ATTR(_name, _mode, batadv_show_##_name,		\
			   batadv_store_##_name)
208

209 210 211 212 213 214 215 216 217 218 219
#define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func)			\
ssize_t batadv_store_vlan_##_name(struct kobject *kobj,			\
				  struct attribute *attr, char *buff,	\
				  size_t count)				\
{									\
	struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
	struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv,	\
							      kobj);	\
	size_t res = __batadv_store_bool_attr(buff, count, _post_func,	\
					      attr, &vlan->_name,	\
					      bat_priv->soft_iface);	\
220
									\
221
	batadv_softif_vlan_put(vlan);					\
222 223 224 225 226 227 228 229 230 231 232 233 234
	return res;							\
}

#define BATADV_ATTR_VLAN_SHOW_BOOL(_name)				\
ssize_t batadv_show_vlan_##_name(struct kobject *kobj,			\
				 struct attribute *attr, char *buff)	\
{									\
	struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
	struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv,	\
							      kobj);	\
	size_t res = sprintf(buff, "%s\n",				\
			     atomic_read(&vlan->_name) == 0 ?		\
			     "disabled" : "enabled");			\
235
									\
236
	batadv_softif_vlan_put(vlan);					\
237 238 239 240 241 242 243 244 245
	return res;							\
}

/* Use this, if you are going to turn a [name] in the vlan struct on or off */
#define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func)			\
	static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func)		\
	static BATADV_ATTR_VLAN_SHOW_BOOL(_name)			\
	static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name,	\
				batadv_store_vlan_##_name)
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294

#define BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min, _max, _post_func)	\
ssize_t batadv_store_##_name(struct kobject *kobj,			\
			     struct attribute *attr, char *buff,	\
			     size_t count)				\
{									\
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
	struct batadv_hard_iface *hard_iface;				\
	ssize_t length;							\
									\
	hard_iface = batadv_hardif_get_by_netdev(net_dev);		\
	if (!hard_iface)						\
		return 0;						\
									\
	length = __batadv_store_uint_attr(buff, count, _min, _max,	\
					  _post_func, attr,		\
					  &hard_iface->_var, net_dev);	\
									\
	batadv_hardif_put(hard_iface);				\
	return length;							\
}

#define BATADV_ATTR_HIF_SHOW_UINT(_name, _var)				\
ssize_t batadv_show_##_name(struct kobject *kobj,			\
			    struct attribute *attr, char *buff)		\
{									\
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
	struct batadv_hard_iface *hard_iface;				\
	ssize_t length;							\
									\
	hard_iface = batadv_hardif_get_by_netdev(net_dev);		\
	if (!hard_iface)						\
		return 0;						\
									\
	length = sprintf(buff, "%i\n", atomic_read(&hard_iface->_var));	\
									\
	batadv_hardif_put(hard_iface);				\
	return length;							\
}

/* Use this, if you are going to set [name] in hard_iface to an
 * unsigned integer value
 */
#define BATADV_ATTR_HIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
	static BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min,		\
					  _max, _post_func)		\
	static BATADV_ATTR_HIF_SHOW_UINT(_name, _var)			\
	static BATADV_ATTR(_name, _mode, batadv_show_##_name,		\
			   batadv_store_##_name)
295

296 297
static int batadv_store_bool_attr(char *buff, size_t count,
				  struct net_device *net_dev,
298 299
				  const char *attr_name, atomic_t *attr,
				  bool *changed)
300 301 302
{
	int enabled = -1;

303 304
	*changed = false;

305 306 307 308 309 310 311 312 313 314 315 316 317 318
	if (buff[count - 1] == '\n')
		buff[count - 1] = '\0';

	if ((strncmp(buff, "1", 2) == 0) ||
	    (strncmp(buff, "enable", 7) == 0) ||
	    (strncmp(buff, "enabled", 8) == 0))
		enabled = 1;

	if ((strncmp(buff, "0", 2) == 0) ||
	    (strncmp(buff, "disable", 8) == 0) ||
	    (strncmp(buff, "disabled", 9) == 0))
		enabled = 0;

	if (enabled < 0) {
319 320
		batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
			    attr_name, buff);
321 322 323 324 325 326
		return -EINVAL;
	}

	if (atomic_read(attr) == enabled)
		return count;

327 328 329
	batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
		    atomic_read(attr) == 1 ? "enabled" : "disabled",
		    enabled == 1 ? "enabled" : "disabled");
330

331 332
	*changed = true;

333
	atomic_set(attr, (unsigned int)enabled);
334 335 336
	return count;
}

337 338 339 340 341
static inline ssize_t
__batadv_store_bool_attr(char *buff, size_t count,
			 void (*post_func)(struct net_device *),
			 struct attribute *attr,
			 atomic_t *attr_store, struct net_device *net_dev)
342
{
343
	bool changed;
344 345
	int ret;

346
	ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
347 348
				     attr_store, &changed);
	if (post_func && changed)
349 350 351 352 353
		post_func(net_dev);

	return ret;
}

354 355 356 357 358
static int batadv_store_uint_attr(const char *buff, size_t count,
				  struct net_device *net_dev,
				  const char *attr_name,
				  unsigned int min, unsigned int max,
				  atomic_t *attr)
359 360 361 362
{
	unsigned long uint_val;
	int ret;

363
	ret = kstrtoul(buff, 10, &uint_val);
364
	if (ret) {
365 366
		batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
			    attr_name, buff);
367 368 369 370
		return -EINVAL;
	}

	if (uint_val < min) {
371 372
		batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
			    attr_name, uint_val, min);
373 374 375 376
		return -EINVAL;
	}

	if (uint_val > max) {
377 378
		batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
			    attr_name, uint_val, max);
379 380 381 382 383 384
		return -EINVAL;
	}

	if (atomic_read(attr) == uint_val)
		return count;

385 386
	batadv_info(net_dev, "%s: Changing from: %i to: %lu\n",
		    attr_name, atomic_read(attr), uint_val);
387 388 389 390 391

	atomic_set(attr, uint_val);
	return count;
}

392 393 394 395 396 397
static ssize_t __batadv_store_uint_attr(const char *buff, size_t count,
					int min, int max,
					void (*post_func)(struct net_device *),
					const struct attribute *attr,
					atomic_t *attr_store,
					struct net_device *net_dev)
398 399 400
{
	int ret;

401 402
	ret = batadv_store_uint_attr(buff, count, net_dev, attr->name, min, max,
				     attr_store);
403 404 405 406 407 408
	if (post_func && ret)
		post_func(net_dev);

	return ret;
}

409 410
static ssize_t batadv_show_bat_algo(struct kobject *kobj,
				    struct attribute *attr, char *buff)
411
{
412
	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
413

414 415 416
	return sprintf(buff, "%s\n", bat_priv->bat_algo_ops->name);
}

417
static void batadv_post_gw_reselect(struct net_device *net_dev)
418
{
419
	struct batadv_priv *bat_priv = netdev_priv(net_dev);
420

421
	batadv_gw_reselect(bat_priv);
422 423
}

424 425
static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
				   char *buff)
426
{
427
	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
428 429
	int bytes_written;

430
	switch (atomic_read(&bat_priv->gw.mode)) {
431
	case BATADV_GW_MODE_CLIENT:
432 433
		bytes_written = sprintf(buff, "%s\n",
					BATADV_GW_MODE_CLIENT_NAME);
434
		break;
435
	case BATADV_GW_MODE_SERVER:
436 437
		bytes_written = sprintf(buff, "%s\n",
					BATADV_GW_MODE_SERVER_NAME);
438 439
		break;
	default:
440 441
		bytes_written = sprintf(buff, "%s\n",
					BATADV_GW_MODE_OFF_NAME);
442 443 444 445 446 447
		break;
	}

	return bytes_written;
}

448 449 450
static ssize_t batadv_store_gw_mode(struct kobject *kobj,
				    struct attribute *attr, char *buff,
				    size_t count)
451
{
452
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
453
	struct batadv_priv *bat_priv = netdev_priv(net_dev);
454 455 456 457 458 459
	char *curr_gw_mode_str;
	int gw_mode_tmp = -1;

	if (buff[count - 1] == '\n')
		buff[count - 1] = '\0';

460 461
	if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
		    strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
462
		gw_mode_tmp = BATADV_GW_MODE_OFF;
463

464 465
	if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
		    strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
466
		gw_mode_tmp = BATADV_GW_MODE_CLIENT;
467

468 469
	if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
		    strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
470
		gw_mode_tmp = BATADV_GW_MODE_SERVER;
471 472

	if (gw_mode_tmp < 0) {
473 474 475
		batadv_info(net_dev,
			    "Invalid parameter for 'gw mode' setting received: %s\n",
			    buff);
476 477 478
		return -EINVAL;
	}

479
	if (atomic_read(&bat_priv->gw.mode) == gw_mode_tmp)
480 481
		return count;

482
	switch (atomic_read(&bat_priv->gw.mode)) {
483
	case BATADV_GW_MODE_CLIENT:
484
		curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
485
		break;
486
	case BATADV_GW_MODE_SERVER:
487
		curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
488 489
		break;
	default:
490
		curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
491 492 493
		break;
	}

494 495
	batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
		    curr_gw_mode_str, buff);
496

497 498 499 500 501 502 503 504 505
	/* Invoking batadv_gw_reselect() is not enough to really de-select the
	 * current GW. It will only instruct the gateway client code to perform
	 * a re-election the next time that this is needed.
	 *
	 * When gw client mode is being switched off the current GW must be
	 * de-selected explicitly otherwise no GW_ADD uevent is thrown on
	 * client mode re-activation. This is operation is performed in
	 * batadv_gw_check_client_stop().
	 */
506
	batadv_gw_reselect(bat_priv);
507 508 509 510
	/* always call batadv_gw_check_client_stop() before changing the gateway
	 * state
	 */
	batadv_gw_check_client_stop(bat_priv);
511
	atomic_set(&bat_priv->gw.mode, (unsigned int)gw_mode_tmp);
512
	batadv_gw_tvlv_container_update(bat_priv);
513 514 515
	return count;
}

516 517
static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
				     struct attribute *attr, char *buff)
518
{
519
	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
520
	u32 down, up;
521 522 523 524 525 526

	down = atomic_read(&bat_priv->gw.bandwidth_down);
	up = atomic_read(&bat_priv->gw.bandwidth_up);

	return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
		       down % 10, up / 10, up % 10);
527 528
}

529 530 531
static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
				      struct attribute *attr, char *buff,
				      size_t count)
532
{
533
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
534 535 536 537

	if (buff[count - 1] == '\n')
		buff[count - 1] = '\0';

538
	return batadv_gw_bandwidth_set(net_dev, buff, count);
539 540
}

541 542 543 544 545 546
/**
 * batadv_show_isolation_mark - print the current isolation mark/mask
 * @kobj: kobject representing the private mesh sysfs directory
 * @attr: the batman-adv attribute the user is interacting with
 * @buff: the buffer that will contain the data to send back to the user
 *
547
 * Return: the number of bytes written into 'buff' on success or a negative
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
 * error code in case of failure
 */
static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
					  struct attribute *attr, char *buff)
{
	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);

	return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
		       bat_priv->isolation_mark_mask);
}

/**
 * batadv_store_isolation_mark - parse and store the isolation mark/mask entered
 *  by the user
 * @kobj: kobject representing the private mesh sysfs directory
 * @attr: the batman-adv attribute the user is interacting with
 * @buff: the buffer containing the user data
 * @count: number of bytes in the buffer
 *
567
 * Return: 'count' on success or a negative error code in case of failure
568 569 570 571 572 573 574
 */
static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
					   struct attribute *attr, char *buff,
					   size_t count)
{
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
	struct batadv_priv *bat_priv = netdev_priv(net_dev);
575
	u32 mark, mask;
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
	char *mask_ptr;

	/* parse the mask if it has been specified, otherwise assume the mask is
	 * the biggest possible
	 */
	mask = 0xFFFFFFFF;
	mask_ptr = strchr(buff, '/');
	if (mask_ptr) {
		*mask_ptr = '\0';
		mask_ptr++;

		/* the mask must be entered in hex base as it is going to be a
		 * bitmask and not a prefix length
		 */
		if (kstrtou32(mask_ptr, 16, &mask) < 0)
			return -EINVAL;
	}

	/* the mark can be entered in any base */
	if (kstrtou32(buff, 0, &mark) < 0)
		return -EINVAL;

	bat_priv->isolation_mark_mask = mask;
	/* erase bits not covered by the mask */
	bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;

	batadv_info(net_dev,
		    "New skb mark for extended isolation: %#.8x/%#.8x\n",
		    bat_priv->isolation_mark, bat_priv->isolation_mark_mask);

	return count;
}

609 610
BATADV_ATTR_SIF_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL);
BATADV_ATTR_SIF_BOOL(bonding, S_IRUGO | S_IWUSR, NULL);
611
#ifdef CONFIG_BATMAN_ADV_BLA
612 613
BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, S_IRUGO | S_IWUSR,
		     batadv_bla_status_update);
614
#endif
615
#ifdef CONFIG_BATMAN_ADV_DAT
616 617
BATADV_ATTR_SIF_BOOL(distributed_arp_table, S_IRUGO | S_IWUSR,
		     batadv_dat_status_update);
618
#endif
619 620 621 622
BATADV_ATTR_SIF_BOOL(fragmentation, S_IRUGO | S_IWUSR, batadv_update_min_mtu);
static BATADV_ATTR(routing_algo, S_IRUGO, batadv_show_bat_algo, NULL);
static BATADV_ATTR(gw_mode, S_IRUGO | S_IWUSR, batadv_show_gw_mode,
		   batadv_store_gw_mode);
623 624 625 626
BATADV_ATTR_SIF_UINT(orig_interval, orig_interval, S_IRUGO | S_IWUSR,
		     2 * BATADV_JITTER, INT_MAX, NULL);
BATADV_ATTR_SIF_UINT(hop_penalty, hop_penalty, S_IRUGO | S_IWUSR, 0,
		     BATADV_TQ_MAX_VALUE, NULL);
627
BATADV_ATTR_SIF_UINT(gw_sel_class, gw.sel_class, S_IRUGO | S_IWUSR, 1,
628
		     BATADV_TQ_MAX_VALUE, batadv_post_gw_reselect);
629 630
static BATADV_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, batadv_show_gw_bwidth,
		   batadv_store_gw_bwidth);
631 632 633
#ifdef CONFIG_BATMAN_ADV_MCAST
BATADV_ATTR_SIF_BOOL(multicast_mode, S_IRUGO | S_IWUSR, NULL);
#endif
634
#ifdef CONFIG_BATMAN_ADV_DEBUG
635 636
BATADV_ATTR_SIF_UINT(log_level, log_level, S_IRUGO | S_IWUSR, 0,
		     BATADV_DBG_ALL, NULL);
637
#endif
638
#ifdef CONFIG_BATMAN_ADV_NC
639 640
BATADV_ATTR_SIF_BOOL(network_coding, S_IRUGO | S_IWUSR,
		     batadv_nc_status_update);
641
#endif
642 643
static BATADV_ATTR(isolation_mark, S_IRUGO | S_IWUSR,
		   batadv_show_isolation_mark, batadv_store_isolation_mark);
644

645
static struct batadv_attribute *batadv_mesh_attrs[] = {
646 647
	&batadv_attr_aggregated_ogms,
	&batadv_attr_bonding,
648
#ifdef CONFIG_BATMAN_ADV_BLA
649
	&batadv_attr_bridge_loop_avoidance,
650 651 652
#endif
#ifdef CONFIG_BATMAN_ADV_DAT
	&batadv_attr_distributed_arp_table,
653 654 655
#endif
#ifdef CONFIG_BATMAN_ADV_MCAST
	&batadv_attr_multicast_mode,
656
#endif
657 658 659 660 661 662 663
	&batadv_attr_fragmentation,
	&batadv_attr_routing_algo,
	&batadv_attr_gw_mode,
	&batadv_attr_orig_interval,
	&batadv_attr_hop_penalty,
	&batadv_attr_gw_sel_class,
	&batadv_attr_gw_bandwidth,
664
#ifdef CONFIG_BATMAN_ADV_DEBUG
665
	&batadv_attr_log_level,
666 667 668
#endif
#ifdef CONFIG_BATMAN_ADV_NC
	&batadv_attr_network_coding,
669
#endif
670
	&batadv_attr_isolation_mark,
671 672 673
	NULL,
};

674 675
BATADV_ATTR_VLAN_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL);

676
/* array of vlan specific sysfs attributes */
677
static struct batadv_attribute *batadv_vlan_attrs[] = {
678
	&batadv_attr_vlan_ap_isolation,
679 680 681
	NULL,
};

682
int batadv_sysfs_add_meshif(struct net_device *dev)
683 684
{
	struct kobject *batif_kobject = &dev->dev.kobj;
685
	struct batadv_priv *bat_priv = netdev_priv(dev);
686
	struct batadv_attribute **bat_attr;
687 688
	int err;

689
	bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
690 691
						    batif_kobject);
	if (!bat_priv->mesh_obj) {
692
		batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
693
			   BATADV_SYSFS_IF_MESH_SUBDIR);
694 695 696
		goto out;
	}

697
	for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
698 699 700
		err = sysfs_create_file(bat_priv->mesh_obj,
					&((*bat_attr)->attr));
		if (err) {
701
			batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
702
				   dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
703
				   ((*bat_attr)->attr).name);
704 705 706 707 708 709 710
			goto rem_attr;
		}
	}

	return 0;

rem_attr:
711
	for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
712 713 714 715 716 717 718 719
		sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));

	kobject_put(bat_priv->mesh_obj);
	bat_priv->mesh_obj = NULL;
out:
	return -ENOMEM;
}

720
void batadv_sysfs_del_meshif(struct net_device *dev)
721
{
722
	struct batadv_priv *bat_priv = netdev_priv(dev);
723
	struct batadv_attribute **bat_attr;
724

725
	for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
726 727 728 729 730 731
		sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));

	kobject_put(bat_priv->mesh_obj);
	bat_priv->mesh_obj = NULL;
}

732 733 734 735 736
/**
 * batadv_sysfs_add_vlan - add all the needed sysfs objects for the new vlan
 * @dev: netdev of the mesh interface
 * @vlan: private data of the newly added VLAN interface
 *
737
 * Return: 0 on success and -ENOMEM if any of the structure allocations fails.
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
 */
int batadv_sysfs_add_vlan(struct net_device *dev,
			  struct batadv_softif_vlan *vlan)
{
	char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
	struct batadv_priv *bat_priv = netdev_priv(dev);
	struct batadv_attribute **bat_attr;
	int err;

	if (vlan->vid & BATADV_VLAN_HAS_TAG) {
		sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
			vlan->vid & VLAN_VID_MASK);

		vlan->kobj = kobject_create_and_add(vlan_subdir,
						    bat_priv->mesh_obj);
		if (!vlan->kobj) {
			batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
				   dev->name, vlan_subdir);
			goto out;
		}
	} else {
		/* the untagged LAN uses the root folder to store its "VLAN
		 * specific attributes"
		 */
		vlan->kobj = bat_priv->mesh_obj;
		kobject_get(bat_priv->mesh_obj);
	}

	for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
		err = sysfs_create_file(vlan->kobj,
					&((*bat_attr)->attr));
		if (err) {
			batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
				   dev->name, vlan_subdir,
				   ((*bat_attr)->attr).name);
			goto rem_attr;
		}
	}

	return 0;

rem_attr:
	for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
		sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));

	kobject_put(vlan->kobj);
	vlan->kobj = NULL;
out:
	return -ENOMEM;
}

/**
 * batadv_sysfs_del_vlan - remove all the sysfs objects for a given VLAN
 * @bat_priv: the bat priv with all the soft interface information
 * @vlan: the private data of the VLAN to destroy
 */
void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
			   struct batadv_softif_vlan *vlan)
{
	struct batadv_attribute **bat_attr;

	for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
		sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));

	kobject_put(vlan->kobj);
	vlan->kobj = NULL;
}

806 807
static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
				      struct attribute *attr, char *buff)
808
{
809
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
810
	struct batadv_hard_iface *hard_iface;
811
	ssize_t length;
812
	const char *ifname;
813

814
	hard_iface = batadv_hardif_get_by_netdev(net_dev);
815
	if (!hard_iface)
816 817
		return 0;

818 819 820 821 822 823
	if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
		ifname =  "none";
	else
		ifname = hard_iface->soft_iface->name;

	length = sprintf(buff, "%s\n", ifname);
824

825
	batadv_hardif_put(hard_iface);
826 827 828 829

	return length;
}

830 831 832
static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
				       struct attribute *attr, char *buff,
				       size_t count)
833
{
834
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
835
	struct net *net = dev_net(net_dev);
836
	struct batadv_hard_iface *hard_iface;
837
	int status_tmp = -1;
838
	int ret = count;
839

840
	hard_iface = batadv_hardif_get_by_netdev(net_dev);
841
	if (!hard_iface)
842 843 844 845 846 847
		return count;

	if (buff[count - 1] == '\n')
		buff[count - 1] = '\0';

	if (strlen(buff) >= IFNAMSIZ) {
848 849
		pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
		       buff);
850
		batadv_hardif_put(hard_iface);
851 852 853 854
		return -EINVAL;
	}

	if (strncmp(buff, "none", 4) == 0)
855
		status_tmp = BATADV_IF_NOT_IN_USE;
856
	else
857
		status_tmp = BATADV_IF_I_WANT_YOU;
858

859 860 861 862 863
	if (hard_iface->if_status == status_tmp)
		goto out;

	if ((hard_iface->soft_iface) &&
	    (strncmp(hard_iface->soft_iface->name, buff, IFNAMSIZ) == 0))
864
		goto out;
865

866
	rtnl_lock();
867

868
	if (status_tmp == BATADV_IF_NOT_IN_USE) {
869 870
		batadv_hardif_disable_interface(hard_iface,
						BATADV_IF_CLEANUP_AUTO);
871
		goto unlock;
872 873 874
	}

	/* if the interface already is in use */
875
	if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
876 877
		batadv_hardif_disable_interface(hard_iface,
						BATADV_IF_CLEANUP_AUTO);
878

879
	ret = batadv_hardif_enable_interface(hard_iface, net, buff);
880

881 882
unlock:
	rtnl_unlock();
883
out:
884
	batadv_hardif_put(hard_iface);
885 886 887
	return ret;
}

888 889
static ssize_t batadv_show_iface_status(struct kobject *kobj,
					struct attribute *attr, char *buff)
890
{
891
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
892
	struct batadv_hard_iface *hard_iface;
893 894
	ssize_t length;

895
	hard_iface = batadv_hardif_get_by_netdev(net_dev);
896
	if (!hard_iface)
897 898
		return 0;

899
	switch (hard_iface->if_status) {
900
	case BATADV_IF_TO_BE_REMOVED:
901 902
		length = sprintf(buff, "disabling\n");
		break;
903
	case BATADV_IF_INACTIVE:
904 905
		length = sprintf(buff, "inactive\n");
		break;
906
	case BATADV_IF_ACTIVE:
907 908
		length = sprintf(buff, "active\n");
		break;
909
	case BATADV_IF_TO_BE_ACTIVATED:
910 911
		length = sprintf(buff, "enabling\n");
		break;
912
	case BATADV_IF_NOT_IN_USE:
913 914 915 916 917
	default:
		length = sprintf(buff, "not in use\n");
		break;
	}

918
	batadv_hardif_put(hard_iface);
919 920 921 922

	return length;
}

923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
#ifdef CONFIG_BATMAN_ADV_BATMAN_V

/**
 * batadv_store_throughput_override - parse and store throughput override
 *  entered by the user
 * @kobj: kobject representing the private mesh sysfs directory
 * @attr: the batman-adv attribute the user is interacting with
 * @buff: the buffer containing the user data
 * @count: number of bytes in the buffer
 *
 * Return: 'count' on success or a negative error code in case of failure
 */
static ssize_t batadv_store_throughput_override(struct kobject *kobj,
						struct attribute *attr,
						char *buff, size_t count)
{
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
	struct batadv_hard_iface *hard_iface;
	u32 tp_override;
	u32 old_tp_override;
	bool ret;

	hard_iface = batadv_hardif_get_by_netdev(net_dev);
	if (!hard_iface)
		return -EINVAL;

	if (buff[count - 1] == '\n')
		buff[count - 1] = '\0';

	ret = batadv_parse_throughput(net_dev, buff, "throughput_override",
				      &tp_override);
	if (!ret)
		return count;

	old_tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
	if (old_tp_override == tp_override)
		goto out;

	batadv_info(net_dev, "%s: Changing from: %u.%u MBit to: %u.%u MBit\n",
		    "throughput_override",
		    old_tp_override / 10, old_tp_override % 10,
		    tp_override / 10, tp_override % 10);

	atomic_set(&hard_iface->bat_v.throughput_override, tp_override);

out:
	batadv_hardif_put(hard_iface);
	return count;
}

static ssize_t batadv_show_throughput_override(struct kobject *kobj,
					       struct attribute *attr,
					       char *buff)
{
	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
	struct batadv_hard_iface *hard_iface;
	u32 tp_override;

	hard_iface = batadv_hardif_get_by_netdev(net_dev);
	if (!hard_iface)
		return -EINVAL;

	tp_override = atomic_read(&hard_iface->bat_v.throughput_override);

	return sprintf(buff, "%u.%u MBit\n", tp_override / 10,
		       tp_override % 10);
}

#endif

993 994 995
static BATADV_ATTR(mesh_iface, S_IRUGO | S_IWUSR, batadv_show_mesh_iface,
		   batadv_store_mesh_iface);
static BATADV_ATTR(iface_status, S_IRUGO, batadv_show_iface_status, NULL);
996 997 998
#ifdef CONFIG_BATMAN_ADV_BATMAN_V
BATADV_ATTR_HIF_UINT(elp_interval, bat_v.elp_interval, S_IRUGO | S_IWUSR,
		     2 * BATADV_JITTER, INT_MAX, NULL);
999 1000 1001
static BATADV_ATTR(throughput_override, S_IRUGO | S_IWUSR,
		   batadv_show_throughput_override,
		   batadv_store_throughput_override);
1002
#endif
1003

1004
static struct batadv_attribute *batadv_batman_attrs[] = {
1005 1006
	&batadv_attr_mesh_iface,
	&batadv_attr_iface_status,
1007 1008
#ifdef CONFIG_BATMAN_ADV_BATMAN_V
	&batadv_attr_elp_interval,
1009
	&batadv_attr_throughput_override,
1010
#endif
1011 1012 1013
	NULL,
};

1014
int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
1015 1016
{
	struct kobject *hardif_kobject = &dev->dev.kobj;
1017
	struct batadv_attribute **bat_attr;
1018 1019
	int err;

1020 1021
	*hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
					     hardif_kobject);
1022 1023

	if (!*hardif_obj) {
1024
		batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
1025
			   BATADV_SYSFS_IF_BAT_SUBDIR);
1026 1027 1028
		goto out;
	}

1029
	for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
1030 1031
		err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
		if (err) {
1032
			batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
1033
				   dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
1034
				   ((*bat_attr)->attr).name);
1035 1036 1037 1038 1039 1040 1041
			goto rem_attr;
		}
	}

	return 0;

rem_attr:
1042
	for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
1043 1044 1045 1046 1047
		sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
out:
	return -ENOMEM;
}

1048
void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
1049 1050 1051 1052
{
	kobject_put(*hardif_obj);
	*hardif_obj = NULL;
}
1053

1054
int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
1055
			enum batadv_uev_action action, const char *data)
1056
{
1057
	int ret = -ENOMEM;
1058 1059 1060
	struct kobject *bat_kobj;
	char *uevent_env[4] = { NULL, NULL, NULL, NULL };

1061
	bat_kobj = &bat_priv->soft_iface->dev.kobj;
1062

H
Himangi Saraogi 已提交
1063 1064 1065
	uevent_env[0] = kasprintf(GFP_ATOMIC,
				  "%s%s", BATADV_UEV_TYPE_VAR,
				  batadv_uev_type_str[type]);
1066 1067 1068
	if (!uevent_env[0])
		goto out;

H
Himangi Saraogi 已提交
1069 1070 1071
	uevent_env[1] = kasprintf(GFP_ATOMIC,
				  "%s%s", BATADV_UEV_ACTION_VAR,
				  batadv_uev_action_str[action]);
1072 1073 1074 1075
	if (!uevent_env[1])
		goto out;

	/* If the event is DEL, ignore the data field */
1076
	if (action != BATADV_UEV_DEL) {
H
Himangi Saraogi 已提交
1077 1078
		uevent_env[2] = kasprintf(GFP_ATOMIC,
					  "%s%s", BATADV_UEV_DATA_VAR, data);
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
		if (!uevent_env[2])
			goto out;
	}

	ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
out:
	kfree(uevent_env[0]);
	kfree(uevent_env[1]);
	kfree(uevent_env[2]);

	if (ret)
1090
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1091
			   "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
1092 1093
			   batadv_uev_type_str[type],
			   batadv_uev_action_str[action],
1094
			   (action == BATADV_UEV_DEL ? "NULL" : data), ret);
1095 1096
	return ret;
}