1 /* Copyright (C) 2010-2013 B.A.T.M.A.N. contributors:
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 #include "translation-table.h"
21 #include "distributed-arp-table.h"
22 #include "network-coding.h"
23 #include "originator.h"
24 #include "hard-interface.h"
25 #include "soft-interface.h"
26 #include "gateway_common.h"
27 #include "gateway_client.h"
29 static struct net_device
*batadv_kobj_to_netdev(struct kobject
*obj
)
31 struct device
*dev
= container_of(obj
->parent
, struct device
, kobj
);
32 return to_net_dev(dev
);
35 static struct batadv_priv
*batadv_kobj_to_batpriv(struct kobject
*obj
)
37 struct net_device
*net_dev
= batadv_kobj_to_netdev(obj
);
38 return netdev_priv(net_dev
);
42 * batadv_vlan_kobj_to_batpriv - convert a vlan kobj in the associated batpriv
43 * @obj: kobject to covert
45 * Returns the associated batadv_priv struct.
47 static struct batadv_priv
*batadv_vlan_kobj_to_batpriv(struct kobject
*obj
)
49 /* VLAN specific attributes are located in the root sysfs folder if they
50 * refer to the untagged VLAN..
52 if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR
, obj
->name
))
53 return batadv_kobj_to_batpriv(obj
);
55 /* ..while the attributes for the tagged vlans are located in
56 * the in the corresponding "vlan%VID" subfolder
58 return batadv_kobj_to_batpriv(obj
->parent
);
62 * batadv_kobj_to_vlan - convert a kobj in the associated softif_vlan struct
63 * @obj: kobject to covert
65 * Returns the associated softif_vlan struct if found, NULL otherwise.
67 static struct batadv_softif_vlan
*
68 batadv_kobj_to_vlan(struct batadv_priv
*bat_priv
, struct kobject
*obj
)
70 struct batadv_softif_vlan
*vlan_tmp
, *vlan
= NULL
;
73 hlist_for_each_entry_rcu(vlan_tmp
, &bat_priv
->softif_vlan_list
, list
) {
74 if (vlan_tmp
->kobj
!= obj
)
77 if (!atomic_inc_not_zero(&vlan_tmp
->refcount
))
88 #define BATADV_UEV_TYPE_VAR "BATTYPE="
89 #define BATADV_UEV_ACTION_VAR "BATACTION="
90 #define BATADV_UEV_DATA_VAR "BATDATA="
92 static char *batadv_uev_action_str
[] = {
98 static char *batadv_uev_type_str
[] = {
102 /* Use this, if you have customized show and store functions for vlan attrs */
103 #define BATADV_ATTR_VLAN(_name, _mode, _show, _store) \
104 struct batadv_attribute batadv_attr_vlan_##_name = { \
105 .attr = {.name = __stringify(_name), \
111 /* Use this, if you have customized show and store functions */
112 #define BATADV_ATTR(_name, _mode, _show, _store) \
113 struct batadv_attribute batadv_attr_##_name = { \
114 .attr = {.name = __stringify(_name), \
120 #define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
121 ssize_t batadv_store_##_name(struct kobject *kobj, \
122 struct attribute *attr, char *buff, \
125 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
126 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
127 return __batadv_store_bool_attr(buff, count, _post_func, attr, \
128 &bat_priv->_name, net_dev); \
131 #define BATADV_ATTR_SIF_SHOW_BOOL(_name) \
132 ssize_t batadv_show_##_name(struct kobject *kobj, \
133 struct attribute *attr, char *buff) \
135 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
136 return sprintf(buff, "%s\n", \
137 atomic_read(&bat_priv->_name) == 0 ? \
138 "disabled" : "enabled"); \
141 /* Use this, if you are going to turn a [name] in the soft-interface
142 * (bat_priv) on or off
144 #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)
151 #define BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func) \
152 ssize_t batadv_store_##_name(struct kobject *kobj, \
153 struct attribute *attr, char *buff, \
156 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
157 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
158 return __batadv_store_uint_attr(buff, count, _min, _max, \
160 &bat_priv->_name, net_dev); \
163 #define BATADV_ATTR_SIF_SHOW_UINT(_name) \
164 ssize_t batadv_show_##_name(struct kobject *kobj, \
165 struct attribute *attr, char *buff) \
167 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
168 return sprintf(buff, "%i\n", atomic_read(&bat_priv->_name)); \
171 /* Use this, if you are going to set [name] in the soft-interface
172 * (bat_priv) to an unsigned integer value
174 #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)
180 #define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
181 ssize_t batadv_store_vlan_##_name(struct kobject *kobj, \
182 struct attribute *attr, char *buff, \
185 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
186 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
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); \
195 #define BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
196 ssize_t batadv_show_vlan_##_name(struct kobject *kobj, \
197 struct attribute *attr, char *buff) \
199 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
200 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
202 size_t res = sprintf(buff, "%s\n", \
203 atomic_read(&vlan->_name) == 0 ? \
204 "disabled" : "enabled"); \
205 batadv_softif_vlan_free_ref(vlan); \
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)
216 static int batadv_store_bool_attr(char *buff
, size_t count
,
217 struct net_device
*net_dev
,
218 const char *attr_name
, atomic_t
*attr
)
222 if (buff
[count
- 1] == '\n')
223 buff
[count
- 1] = '\0';
225 if ((strncmp(buff
, "1", 2) == 0) ||
226 (strncmp(buff
, "enable", 7) == 0) ||
227 (strncmp(buff
, "enabled", 8) == 0))
230 if ((strncmp(buff
, "0", 2) == 0) ||
231 (strncmp(buff
, "disable", 8) == 0) ||
232 (strncmp(buff
, "disabled", 9) == 0))
236 batadv_info(net_dev
, "%s: Invalid parameter received: %s\n",
241 if (atomic_read(attr
) == enabled
)
244 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");
248 atomic_set(attr
, (unsigned int)enabled
);
252 static 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
)
260 ret
= batadv_store_bool_attr(buff
, count
, net_dev
, attr
->name
,
262 if (post_func
&& ret
)
268 static 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
,
274 unsigned long uint_val
;
277 ret
= kstrtoul(buff
, 10, &uint_val
);
279 batadv_info(net_dev
, "%s: Invalid parameter received: %s\n",
284 if (uint_val
< min
) {
285 batadv_info(net_dev
, "%s: Value is too small: %lu min: %u\n",
286 attr_name
, uint_val
, min
);
290 if (uint_val
> max
) {
291 batadv_info(net_dev
, "%s: Value is too big: %lu max: %u\n",
292 attr_name
, uint_val
, max
);
296 if (atomic_read(attr
) == uint_val
)
299 batadv_info(net_dev
, "%s: Changing from: %i to: %lu\n",
300 attr_name
, atomic_read(attr
), uint_val
);
302 atomic_set(attr
, uint_val
);
306 static inline ssize_t
307 __batadv_store_uint_attr(const char *buff
, size_t count
,
309 void (*post_func
)(struct net_device
*),
310 const struct attribute
*attr
,
311 atomic_t
*attr_store
, struct net_device
*net_dev
)
315 ret
= batadv_store_uint_attr(buff
, count
, net_dev
, attr
->name
, min
, max
,
317 if (post_func
&& ret
)
323 static ssize_t
batadv_show_bat_algo(struct kobject
*kobj
,
324 struct attribute
*attr
, char *buff
)
326 struct batadv_priv
*bat_priv
= batadv_kobj_to_batpriv(kobj
);
327 return sprintf(buff
, "%s\n", bat_priv
->bat_algo_ops
->name
);
330 static void batadv_post_gw_reselect(struct net_device
*net_dev
)
332 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
333 batadv_gw_reselect(bat_priv
);
336 static ssize_t
batadv_show_gw_mode(struct kobject
*kobj
, struct attribute
*attr
,
339 struct batadv_priv
*bat_priv
= batadv_kobj_to_batpriv(kobj
);
342 switch (atomic_read(&bat_priv
->gw_mode
)) {
343 case BATADV_GW_MODE_CLIENT
:
344 bytes_written
= sprintf(buff
, "%s\n",
345 BATADV_GW_MODE_CLIENT_NAME
);
347 case BATADV_GW_MODE_SERVER
:
348 bytes_written
= sprintf(buff
, "%s\n",
349 BATADV_GW_MODE_SERVER_NAME
);
352 bytes_written
= sprintf(buff
, "%s\n",
353 BATADV_GW_MODE_OFF_NAME
);
357 return bytes_written
;
360 static ssize_t
batadv_store_gw_mode(struct kobject
*kobj
,
361 struct attribute
*attr
, char *buff
,
364 struct net_device
*net_dev
= batadv_kobj_to_netdev(kobj
);
365 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
366 char *curr_gw_mode_str
;
367 int gw_mode_tmp
= -1;
369 if (buff
[count
- 1] == '\n')
370 buff
[count
- 1] = '\0';
372 if (strncmp(buff
, BATADV_GW_MODE_OFF_NAME
,
373 strlen(BATADV_GW_MODE_OFF_NAME
)) == 0)
374 gw_mode_tmp
= BATADV_GW_MODE_OFF
;
376 if (strncmp(buff
, BATADV_GW_MODE_CLIENT_NAME
,
377 strlen(BATADV_GW_MODE_CLIENT_NAME
)) == 0)
378 gw_mode_tmp
= BATADV_GW_MODE_CLIENT
;
380 if (strncmp(buff
, BATADV_GW_MODE_SERVER_NAME
,
381 strlen(BATADV_GW_MODE_SERVER_NAME
)) == 0)
382 gw_mode_tmp
= BATADV_GW_MODE_SERVER
;
384 if (gw_mode_tmp
< 0) {
386 "Invalid parameter for 'gw mode' setting received: %s\n",
391 if (atomic_read(&bat_priv
->gw_mode
) == gw_mode_tmp
)
394 switch (atomic_read(&bat_priv
->gw_mode
)) {
395 case BATADV_GW_MODE_CLIENT
:
396 curr_gw_mode_str
= BATADV_GW_MODE_CLIENT_NAME
;
398 case BATADV_GW_MODE_SERVER
:
399 curr_gw_mode_str
= BATADV_GW_MODE_SERVER_NAME
;
402 curr_gw_mode_str
= BATADV_GW_MODE_OFF_NAME
;
406 batadv_info(net_dev
, "Changing gw mode from: %s to: %s\n",
407 curr_gw_mode_str
, buff
);
409 /* 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.
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().
418 batadv_gw_reselect(bat_priv
);
419 /* always call batadv_gw_check_client_stop() before changing the gateway
422 batadv_gw_check_client_stop(bat_priv
);
423 atomic_set(&bat_priv
->gw_mode
, (unsigned int)gw_mode_tmp
);
424 batadv_gw_tvlv_container_update(bat_priv
);
428 static ssize_t
batadv_show_gw_bwidth(struct kobject
*kobj
,
429 struct attribute
*attr
, char *buff
)
431 struct batadv_priv
*bat_priv
= batadv_kobj_to_batpriv(kobj
);
434 down
= atomic_read(&bat_priv
->gw
.bandwidth_down
);
435 up
= atomic_read(&bat_priv
->gw
.bandwidth_up
);
437 return sprintf(buff
, "%u.%u/%u.%u MBit\n", down
/ 10,
438 down
% 10, up
/ 10, up
% 10);
441 static ssize_t
batadv_store_gw_bwidth(struct kobject
*kobj
,
442 struct attribute
*attr
, char *buff
,
445 struct net_device
*net_dev
= batadv_kobj_to_netdev(kobj
);
447 if (buff
[count
- 1] == '\n')
448 buff
[count
- 1] = '\0';
450 return batadv_gw_bandwidth_set(net_dev
, buff
, count
);
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
459 * Returns the number of bytes written into 'buff' on success or a negative
460 * error code in case of failure
462 static ssize_t
batadv_show_isolation_mark(struct kobject
*kobj
,
463 struct attribute
*attr
, char *buff
)
465 struct batadv_priv
*bat_priv
= batadv_kobj_to_batpriv(kobj
);
467 return sprintf(buff
, "%#.8x/%#.8x\n", bat_priv
->isolation_mark
,
468 bat_priv
->isolation_mark_mask
);
472 * batadv_store_isolation_mark - parse and store the isolation mark/mask entered
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
479 * Returns 'count' on success or a negative error code in case of failure
481 static ssize_t
batadv_store_isolation_mark(struct kobject
*kobj
,
482 struct attribute
*attr
, char *buff
,
485 struct net_device
*net_dev
= batadv_kobj_to_netdev(kobj
);
486 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
490 /* parse the mask if it has been specified, otherwise assume the mask is
491 * the biggest possible
494 mask_ptr
= strchr(buff
, '/');
499 /* the mask must be entered in hex base as it is going to be a
500 * bitmask and not a prefix length
502 if (kstrtou32(mask_ptr
, 16, &mask
) < 0)
506 /* the mark can be entered in any base */
507 if (kstrtou32(buff
, 0, &mark
) < 0)
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
;
515 "New skb mark for extended isolation: %#.8x/%#.8x\n",
516 bat_priv
->isolation_mark
, bat_priv
->isolation_mark_mask
);
521 BATADV_ATTR_SIF_BOOL(aggregated_ogms
, S_IRUGO
| S_IWUSR
, NULL
);
522 BATADV_ATTR_SIF_BOOL(bonding
, S_IRUGO
| S_IWUSR
, NULL
);
523 #ifdef CONFIG_BATMAN_ADV_BLA
524 BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance
, S_IRUGO
| S_IWUSR
, NULL
);
526 #ifdef CONFIG_BATMAN_ADV_DAT
527 BATADV_ATTR_SIF_BOOL(distributed_arp_table
, S_IRUGO
| S_IWUSR
,
528 batadv_dat_status_update
);
530 BATADV_ATTR_SIF_BOOL(fragmentation
, S_IRUGO
| S_IWUSR
, batadv_update_min_mtu
);
531 static BATADV_ATTR(routing_algo
, S_IRUGO
, batadv_show_bat_algo
, NULL
);
532 static BATADV_ATTR(gw_mode
, S_IRUGO
| S_IWUSR
, batadv_show_gw_mode
,
533 batadv_store_gw_mode
);
534 BATADV_ATTR_SIF_UINT(orig_interval
, S_IRUGO
| S_IWUSR
, 2 * BATADV_JITTER
,
536 BATADV_ATTR_SIF_UINT(hop_penalty
, S_IRUGO
| S_IWUSR
, 0, BATADV_TQ_MAX_VALUE
,
538 BATADV_ATTR_SIF_UINT(gw_sel_class
, S_IRUGO
| S_IWUSR
, 1, BATADV_TQ_MAX_VALUE
,
539 batadv_post_gw_reselect
);
540 static BATADV_ATTR(gw_bandwidth
, S_IRUGO
| S_IWUSR
, batadv_show_gw_bwidth
,
541 batadv_store_gw_bwidth
);
542 #ifdef CONFIG_BATMAN_ADV_DEBUG
543 BATADV_ATTR_SIF_UINT(log_level
, S_IRUGO
| S_IWUSR
, 0, BATADV_DBG_ALL
, NULL
);
545 #ifdef CONFIG_BATMAN_ADV_NC
546 BATADV_ATTR_SIF_BOOL(network_coding
, S_IRUGO
| S_IWUSR
,
547 batadv_nc_status_update
);
549 static BATADV_ATTR(isolation_mark
, S_IRUGO
| S_IWUSR
,
550 batadv_show_isolation_mark
, batadv_store_isolation_mark
);
552 static struct batadv_attribute
*batadv_mesh_attrs
[] = {
553 &batadv_attr_aggregated_ogms
,
554 &batadv_attr_bonding
,
555 #ifdef CONFIG_BATMAN_ADV_BLA
556 &batadv_attr_bridge_loop_avoidance
,
558 #ifdef CONFIG_BATMAN_ADV_DAT
559 &batadv_attr_distributed_arp_table
,
561 &batadv_attr_fragmentation
,
562 &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
,
568 #ifdef CONFIG_BATMAN_ADV_DEBUG
569 &batadv_attr_log_level
,
571 #ifdef CONFIG_BATMAN_ADV_NC
572 &batadv_attr_network_coding
,
574 &batadv_attr_isolation_mark
,
578 BATADV_ATTR_VLAN_BOOL(ap_isolation
, S_IRUGO
| S_IWUSR
, NULL
);
581 * batadv_vlan_attrs - array of vlan specific sysfs attributes
583 static struct batadv_attribute
*batadv_vlan_attrs
[] = {
584 &batadv_attr_vlan_ap_isolation
,
588 int batadv_sysfs_add_meshif(struct net_device
*dev
)
590 struct kobject
*batif_kobject
= &dev
->dev
.kobj
;
591 struct batadv_priv
*bat_priv
= netdev_priv(dev
);
592 struct batadv_attribute
**bat_attr
;
595 bat_priv
->mesh_obj
= kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR
,
597 if (!bat_priv
->mesh_obj
) {
598 batadv_err(dev
, "Can't add sysfs directory: %s/%s\n", dev
->name
,
599 BATADV_SYSFS_IF_MESH_SUBDIR
);
603 for (bat_attr
= batadv_mesh_attrs
; *bat_attr
; ++bat_attr
) {
604 err
= sysfs_create_file(bat_priv
->mesh_obj
,
605 &((*bat_attr
)->attr
));
607 batadv_err(dev
, "Can't add sysfs file: %s/%s/%s\n",
608 dev
->name
, BATADV_SYSFS_IF_MESH_SUBDIR
,
609 ((*bat_attr
)->attr
).name
);
617 for (bat_attr
= batadv_mesh_attrs
; *bat_attr
; ++bat_attr
)
618 sysfs_remove_file(bat_priv
->mesh_obj
, &((*bat_attr
)->attr
));
620 kobject_put(bat_priv
->mesh_obj
);
621 bat_priv
->mesh_obj
= NULL
;
626 void batadv_sysfs_del_meshif(struct net_device
*dev
)
628 struct batadv_priv
*bat_priv
= netdev_priv(dev
);
629 struct batadv_attribute
**bat_attr
;
631 for (bat_attr
= batadv_mesh_attrs
; *bat_attr
; ++bat_attr
)
632 sysfs_remove_file(bat_priv
->mesh_obj
, &((*bat_attr
)->attr
));
634 kobject_put(bat_priv
->mesh_obj
);
635 bat_priv
->mesh_obj
= NULL
;
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
643 * Returns 0 on success and -ENOMEM if any of the structure allocations fails.
645 int batadv_sysfs_add_vlan(struct net_device
*dev
,
646 struct batadv_softif_vlan
*vlan
)
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
;
653 if (vlan
->vid
& BATADV_VLAN_HAS_TAG
) {
654 sprintf(vlan_subdir
, BATADV_SYSFS_VLAN_SUBDIR_PREFIX
"%hu",
655 vlan
->vid
& VLAN_VID_MASK
);
657 vlan
->kobj
= kobject_create_and_add(vlan_subdir
,
660 batadv_err(dev
, "Can't add sysfs directory: %s/%s\n",
661 dev
->name
, vlan_subdir
);
665 /* the untagged LAN uses the root folder to store its "VLAN
666 * specific attributes"
668 vlan
->kobj
= bat_priv
->mesh_obj
;
669 kobject_get(bat_priv
->mesh_obj
);
672 for (bat_attr
= batadv_vlan_attrs
; *bat_attr
; ++bat_attr
) {
673 err
= sysfs_create_file(vlan
->kobj
,
674 &((*bat_attr
)->attr
));
676 batadv_err(dev
, "Can't add sysfs file: %s/%s/%s\n",
677 dev
->name
, vlan_subdir
,
678 ((*bat_attr
)->attr
).name
);
686 for (bat_attr
= batadv_vlan_attrs
; *bat_attr
; ++bat_attr
)
687 sysfs_remove_file(vlan
->kobj
, &((*bat_attr
)->attr
));
689 kobject_put(vlan
->kobj
);
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
700 void batadv_sysfs_del_vlan(struct batadv_priv
*bat_priv
,
701 struct batadv_softif_vlan
*vlan
)
703 struct batadv_attribute
**bat_attr
;
705 for (bat_attr
= batadv_vlan_attrs
; *bat_attr
; ++bat_attr
)
706 sysfs_remove_file(vlan
->kobj
, &((*bat_attr
)->attr
));
708 kobject_put(vlan
->kobj
);
712 static ssize_t
batadv_show_mesh_iface(struct kobject
*kobj
,
713 struct attribute
*attr
, char *buff
)
715 struct net_device
*net_dev
= batadv_kobj_to_netdev(kobj
);
716 struct batadv_hard_iface
*hard_iface
;
720 hard_iface
= batadv_hardif_get_by_netdev(net_dev
);
724 if (hard_iface
->if_status
== BATADV_IF_NOT_IN_USE
)
727 ifname
= hard_iface
->soft_iface
->name
;
729 length
= sprintf(buff
, "%s\n", ifname
);
731 batadv_hardif_free_ref(hard_iface
);
736 static ssize_t
batadv_store_mesh_iface(struct kobject
*kobj
,
737 struct attribute
*attr
, char *buff
,
740 struct net_device
*net_dev
= batadv_kobj_to_netdev(kobj
);
741 struct batadv_hard_iface
*hard_iface
;
745 hard_iface
= batadv_hardif_get_by_netdev(net_dev
);
749 if (buff
[count
- 1] == '\n')
750 buff
[count
- 1] = '\0';
752 if (strlen(buff
) >= IFNAMSIZ
) {
753 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
755 batadv_hardif_free_ref(hard_iface
);
759 if (strncmp(buff
, "none", 4) == 0)
760 status_tmp
= BATADV_IF_NOT_IN_USE
;
762 status_tmp
= BATADV_IF_I_WANT_YOU
;
764 if (hard_iface
->if_status
== status_tmp
)
767 if ((hard_iface
->soft_iface
) &&
768 (strncmp(hard_iface
->soft_iface
->name
, buff
, IFNAMSIZ
) == 0))
773 if (status_tmp
== BATADV_IF_NOT_IN_USE
) {
774 batadv_hardif_disable_interface(hard_iface
,
775 BATADV_IF_CLEANUP_AUTO
);
779 /* if the interface already is in use */
780 if (hard_iface
->if_status
!= BATADV_IF_NOT_IN_USE
)
781 batadv_hardif_disable_interface(hard_iface
,
782 BATADV_IF_CLEANUP_AUTO
);
784 ret
= batadv_hardif_enable_interface(hard_iface
, buff
);
789 batadv_hardif_free_ref(hard_iface
);
793 static ssize_t
batadv_show_iface_status(struct kobject
*kobj
,
794 struct attribute
*attr
, char *buff
)
796 struct net_device
*net_dev
= batadv_kobj_to_netdev(kobj
);
797 struct batadv_hard_iface
*hard_iface
;
800 hard_iface
= batadv_hardif_get_by_netdev(net_dev
);
804 switch (hard_iface
->if_status
) {
805 case BATADV_IF_TO_BE_REMOVED
:
806 length
= sprintf(buff
, "disabling\n");
808 case BATADV_IF_INACTIVE
:
809 length
= sprintf(buff
, "inactive\n");
811 case BATADV_IF_ACTIVE
:
812 length
= sprintf(buff
, "active\n");
814 case BATADV_IF_TO_BE_ACTIVATED
:
815 length
= sprintf(buff
, "enabling\n");
817 case BATADV_IF_NOT_IN_USE
:
819 length
= sprintf(buff
, "not in use\n");
823 batadv_hardif_free_ref(hard_iface
);
828 static BATADV_ATTR(mesh_iface
, S_IRUGO
| S_IWUSR
, batadv_show_mesh_iface
,
829 batadv_store_mesh_iface
);
830 static BATADV_ATTR(iface_status
, S_IRUGO
, batadv_show_iface_status
, NULL
);
832 static struct batadv_attribute
*batadv_batman_attrs
[] = {
833 &batadv_attr_mesh_iface
,
834 &batadv_attr_iface_status
,
838 int batadv_sysfs_add_hardif(struct kobject
**hardif_obj
, struct net_device
*dev
)
840 struct kobject
*hardif_kobject
= &dev
->dev
.kobj
;
841 struct batadv_attribute
**bat_attr
;
844 *hardif_obj
= kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR
,
848 batadv_err(dev
, "Can't add sysfs directory: %s/%s\n", dev
->name
,
849 BATADV_SYSFS_IF_BAT_SUBDIR
);
853 for (bat_attr
= batadv_batman_attrs
; *bat_attr
; ++bat_attr
) {
854 err
= sysfs_create_file(*hardif_obj
, &((*bat_attr
)->attr
));
856 batadv_err(dev
, "Can't add sysfs file: %s/%s/%s\n",
857 dev
->name
, BATADV_SYSFS_IF_BAT_SUBDIR
,
858 ((*bat_attr
)->attr
).name
);
866 for (bat_attr
= batadv_batman_attrs
; *bat_attr
; ++bat_attr
)
867 sysfs_remove_file(*hardif_obj
, &((*bat_attr
)->attr
));
872 void batadv_sysfs_del_hardif(struct kobject
**hardif_obj
)
874 kobject_put(*hardif_obj
);
878 int batadv_throw_uevent(struct batadv_priv
*bat_priv
, enum batadv_uev_type type
,
879 enum batadv_uev_action action
, const char *data
)
882 struct kobject
*bat_kobj
;
883 char *uevent_env
[4] = { NULL
, NULL
, NULL
, NULL
};
885 bat_kobj
= &bat_priv
->soft_iface
->dev
.kobj
;
887 uevent_env
[0] = kmalloc(strlen(BATADV_UEV_TYPE_VAR
) +
888 strlen(batadv_uev_type_str
[type
]) + 1,
893 sprintf(uevent_env
[0], "%s%s", BATADV_UEV_TYPE_VAR
,
894 batadv_uev_type_str
[type
]);
896 uevent_env
[1] = kmalloc(strlen(BATADV_UEV_ACTION_VAR
) +
897 strlen(batadv_uev_action_str
[action
]) + 1,
902 sprintf(uevent_env
[1], "%s%s", BATADV_UEV_ACTION_VAR
,
903 batadv_uev_action_str
[action
]);
905 /* If the event is DEL, ignore the data field */
906 if (action
!= BATADV_UEV_DEL
) {
907 uevent_env
[2] = kmalloc(strlen(BATADV_UEV_DATA_VAR
) +
908 strlen(data
) + 1, GFP_ATOMIC
);
912 sprintf(uevent_env
[2], "%s%s", BATADV_UEV_DATA_VAR
, data
);
915 ret
= kobject_uevent_env(bat_kobj
, KOBJ_CHANGE
, uevent_env
);
917 kfree(uevent_env
[0]);
918 kfree(uevent_env
[1]);
919 kfree(uevent_env
[2]);
922 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
923 "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
924 batadv_uev_type_str
[type
],
925 batadv_uev_action_str
[action
],
926 (action
== BATADV_UEV_DEL
? "NULL" : data
), ret
);