1 /* Copyright (C) 2010-2014 B.A.T.M.A.N. contributors:
2 *
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
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #include "main.h"
19 #include "sysfs.h"
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"
28
batadv_kobj_to_netdev(struct kobject * obj)29 static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
30 {
31 struct device *dev = container_of(obj->parent, struct device, kobj);
32
33 return to_net_dev(dev);
34 }
35
batadv_kobj_to_batpriv(struct kobject * obj)36 static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
37 {
38 struct net_device *net_dev = batadv_kobj_to_netdev(obj);
39
40 return netdev_priv(net_dev);
41 }
42
43 /**
44 * batadv_vlan_kobj_to_batpriv - convert a vlan kobj in the associated batpriv
45 * @obj: kobject to covert
46 *
47 * Returns the associated batadv_priv struct.
48 */
batadv_vlan_kobj_to_batpriv(struct kobject * obj)49 static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
50 {
51 /* VLAN specific attributes are located in the root sysfs folder if they
52 * refer to the untagged VLAN..
53 */
54 if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
55 return batadv_kobj_to_batpriv(obj);
56
57 /* ..while the attributes for the tagged vlans are located in
58 * the in the corresponding "vlan%VID" subfolder
59 */
60 return batadv_kobj_to_batpriv(obj->parent);
61 }
62
63 /**
64 * batadv_kobj_to_vlan - convert a kobj in the associated softif_vlan struct
65 * @obj: kobject to covert
66 *
67 * Returns the associated softif_vlan struct if found, NULL otherwise.
68 */
69 static struct batadv_softif_vlan *
batadv_kobj_to_vlan(struct batadv_priv * bat_priv,struct kobject * obj)70 batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
71 {
72 struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
73
74 rcu_read_lock();
75 hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
76 if (vlan_tmp->kobj != obj)
77 continue;
78
79 if (!atomic_inc_not_zero(&vlan_tmp->refcount))
80 continue;
81
82 vlan = vlan_tmp;
83 break;
84 }
85 rcu_read_unlock();
86
87 return vlan;
88 }
89
90 #define BATADV_UEV_TYPE_VAR "BATTYPE="
91 #define BATADV_UEV_ACTION_VAR "BATACTION="
92 #define BATADV_UEV_DATA_VAR "BATDATA="
93
94 static char *batadv_uev_action_str[] = {
95 "add",
96 "del",
97 "change"
98 };
99
100 static char *batadv_uev_type_str[] = {
101 "gw"
102 };
103
104 /* Use this, if you have customized show and store functions for vlan attrs */
105 #define BATADV_ATTR_VLAN(_name, _mode, _show, _store) \
106 struct batadv_attribute batadv_attr_vlan_##_name = { \
107 .attr = {.name = __stringify(_name), \
108 .mode = _mode }, \
109 .show = _show, \
110 .store = _store, \
111 }
112
113 /* Use this, if you have customized show and store functions */
114 #define BATADV_ATTR(_name, _mode, _show, _store) \
115 struct batadv_attribute batadv_attr_##_name = { \
116 .attr = {.name = __stringify(_name), \
117 .mode = _mode }, \
118 .show = _show, \
119 .store = _store, \
120 }
121
122 #define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
123 ssize_t batadv_store_##_name(struct kobject *kobj, \
124 struct attribute *attr, char *buff, \
125 size_t count) \
126 { \
127 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
128 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
129 \
130 return __batadv_store_bool_attr(buff, count, _post_func, attr, \
131 &bat_priv->_name, net_dev); \
132 }
133
134 #define BATADV_ATTR_SIF_SHOW_BOOL(_name) \
135 ssize_t batadv_show_##_name(struct kobject *kobj, \
136 struct attribute *attr, char *buff) \
137 { \
138 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
139 \
140 return sprintf(buff, "%s\n", \
141 atomic_read(&bat_priv->_name) == 0 ? \
142 "disabled" : "enabled"); \
143 } \
144
145 /* Use this, if you are going to turn a [name] in the soft-interface
146 * (bat_priv) on or off
147 */
148 #define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func) \
149 static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func) \
150 static BATADV_ATTR_SIF_SHOW_BOOL(_name) \
151 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
152 batadv_store_##_name)
153
154
155 #define BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func) \
156 ssize_t batadv_store_##_name(struct kobject *kobj, \
157 struct attribute *attr, char *buff, \
158 size_t count) \
159 { \
160 struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \
161 struct batadv_priv *bat_priv = netdev_priv(net_dev); \
162 \
163 return __batadv_store_uint_attr(buff, count, _min, _max, \
164 _post_func, attr, \
165 &bat_priv->_name, net_dev); \
166 }
167
168 #define BATADV_ATTR_SIF_SHOW_UINT(_name) \
169 ssize_t batadv_show_##_name(struct kobject *kobj, \
170 struct attribute *attr, char *buff) \
171 { \
172 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \
173 \
174 return sprintf(buff, "%i\n", atomic_read(&bat_priv->_name)); \
175 } \
176
177 /* Use this, if you are going to set [name] in the soft-interface
178 * (bat_priv) to an unsigned integer value
179 */
180 #define BATADV_ATTR_SIF_UINT(_name, _mode, _min, _max, _post_func) \
181 static BATADV_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func)\
182 static BATADV_ATTR_SIF_SHOW_UINT(_name) \
183 static BATADV_ATTR(_name, _mode, batadv_show_##_name, \
184 batadv_store_##_name)
185
186 #define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
187 ssize_t batadv_store_vlan_##_name(struct kobject *kobj, \
188 struct attribute *attr, char *buff, \
189 size_t count) \
190 { \
191 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
192 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
193 kobj); \
194 size_t res = __batadv_store_bool_attr(buff, count, _post_func, \
195 attr, &vlan->_name, \
196 bat_priv->soft_iface); \
197 \
198 batadv_softif_vlan_free_ref(vlan); \
199 return res; \
200 }
201
202 #define BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
203 ssize_t batadv_show_vlan_##_name(struct kobject *kobj, \
204 struct attribute *attr, char *buff) \
205 { \
206 struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
207 struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
208 kobj); \
209 size_t res = sprintf(buff, "%s\n", \
210 atomic_read(&vlan->_name) == 0 ? \
211 "disabled" : "enabled"); \
212 \
213 batadv_softif_vlan_free_ref(vlan); \
214 return res; \
215 }
216
217 /* Use this, if you are going to turn a [name] in the vlan struct on or off */
218 #define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func) \
219 static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func) \
220 static BATADV_ATTR_VLAN_SHOW_BOOL(_name) \
221 static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name, \
222 batadv_store_vlan_##_name)
223
batadv_store_bool_attr(char * buff,size_t count,struct net_device * net_dev,const char * attr_name,atomic_t * attr)224 static int batadv_store_bool_attr(char *buff, size_t count,
225 struct net_device *net_dev,
226 const char *attr_name, atomic_t *attr)
227 {
228 int enabled = -1;
229
230 if (buff[count - 1] == '\n')
231 buff[count - 1] = '\0';
232
233 if ((strncmp(buff, "1", 2) == 0) ||
234 (strncmp(buff, "enable", 7) == 0) ||
235 (strncmp(buff, "enabled", 8) == 0))
236 enabled = 1;
237
238 if ((strncmp(buff, "0", 2) == 0) ||
239 (strncmp(buff, "disable", 8) == 0) ||
240 (strncmp(buff, "disabled", 9) == 0))
241 enabled = 0;
242
243 if (enabled < 0) {
244 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
245 attr_name, buff);
246 return -EINVAL;
247 }
248
249 if (atomic_read(attr) == enabled)
250 return count;
251
252 batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
253 atomic_read(attr) == 1 ? "enabled" : "disabled",
254 enabled == 1 ? "enabled" : "disabled");
255
256 atomic_set(attr, (unsigned int)enabled);
257 return count;
258 }
259
260 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)261 __batadv_store_bool_attr(char *buff, size_t count,
262 void (*post_func)(struct net_device *),
263 struct attribute *attr,
264 atomic_t *attr_store, struct net_device *net_dev)
265 {
266 int ret;
267
268 ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
269 attr_store);
270 if (post_func && ret)
271 post_func(net_dev);
272
273 return ret;
274 }
275
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)276 static int batadv_store_uint_attr(const char *buff, size_t count,
277 struct net_device *net_dev,
278 const char *attr_name,
279 unsigned int min, unsigned int max,
280 atomic_t *attr)
281 {
282 unsigned long uint_val;
283 int ret;
284
285 ret = kstrtoul(buff, 10, &uint_val);
286 if (ret) {
287 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
288 attr_name, buff);
289 return -EINVAL;
290 }
291
292 if (uint_val < min) {
293 batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
294 attr_name, uint_val, min);
295 return -EINVAL;
296 }
297
298 if (uint_val > max) {
299 batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
300 attr_name, uint_val, max);
301 return -EINVAL;
302 }
303
304 if (atomic_read(attr) == uint_val)
305 return count;
306
307 batadv_info(net_dev, "%s: Changing from: %i to: %lu\n",
308 attr_name, atomic_read(attr), uint_val);
309
310 atomic_set(attr, uint_val);
311 return count;
312 }
313
314 static inline 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)315 __batadv_store_uint_attr(const char *buff, size_t count,
316 int min, int max,
317 void (*post_func)(struct net_device *),
318 const struct attribute *attr,
319 atomic_t *attr_store, struct net_device *net_dev)
320 {
321 int ret;
322
323 ret = batadv_store_uint_attr(buff, count, net_dev, attr->name, min, max,
324 attr_store);
325 if (post_func && ret)
326 post_func(net_dev);
327
328 return ret;
329 }
330
batadv_show_bat_algo(struct kobject * kobj,struct attribute * attr,char * buff)331 static ssize_t batadv_show_bat_algo(struct kobject *kobj,
332 struct attribute *attr, char *buff)
333 {
334 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
335
336 return sprintf(buff, "%s\n", bat_priv->bat_algo_ops->name);
337 }
338
batadv_post_gw_reselect(struct net_device * net_dev)339 static void batadv_post_gw_reselect(struct net_device *net_dev)
340 {
341 struct batadv_priv *bat_priv = netdev_priv(net_dev);
342
343 batadv_gw_reselect(bat_priv);
344 }
345
batadv_show_gw_mode(struct kobject * kobj,struct attribute * attr,char * buff)346 static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
347 char *buff)
348 {
349 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
350 int bytes_written;
351
352 switch (atomic_read(&bat_priv->gw_mode)) {
353 case BATADV_GW_MODE_CLIENT:
354 bytes_written = sprintf(buff, "%s\n",
355 BATADV_GW_MODE_CLIENT_NAME);
356 break;
357 case BATADV_GW_MODE_SERVER:
358 bytes_written = sprintf(buff, "%s\n",
359 BATADV_GW_MODE_SERVER_NAME);
360 break;
361 default:
362 bytes_written = sprintf(buff, "%s\n",
363 BATADV_GW_MODE_OFF_NAME);
364 break;
365 }
366
367 return bytes_written;
368 }
369
batadv_store_gw_mode(struct kobject * kobj,struct attribute * attr,char * buff,size_t count)370 static ssize_t batadv_store_gw_mode(struct kobject *kobj,
371 struct attribute *attr, char *buff,
372 size_t count)
373 {
374 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
375 struct batadv_priv *bat_priv = netdev_priv(net_dev);
376 char *curr_gw_mode_str;
377 int gw_mode_tmp = -1;
378
379 if (buff[count - 1] == '\n')
380 buff[count - 1] = '\0';
381
382 if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
383 strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
384 gw_mode_tmp = BATADV_GW_MODE_OFF;
385
386 if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
387 strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
388 gw_mode_tmp = BATADV_GW_MODE_CLIENT;
389
390 if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
391 strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
392 gw_mode_tmp = BATADV_GW_MODE_SERVER;
393
394 if (gw_mode_tmp < 0) {
395 batadv_info(net_dev,
396 "Invalid parameter for 'gw mode' setting received: %s\n",
397 buff);
398 return -EINVAL;
399 }
400
401 if (atomic_read(&bat_priv->gw_mode) == gw_mode_tmp)
402 return count;
403
404 switch (atomic_read(&bat_priv->gw_mode)) {
405 case BATADV_GW_MODE_CLIENT:
406 curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
407 break;
408 case BATADV_GW_MODE_SERVER:
409 curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
410 break;
411 default:
412 curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
413 break;
414 }
415
416 batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
417 curr_gw_mode_str, buff);
418
419 /* Invoking batadv_gw_reselect() is not enough to really de-select the
420 * current GW. It will only instruct the gateway client code to perform
421 * a re-election the next time that this is needed.
422 *
423 * When gw client mode is being switched off the current GW must be
424 * de-selected explicitly otherwise no GW_ADD uevent is thrown on
425 * client mode re-activation. This is operation is performed in
426 * batadv_gw_check_client_stop().
427 */
428 batadv_gw_reselect(bat_priv);
429 /* always call batadv_gw_check_client_stop() before changing the gateway
430 * state
431 */
432 batadv_gw_check_client_stop(bat_priv);
433 atomic_set(&bat_priv->gw_mode, (unsigned int)gw_mode_tmp);
434 batadv_gw_tvlv_container_update(bat_priv);
435 return count;
436 }
437
batadv_show_gw_bwidth(struct kobject * kobj,struct attribute * attr,char * buff)438 static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
439 struct attribute *attr, char *buff)
440 {
441 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
442 uint32_t down, up;
443
444 down = atomic_read(&bat_priv->gw.bandwidth_down);
445 up = atomic_read(&bat_priv->gw.bandwidth_up);
446
447 return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
448 down % 10, up / 10, up % 10);
449 }
450
batadv_store_gw_bwidth(struct kobject * kobj,struct attribute * attr,char * buff,size_t count)451 static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
452 struct attribute *attr, char *buff,
453 size_t count)
454 {
455 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
456
457 if (buff[count - 1] == '\n')
458 buff[count - 1] = '\0';
459
460 return batadv_gw_bandwidth_set(net_dev, buff, count);
461 }
462
463 /**
464 * batadv_show_isolation_mark - print the current isolation mark/mask
465 * @kobj: kobject representing the private mesh sysfs directory
466 * @attr: the batman-adv attribute the user is interacting with
467 * @buff: the buffer that will contain the data to send back to the user
468 *
469 * Returns the number of bytes written into 'buff' on success or a negative
470 * error code in case of failure
471 */
batadv_show_isolation_mark(struct kobject * kobj,struct attribute * attr,char * buff)472 static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
473 struct attribute *attr, char *buff)
474 {
475 struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
476
477 return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
478 bat_priv->isolation_mark_mask);
479 }
480
481 /**
482 * batadv_store_isolation_mark - parse and store the isolation mark/mask entered
483 * by the user
484 * @kobj: kobject representing the private mesh sysfs directory
485 * @attr: the batman-adv attribute the user is interacting with
486 * @buff: the buffer containing the user data
487 * @count: number of bytes in the buffer
488 *
489 * Returns 'count' on success or a negative error code in case of failure
490 */
batadv_store_isolation_mark(struct kobject * kobj,struct attribute * attr,char * buff,size_t count)491 static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
492 struct attribute *attr, char *buff,
493 size_t count)
494 {
495 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
496 struct batadv_priv *bat_priv = netdev_priv(net_dev);
497 uint32_t mark, mask;
498 char *mask_ptr;
499
500 /* parse the mask if it has been specified, otherwise assume the mask is
501 * the biggest possible
502 */
503 mask = 0xFFFFFFFF;
504 mask_ptr = strchr(buff, '/');
505 if (mask_ptr) {
506 *mask_ptr = '\0';
507 mask_ptr++;
508
509 /* the mask must be entered in hex base as it is going to be a
510 * bitmask and not a prefix length
511 */
512 if (kstrtou32(mask_ptr, 16, &mask) < 0)
513 return -EINVAL;
514 }
515
516 /* the mark can be entered in any base */
517 if (kstrtou32(buff, 0, &mark) < 0)
518 return -EINVAL;
519
520 bat_priv->isolation_mark_mask = mask;
521 /* erase bits not covered by the mask */
522 bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;
523
524 batadv_info(net_dev,
525 "New skb mark for extended isolation: %#.8x/%#.8x\n",
526 bat_priv->isolation_mark, bat_priv->isolation_mark_mask);
527
528 return count;
529 }
530
531 BATADV_ATTR_SIF_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL);
532 BATADV_ATTR_SIF_BOOL(bonding, S_IRUGO | S_IWUSR, NULL);
533 #ifdef CONFIG_BATMAN_ADV_BLA
534 BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, S_IRUGO | S_IWUSR, NULL);
535 #endif
536 #ifdef CONFIG_BATMAN_ADV_DAT
537 BATADV_ATTR_SIF_BOOL(distributed_arp_table, S_IRUGO | S_IWUSR,
538 batadv_dat_status_update);
539 #endif
540 BATADV_ATTR_SIF_BOOL(fragmentation, S_IRUGO | S_IWUSR, batadv_update_min_mtu);
541 static BATADV_ATTR(routing_algo, S_IRUGO, batadv_show_bat_algo, NULL);
542 static BATADV_ATTR(gw_mode, S_IRUGO | S_IWUSR, batadv_show_gw_mode,
543 batadv_store_gw_mode);
544 BATADV_ATTR_SIF_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * BATADV_JITTER,
545 INT_MAX, NULL);
546 BATADV_ATTR_SIF_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, BATADV_TQ_MAX_VALUE,
547 NULL);
548 BATADV_ATTR_SIF_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, BATADV_TQ_MAX_VALUE,
549 batadv_post_gw_reselect);
550 static BATADV_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, batadv_show_gw_bwidth,
551 batadv_store_gw_bwidth);
552 #ifdef CONFIG_BATMAN_ADV_MCAST
553 BATADV_ATTR_SIF_BOOL(multicast_mode, S_IRUGO | S_IWUSR, NULL);
554 #endif
555 #ifdef CONFIG_BATMAN_ADV_DEBUG
556 BATADV_ATTR_SIF_UINT(log_level, S_IRUGO | S_IWUSR, 0, BATADV_DBG_ALL, NULL);
557 #endif
558 #ifdef CONFIG_BATMAN_ADV_NC
559 BATADV_ATTR_SIF_BOOL(network_coding, S_IRUGO | S_IWUSR,
560 batadv_nc_status_update);
561 #endif
562 static BATADV_ATTR(isolation_mark, S_IRUGO | S_IWUSR,
563 batadv_show_isolation_mark, batadv_store_isolation_mark);
564
565 static struct batadv_attribute *batadv_mesh_attrs[] = {
566 &batadv_attr_aggregated_ogms,
567 &batadv_attr_bonding,
568 #ifdef CONFIG_BATMAN_ADV_BLA
569 &batadv_attr_bridge_loop_avoidance,
570 #endif
571 #ifdef CONFIG_BATMAN_ADV_DAT
572 &batadv_attr_distributed_arp_table,
573 #endif
574 #ifdef CONFIG_BATMAN_ADV_MCAST
575 &batadv_attr_multicast_mode,
576 #endif
577 &batadv_attr_fragmentation,
578 &batadv_attr_routing_algo,
579 &batadv_attr_gw_mode,
580 &batadv_attr_orig_interval,
581 &batadv_attr_hop_penalty,
582 &batadv_attr_gw_sel_class,
583 &batadv_attr_gw_bandwidth,
584 #ifdef CONFIG_BATMAN_ADV_DEBUG
585 &batadv_attr_log_level,
586 #endif
587 #ifdef CONFIG_BATMAN_ADV_NC
588 &batadv_attr_network_coding,
589 #endif
590 &batadv_attr_isolation_mark,
591 NULL,
592 };
593
594 BATADV_ATTR_VLAN_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL);
595
596 /**
597 * batadv_vlan_attrs - array of vlan specific sysfs attributes
598 */
599 static struct batadv_attribute *batadv_vlan_attrs[] = {
600 &batadv_attr_vlan_ap_isolation,
601 NULL,
602 };
603
batadv_sysfs_add_meshif(struct net_device * dev)604 int batadv_sysfs_add_meshif(struct net_device *dev)
605 {
606 struct kobject *batif_kobject = &dev->dev.kobj;
607 struct batadv_priv *bat_priv = netdev_priv(dev);
608 struct batadv_attribute **bat_attr;
609 int err;
610
611 bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
612 batif_kobject);
613 if (!bat_priv->mesh_obj) {
614 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
615 BATADV_SYSFS_IF_MESH_SUBDIR);
616 goto out;
617 }
618
619 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
620 err = sysfs_create_file(bat_priv->mesh_obj,
621 &((*bat_attr)->attr));
622 if (err) {
623 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
624 dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
625 ((*bat_attr)->attr).name);
626 goto rem_attr;
627 }
628 }
629
630 return 0;
631
632 rem_attr:
633 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
634 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
635
636 kobject_put(bat_priv->mesh_obj);
637 bat_priv->mesh_obj = NULL;
638 out:
639 return -ENOMEM;
640 }
641
batadv_sysfs_del_meshif(struct net_device * dev)642 void batadv_sysfs_del_meshif(struct net_device *dev)
643 {
644 struct batadv_priv *bat_priv = netdev_priv(dev);
645 struct batadv_attribute **bat_attr;
646
647 for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
648 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
649
650 kobject_put(bat_priv->mesh_obj);
651 bat_priv->mesh_obj = NULL;
652 }
653
654 /**
655 * batadv_sysfs_add_vlan - add all the needed sysfs objects for the new vlan
656 * @dev: netdev of the mesh interface
657 * @vlan: private data of the newly added VLAN interface
658 *
659 * Returns 0 on success and -ENOMEM if any of the structure allocations fails.
660 */
batadv_sysfs_add_vlan(struct net_device * dev,struct batadv_softif_vlan * vlan)661 int batadv_sysfs_add_vlan(struct net_device *dev,
662 struct batadv_softif_vlan *vlan)
663 {
664 char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
665 struct batadv_priv *bat_priv = netdev_priv(dev);
666 struct batadv_attribute **bat_attr;
667 int err;
668
669 if (vlan->vid & BATADV_VLAN_HAS_TAG) {
670 sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
671 vlan->vid & VLAN_VID_MASK);
672
673 vlan->kobj = kobject_create_and_add(vlan_subdir,
674 bat_priv->mesh_obj);
675 if (!vlan->kobj) {
676 batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
677 dev->name, vlan_subdir);
678 goto out;
679 }
680 } else {
681 /* the untagged LAN uses the root folder to store its "VLAN
682 * specific attributes"
683 */
684 vlan->kobj = bat_priv->mesh_obj;
685 kobject_get(bat_priv->mesh_obj);
686 }
687
688 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
689 err = sysfs_create_file(vlan->kobj,
690 &((*bat_attr)->attr));
691 if (err) {
692 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
693 dev->name, vlan_subdir,
694 ((*bat_attr)->attr).name);
695 goto rem_attr;
696 }
697 }
698
699 return 0;
700
701 rem_attr:
702 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
703 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
704
705 kobject_put(vlan->kobj);
706 vlan->kobj = NULL;
707 out:
708 return -ENOMEM;
709 }
710
711 /**
712 * batadv_sysfs_del_vlan - remove all the sysfs objects for a given VLAN
713 * @bat_priv: the bat priv with all the soft interface information
714 * @vlan: the private data of the VLAN to destroy
715 */
batadv_sysfs_del_vlan(struct batadv_priv * bat_priv,struct batadv_softif_vlan * vlan)716 void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
717 struct batadv_softif_vlan *vlan)
718 {
719 struct batadv_attribute **bat_attr;
720
721 for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
722 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
723
724 kobject_put(vlan->kobj);
725 vlan->kobj = NULL;
726 }
727
batadv_show_mesh_iface(struct kobject * kobj,struct attribute * attr,char * buff)728 static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
729 struct attribute *attr, char *buff)
730 {
731 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
732 struct batadv_hard_iface *hard_iface;
733 ssize_t length;
734 const char *ifname;
735
736 hard_iface = batadv_hardif_get_by_netdev(net_dev);
737 if (!hard_iface)
738 return 0;
739
740 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
741 ifname = "none";
742 else
743 ifname = hard_iface->soft_iface->name;
744
745 length = sprintf(buff, "%s\n", ifname);
746
747 batadv_hardif_free_ref(hard_iface);
748
749 return length;
750 }
751
batadv_store_mesh_iface(struct kobject * kobj,struct attribute * attr,char * buff,size_t count)752 static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
753 struct attribute *attr, char *buff,
754 size_t count)
755 {
756 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
757 struct batadv_hard_iface *hard_iface;
758 int status_tmp = -1;
759 int ret = count;
760
761 hard_iface = batadv_hardif_get_by_netdev(net_dev);
762 if (!hard_iface)
763 return count;
764
765 if (buff[count - 1] == '\n')
766 buff[count - 1] = '\0';
767
768 if (strlen(buff) >= IFNAMSIZ) {
769 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
770 buff);
771 batadv_hardif_free_ref(hard_iface);
772 return -EINVAL;
773 }
774
775 if (strncmp(buff, "none", 4) == 0)
776 status_tmp = BATADV_IF_NOT_IN_USE;
777 else
778 status_tmp = BATADV_IF_I_WANT_YOU;
779
780 if (hard_iface->if_status == status_tmp)
781 goto out;
782
783 if ((hard_iface->soft_iface) &&
784 (strncmp(hard_iface->soft_iface->name, buff, IFNAMSIZ) == 0))
785 goto out;
786
787 rtnl_lock();
788
789 if (status_tmp == BATADV_IF_NOT_IN_USE) {
790 batadv_hardif_disable_interface(hard_iface,
791 BATADV_IF_CLEANUP_AUTO);
792 goto unlock;
793 }
794
795 /* if the interface already is in use */
796 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
797 batadv_hardif_disable_interface(hard_iface,
798 BATADV_IF_CLEANUP_AUTO);
799
800 ret = batadv_hardif_enable_interface(hard_iface, buff);
801
802 unlock:
803 rtnl_unlock();
804 out:
805 batadv_hardif_free_ref(hard_iface);
806 return ret;
807 }
808
batadv_show_iface_status(struct kobject * kobj,struct attribute * attr,char * buff)809 static ssize_t batadv_show_iface_status(struct kobject *kobj,
810 struct attribute *attr, char *buff)
811 {
812 struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
813 struct batadv_hard_iface *hard_iface;
814 ssize_t length;
815
816 hard_iface = batadv_hardif_get_by_netdev(net_dev);
817 if (!hard_iface)
818 return 0;
819
820 switch (hard_iface->if_status) {
821 case BATADV_IF_TO_BE_REMOVED:
822 length = sprintf(buff, "disabling\n");
823 break;
824 case BATADV_IF_INACTIVE:
825 length = sprintf(buff, "inactive\n");
826 break;
827 case BATADV_IF_ACTIVE:
828 length = sprintf(buff, "active\n");
829 break;
830 case BATADV_IF_TO_BE_ACTIVATED:
831 length = sprintf(buff, "enabling\n");
832 break;
833 case BATADV_IF_NOT_IN_USE:
834 default:
835 length = sprintf(buff, "not in use\n");
836 break;
837 }
838
839 batadv_hardif_free_ref(hard_iface);
840
841 return length;
842 }
843
844 static BATADV_ATTR(mesh_iface, S_IRUGO | S_IWUSR, batadv_show_mesh_iface,
845 batadv_store_mesh_iface);
846 static BATADV_ATTR(iface_status, S_IRUGO, batadv_show_iface_status, NULL);
847
848 static struct batadv_attribute *batadv_batman_attrs[] = {
849 &batadv_attr_mesh_iface,
850 &batadv_attr_iface_status,
851 NULL,
852 };
853
batadv_sysfs_add_hardif(struct kobject ** hardif_obj,struct net_device * dev)854 int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
855 {
856 struct kobject *hardif_kobject = &dev->dev.kobj;
857 struct batadv_attribute **bat_attr;
858 int err;
859
860 *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
861 hardif_kobject);
862
863 if (!*hardif_obj) {
864 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
865 BATADV_SYSFS_IF_BAT_SUBDIR);
866 goto out;
867 }
868
869 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
870 err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
871 if (err) {
872 batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
873 dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
874 ((*bat_attr)->attr).name);
875 goto rem_attr;
876 }
877 }
878
879 return 0;
880
881 rem_attr:
882 for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
883 sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
884 out:
885 return -ENOMEM;
886 }
887
batadv_sysfs_del_hardif(struct kobject ** hardif_obj)888 void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
889 {
890 kobject_put(*hardif_obj);
891 *hardif_obj = NULL;
892 }
893
batadv_throw_uevent(struct batadv_priv * bat_priv,enum batadv_uev_type type,enum batadv_uev_action action,const char * data)894 int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
895 enum batadv_uev_action action, const char *data)
896 {
897 int ret = -ENOMEM;
898 struct kobject *bat_kobj;
899 char *uevent_env[4] = { NULL, NULL, NULL, NULL };
900
901 bat_kobj = &bat_priv->soft_iface->dev.kobj;
902
903 uevent_env[0] = kasprintf(GFP_ATOMIC,
904 "%s%s", BATADV_UEV_TYPE_VAR,
905 batadv_uev_type_str[type]);
906 if (!uevent_env[0])
907 goto out;
908
909 uevent_env[1] = kasprintf(GFP_ATOMIC,
910 "%s%s", BATADV_UEV_ACTION_VAR,
911 batadv_uev_action_str[action]);
912 if (!uevent_env[1])
913 goto out;
914
915 /* If the event is DEL, ignore the data field */
916 if (action != BATADV_UEV_DEL) {
917 uevent_env[2] = kasprintf(GFP_ATOMIC,
918 "%s%s", BATADV_UEV_DATA_VAR, data);
919 if (!uevent_env[2])
920 goto out;
921 }
922
923 ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
924 out:
925 kfree(uevent_env[0]);
926 kfree(uevent_env[1]);
927 kfree(uevent_env[2]);
928
929 if (ret)
930 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
931 "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
932 batadv_uev_type_str[type],
933 batadv_uev_action_str[action],
934 (action == BATADV_UEV_DEL ? "NULL" : data), ret);
935 return ret;
936 }
937