drivers/staging/batman-adv/proc.c

   1 /*
   2  * Copyright (C) 2007-2009 B.A.T.M.A.N. contributors:
   3  *
   4  * Marek Lindner, Simon Wunderlich
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of version 2 of the GNU General Public
   8  * License as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA
  19  *
  20  */
  21
  22 #include "main.h"
  23 #include "proc.h"
  24 #include "log.h"
  25 #include "routing.h"
  26 #include "translation-table.h"
  27 #include "hard-interface.h"
  28 #include "types.h"
  29 #include "hash.h"
  30 #include "vis.h"
  31 #include "compat.h"
  32
  33 static uint8_t vis_format = DOT_DRAW;
  34
  35 static struct proc_dir_entry *proc_batman_dir, *proc_interface_file;
  36 static struct proc_dir_entry *proc_orig_interval_file, *proc_originators_file;
  37 static struct proc_dir_entry *proc_log_file, *proc_log_level_file;
  38 static struct proc_dir_entry *proc_transt_local_file;
  39 static struct proc_dir_entry *proc_transt_global_file;
  40 static struct proc_dir_entry *proc_vis_file, *proc_vis_format_file;
  41 static struct proc_dir_entry *proc_aggr_file;
  42
  43 static int proc_interfaces_read(struct seq_file *seq, void *offset)
  44 {
  45         struct batman_if *batman_if;
  46
  47         rcu_read_lock();
  48         list_for_each_entry_rcu(batman_if, &if_list, list) {
  49                 seq_printf(seq, "[%8s] %s %s \n",
  50                            (batman_if->if_active == IF_ACTIVE ?
  51                             "active" : "inactive"),
  52                            batman_if->dev,
  53                            (batman_if->if_active == IF_ACTIVE ?
  54                             batman_if->addr_str : " "));
  55         }
  56         rcu_read_unlock();
  57
  58         return 0;
  59 }
  60
  61 static int proc_interfaces_open(struct inode *inode, struct file *file)
  62 {
  63         return single_open(file, proc_interfaces_read, NULL);
  64 }
  65
  66 static ssize_t proc_interfaces_write(struct file *instance,
  67                                      const char __user *userbuffer,
  68                                      size_t count, loff_t *data)
  69 {
  70         char *if_string, *colon_ptr = NULL, *cr_ptr = NULL;
  71         int not_copied = 0, if_num = 0;
  72         struct batman_if *batman_if = NULL;
  73
  74         if_string = kmalloc(count, GFP_KERNEL);
  75
  76         if (!if_string)
  77                 return -ENOMEM;
  78
  79         if (count > IFNAMSIZ - 1) {
  80                 debug_log(LOG_TYPE_WARN,
  81                           "Can't add interface: device name is too long\n");
  82                 goto end;
  83         }
  84
  85         not_copied = copy_from_user(if_string, userbuffer, count);
  86         if_string[count - not_copied - 1] = 0;
  87
  88         colon_ptr = strchr(if_string, ':');
  89         if (colon_ptr)
  90                 *colon_ptr = 0;
  91
  92         if (!colon_ptr) {
  93                 cr_ptr = strchr(if_string, '\n');
  94                 if (cr_ptr)
  95                         *cr_ptr = 0;
  96         }
  97
  98         if (strlen(if_string) == 0) {
  99                 shutdown_module();
 100                 num_ifs = 0;
 101                 goto end;
 102         }
 103
 104         /* add interface */
 105         rcu_read_lock();
 106         list_for_each_entry_rcu(batman_if, &if_list, list) {
 107                 if (strncmp(batman_if->dev, if_string, count) == 0) {
 108                         debug_log(LOG_TYPE_WARN, "Given interface is already active: %s\n", if_string);
 109                         rcu_read_unlock();
 110                         goto end;
 111
 112                 }
 113
 114                 if_num++;
 115         }
 116         rcu_read_unlock();
 117
 118         hardif_add_interface(if_string, if_num);
 119
 120         if ((atomic_read(&module_state) == MODULE_INACTIVE) &&
 121             (hardif_get_active_if_num() > 0))
 122                 activate_module();
 123
 124         rcu_read_lock();
 125         if (list_empty(&if_list)) {
 126                 rcu_read_unlock();
 127                 goto end;
 128         }
 129         rcu_read_unlock();
 130
 131         num_ifs = if_num + 1;
 132         return count;
 133
 134 end:
 135         kfree(if_string);
 136         return count;
 137 }
 138
 139 static int proc_orig_interval_read(struct seq_file *seq, void *offset)
 140 {
 141         seq_printf(seq, "%i\n", atomic_read(&originator_interval));
 142
 143         return 0;
 144 }
 145
 146 static ssize_t proc_orig_interval_write(struct file *file,
 147                                         const char __user *buffer,
 148                                         size_t count, loff_t *ppos)
 149 {
 150         char *interval_string;
 151         int not_copied = 0;
 152         unsigned long originator_interval_tmp;
 153         int retval;
 154
 155         interval_string = kmalloc(count, GFP_KERNEL);
 156
 157         if (!interval_string)
 158                 return -ENOMEM;
 159
 160         not_copied = copy_from_user(interval_string, buffer, count);
 161         interval_string[count - not_copied - 1] = 0;
 162
 163         retval = strict_strtoul(interval_string, 10, &originator_interval_tmp);
 164         if (retval) {
 165                 debug_log(LOG_TYPE_WARN, "New originator interval invalid\n");
 166                 goto end;
 167         }
 168
 169         if (originator_interval_tmp <= JITTER * 2) {
 170                 debug_log(LOG_TYPE_WARN,
 171                           "New originator interval too small: %i (min: %i)\n",
 172                           originator_interval_tmp, JITTER * 2);
 173                 goto end;
 174         }
 175
 176         debug_log(LOG_TYPE_NOTICE,
 177                   "Changing originator interval from: %i to: %i\n",
 178                   atomic_read(&originator_interval), originator_interval_tmp);
 179
 180         atomic_set(&originator_interval, originator_interval_tmp);
 181
 182 end:
 183         kfree(interval_string);
 184         return count;
 185 }
 186
 187 static int proc_orig_interval_open(struct inode *inode, struct file *file)
 188 {
 189         return single_open(file, proc_orig_interval_read, NULL);
 190 }
 191
 192 static int proc_originators_read(struct seq_file *seq, void *offset)
 193 {
 194         struct hash_it_t *hashit = NULL;
 195         struct orig_node *orig_node;
 196         struct neigh_node *neigh_node;
 197         int batman_count = 0;
 198         char orig_str[ETH_STR_LEN], router_str[ETH_STR_LEN];
 199
 200         rcu_read_lock();
 201         if (list_empty(&if_list)) {
 202                 rcu_read_unlock();
 203                 seq_printf(seq, "BATMAN disabled - please specify interfaces to enable it \n");
 204                 goto end;
 205         }
 206
 207         if (((struct batman_if *)if_list.next)->if_active != IF_ACTIVE) {
 208                 rcu_read_unlock();
 209                 seq_printf(seq, "BATMAN disabled - primary interface not active \n");
 210                 goto end;
 211         }
 212
 213         seq_printf(seq,
 214                    "  %-14s (%s/%i) %17s [%10s]: %20s ... [B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%s] \n",
 215                    "Originator", "#", TQ_MAX_VALUE, "Nexthop", "outgoingIF",
 216                    "Potential nexthops", SOURCE_VERSION, REVISION_VERSION_STR,
 217                    ((struct batman_if *)if_list.next)->dev,
 218                    ((struct batman_if *)if_list.next)->addr_str);
 219
 220         rcu_read_unlock();
 221         spin_lock(&orig_hash_lock);
 222
 223         while (NULL != (hashit = hash_iterate(orig_hash, hashit))) {
 224
 225                 orig_node = hashit->bucket->data;
 226
 227                 if (!orig_node->router)
 228                         continue;
 229
 230                 if (orig_node->router->tq_avg == 0)
 231                         continue;
 232
 233                 batman_count++;
 234
 235                 addr_to_string(orig_str, orig_node->orig);
 236                 addr_to_string(router_str, orig_node->router->addr);
 237
 238                 seq_printf(seq, "%-17s  (%3i) %17s [%10s]:",
 239                            orig_str, orig_node->router->tq_avg,
 240                            router_str, orig_node->router->if_incoming->dev);
 241
 242                 list_for_each_entry(neigh_node, &orig_node->neigh_list, list) {
 243                         addr_to_string(orig_str, neigh_node->addr);
 244                         seq_printf(seq, " %17s (%3i)",
 245                                    orig_str, neigh_node->tq_avg);
 246                 }
 247
 248                 seq_printf(seq, "\n");
 249
 250         }
 251
 252         spin_unlock(&orig_hash_lock);
 253
 254         if (batman_count == 0)
 255                 seq_printf(seq, "No batman nodes in range ... \n");
 256
 257 end:
 258         return 0;
 259 }
 260
 261 static int proc_originators_open(struct inode *inode, struct file *file)
 262 {
 263         return single_open(file, proc_originators_read, NULL);
 264 }
 265
 266 static int proc_log_level_read(struct seq_file *seq, void *offset)
 267 {
 268
 269         seq_printf(seq, "[x] %s (%d)\n", LOG_TYPE_CRIT_NAME, LOG_TYPE_CRIT);
 270         seq_printf(seq, "[%c] %s (%d)\n",
 271                    (LOG_TYPE_WARN & log_level) ? 'x' : ' ',
 272                    LOG_TYPE_WARN_NAME, LOG_TYPE_WARN);
 273         seq_printf(seq, "[%c] %s (%d)\n",
 274                    (LOG_TYPE_NOTICE & log_level) ? 'x' : ' ',
 275                    LOG_TYPE_NOTICE_NAME, LOG_TYPE_NOTICE);
 276         seq_printf(seq, "[%c] %s (%d)\n",
 277                    (LOG_TYPE_BATMAN & log_level) ? 'x' : ' ',
 278                    LOG_TYPE_BATMAN_NAME, LOG_TYPE_BATMAN);
 279         seq_printf(seq, "[%c] %s (%d)\n",
 280                    (LOG_TYPE_ROUTES & log_level) ? 'x' : ' ',
 281                    LOG_TYPE_ROUTES_NAME, LOG_TYPE_ROUTES);
 282         return 0;
 283 }
 284
 285 static int proc_log_level_open(struct inode *inode, struct file *file)
 286 {
 287         return single_open(file, proc_log_level_read, NULL);
 288 }
 289
 290 static ssize_t proc_log_level_write(struct file *instance,
 291                                     const char __user *userbuffer,
 292                                     size_t count, loff_t *data)
 293 {
 294         char *log_level_string, *tokptr, *cp;
 295         int finished, not_copied = 0;
 296         unsigned long log_level_tmp = 0;
 297
 298         log_level_string = kmalloc(count, GFP_KERNEL);
 299
 300         if (!log_level_string)
 301                 return -ENOMEM;
 302
 303         not_copied = copy_from_user(log_level_string, userbuffer, count);
 304         log_level_string[count - not_copied - 1] = 0;
 305
 306         if (strict_strtoul(log_level_string, 10, &log_level_tmp) < 0) {
 307                 /* was not a number, doing textual parsing */
 308                 log_level_tmp = 0;
 309                 tokptr = log_level_string;
 310
 311                 for (cp = log_level_string, finished = 0; !finished; cp++) {
 312                         switch (*cp) {
 313                         case 0:
 314                                 finished = 1;
 315                         case ' ':
 316                         case '\n':
 317                         case '\t':
 318                                 *cp = 0;
 319                                 /* compare */
 320                                 if (strcmp(tokptr, LOG_TYPE_WARN_NAME) == 0)
 321                                         log_level_tmp |= LOG_TYPE_WARN;
 322                                 if (strcmp(tokptr, LOG_TYPE_NOTICE_NAME) == 0)
 323                                         log_level_tmp |= LOG_TYPE_NOTICE;
 324                                 if (strcmp(tokptr, LOG_TYPE_BATMAN_NAME) == 0)
 325                                         log_level_tmp |= LOG_TYPE_BATMAN;
 326                                 if (strcmp(tokptr, LOG_TYPE_ROUTES_NAME) == 0)
 327                                         log_level_tmp |= LOG_TYPE_ROUTES;
 328                                 tokptr = cp + 1;
 329                                 break;
 330                         default:
 331                                 ;
 332                         }
 333                 }
 334         }
 335
 336         debug_log(LOG_TYPE_CRIT, "Changing log_level from: %i to: %i\n",
 337                   log_level, log_level_tmp);
 338         log_level = log_level_tmp;
 339
 340         kfree(log_level_string);
 341         return count;
 342 }
 343
 344 static int proc_transt_local_read(struct seq_file *seq, void *offset)
 345 {
 346         char *buf;
 347
 348         buf = kmalloc(4096, GFP_KERNEL);
 349         if (!buf)
 350                 return 0;
 351
 352         rcu_read_lock();
 353         if (list_empty(&if_list)) {
 354                 rcu_read_unlock();
 355                 seq_printf(seq, "BATMAN disabled - please specify interfaces to enable it \n");
 356                 goto end;
 357         }
 358
 359         rcu_read_unlock();
 360
 361         seq_printf(seq, "Locally retrieved addresses (from %s) announced via HNA:\n", soft_device->name);
 362
 363         hna_local_fill_buffer_text(buf, 4096);
 364         seq_printf(seq, "%s", buf);
 365
 366 end:
 367         kfree(buf);
 368         return 0;
 369 }
 370
 371 static int proc_transt_local_open(struct inode *inode, struct file *file)
 372 {
 373         return single_open(file, proc_transt_local_read, NULL);
 374 }
 375
 376 static int proc_transt_global_read(struct seq_file *seq, void *offset)
 377 {
 378         char *buf;
 379
 380         buf = kmalloc(4096, GFP_KERNEL);
 381         if (!buf)
 382                 return 0;
 383
 384         rcu_read_lock();
 385         if (list_empty(&if_list)) {
 386                 rcu_read_unlock();
 387                 seq_printf(seq, "BATMAN disabled - please specify interfaces to enable it \n");
 388                 goto end;
 389         }
 390         rcu_read_unlock();
 391
 392
 393         seq_printf(seq, "Globally announced HNAs received via the mesh (translation table):\n");
 394
 395         hna_global_fill_buffer_text(buf, 4096);
 396         seq_printf(seq, "%s", buf);
 397
 398 end:
 399         kfree(buf);
 400         return 0;
 401 }
 402
 403 static int proc_transt_global_open(struct inode *inode, struct file *file)
 404 {
 405         return single_open(file, proc_transt_global_read, NULL);
 406 }
 407
 408 /* insert interface to the list of interfaces of one originator */
 409
 410 static void proc_vis_insert_interface(const uint8_t *interface,
 411                                       struct vis_if_list **if_entry,
 412                                       bool primary)
 413 {
 414         /* Did we get an empty list? (then insert imediately) */
 415         if(*if_entry == NULL) {
 416                 *if_entry = kmalloc(sizeof(struct vis_if_list), GFP_KERNEL);
 417                 if (*if_entry == NULL)
 418                         return;
 419
 420                 (*if_entry)->primary = primary;
 421                 (*if_entry)->next = NULL;
 422                 memcpy((*if_entry)->addr, interface, ETH_ALEN);
 423         } else {
 424                 struct vis_if_list *head_if_entry = *if_entry;
 425                 /* Do we already have this interface in our list? */
 426                 while (!compare_orig((*if_entry)->addr, (void *)interface)) {
 427
 428                         /* Or did we reach the end (then append the interface) */
 429                         if ((*if_entry)->next == NULL) {
 430                                 (*if_entry)->next = kmalloc(sizeof(struct vis_if_list), GFP_KERNEL);
 431                                 if ((*if_entry)->next == NULL)
 432                                         return;
 433
 434                                 memcpy((*if_entry)->next->addr, interface, ETH_ALEN);
 435                                 (*if_entry)->next->primary = primary;
 436                                 (*if_entry)->next->next = NULL;
 437                                 break;
 438                         }
 439                         *if_entry = (*if_entry)->next;
 440                 }
 441                 /* Rewind the list to its head */
 442                 *if_entry = head_if_entry;
 443         }
 444 }
 445 /* read an entry  */
 446
 447 static void proc_vis_read_entry(struct seq_file *seq,
 448                                 struct vis_info_entry *entry,
 449                                 struct vis_if_list **if_entry,
 450                                 uint8_t *vis_orig,
 451                                 uint8_t current_format,
 452                                 uint8_t first_line)
 453 {
 454         char from[40];
 455         char to[40];
 456         int int_part, frac_part;
 457
 458         addr_to_string(to, entry->dest);
 459         if (entry->quality == 0) {
 460 #ifndef VIS_SUBCLUSTERS_DISABLED
 461                 proc_vis_insert_interface(vis_orig, if_entry, true);
 462 #endif /* VIS_SUBCLUSTERS_DISABLED */
 463                 addr_to_string(from, vis_orig);
 464                 if (current_format == DOT_DRAW) {
 465                         seq_printf(seq, "\t\"%s\" -> \"%s\" [label=\"HNA\"]\n",
 466                                    from, to);
 467                 } else {
 468                         seq_printf(seq,
 469                                    "%s\t{ router : \"%s\", gateway   : \"%s\", label : \"HNA\" }",
 470                                    (first_line ? "" : ",\n"), from, to);
 471                 }
 472         } else {
 473 #ifndef VIS_SUBCLUSTERS_DISABLED
 474                 proc_vis_insert_interface(entry->src, if_entry, compare_orig(entry->src, vis_orig));
 475 #endif /* VIS_SUBCLUSTERS_DISABLED */
 476                 addr_to_string(from, entry->src);
 477
 478                 /* kernel has no printf-support for %f? it'd be better to return
 479                  * this in float. */
 480
 481                 int_part = TQ_MAX_VALUE / entry->quality;
 482                 frac_part = 1000 * TQ_MAX_VALUE / entry->quality - int_part * 1000;
 483
 484                 if (current_format == DOT_DRAW) {
 485                         seq_printf(seq,
 486                                    "\t\"%s\" -> \"%s\" [label=\"%d.%d\"]\n",
 487                                    from, to, int_part, frac_part);
 488                 } else {
 489                         seq_printf(seq,
 490                                    "%s\t{ router : \"%s\", neighbour : \"%s\", label : %d.%d }",
 491                                    (first_line ? "" : ",\n"), from, to, int_part, frac_part);
 492                 }
 493         }
 494 }
 495
 496
 497 static int proc_vis_read(struct seq_file *seq, void *offset)
 498 {
 499         struct hash_it_t *hashit = NULL;
 500         struct vis_info *info;
 501         struct vis_info_entry *entries;
 502         struct vis_if_list *if_entries = NULL;
 503         int i;
 504         uint8_t current_format, first_line = 1;
 505 #ifndef VIS_SUBCLUSTERS_DISABLED
 506         char tmp_addr_str[ETH_STR_LEN];
 507         struct vis_if_list *tmp_if_next;
 508 #endif /* VIS_SUBCLUSTERS_DISABLED */
 509
 510         current_format = vis_format;
 511
 512         rcu_read_lock();
 513         if (list_empty(&if_list) || (!is_vis_server())) {
 514                 rcu_read_unlock();
 515                 if (current_format == DOT_DRAW)
 516                         seq_printf(seq, "digraph {\n}\n");
 517                 goto end;
 518         }
 519
 520         rcu_read_unlock();
 521
 522         if (current_format == DOT_DRAW)
 523                 seq_printf(seq, "digraph {\n");
 524
 525         spin_lock(&vis_hash_lock);
 526         while (NULL != (hashit = hash_iterate(vis_hash, hashit))) {
 527                 info = hashit->bucket->data;
 528                 entries = (struct vis_info_entry *)
 529                         ((char *)info + sizeof(struct vis_info));
 530
 531                 for (i = 0; i < info->packet.entries; i++) {
 532                         proc_vis_read_entry(seq, &entries[i], &if_entries,
 533                                             info->packet.vis_orig,
 534                                             current_format, first_line);
 535                         if (first_line)
 536                                 first_line = 0;
 537                 }
 538
 539 #ifndef VIS_SUBCLUSTERS_DISABLED
 540                 /* Generate subgraphs from the collected items */
 541                 if (current_format == DOT_DRAW) {
 542
 543                         addr_to_string(tmp_addr_str, info->packet.vis_orig);
 544                         seq_printf(seq, "\tsubgraph \"cluster_%s\" {\n", tmp_addr_str);
 545                         while (if_entries != NULL) {
 546
 547                                 addr_to_string(tmp_addr_str, if_entries->addr);
 548                                 if (if_entries->primary)
 549                                         seq_printf(seq, "\t\t\"%s\" [peripheries=2]\n", tmp_addr_str);
 550                                 else
 551                                         seq_printf(seq, "\t\t\"%s\"\n", tmp_addr_str);
 552
 553                                 /* ... and empty the list while doing this */
 554                                 tmp_if_next = if_entries->next;
 555                                 kfree(if_entries);
 556                                 if_entries = tmp_if_next;
 557                         }
 558                         seq_printf(seq, "\t}\n");
 559                 }
 560 #endif /* VIS_SUBCLUSTERS_DISABLED */
 561         }
 562         spin_unlock(&vis_hash_lock);
 563
 564         if (current_format == DOT_DRAW)
 565                 seq_printf(seq, "}\n");
 566         else
 567                 seq_printf(seq, "\n");
 568 end:
 569         return 0;
 570 }
 571
 572 /* setting the mode of the vis server by the user */
 573 static ssize_t proc_vis_write(struct file *file, const char __user * buffer,
 574                               size_t count, loff_t *ppos)
 575 {
 576         char *vis_mode_string;
 577         int not_copied = 0;
 578
 579         vis_mode_string = kmalloc(count, GFP_KERNEL);
 580
 581         if (!vis_mode_string)
 582                 return -ENOMEM;
 583
 584         not_copied = copy_from_user(vis_mode_string, buffer, count);
 585         vis_mode_string[count - not_copied - 1] = 0;
 586
 587         if (strcmp(vis_mode_string, "client") == 0) {
 588                 debug_log(LOG_TYPE_NOTICE, "Setting VIS mode to client\n");
 589                 vis_set_mode(VIS_TYPE_CLIENT_UPDATE);
 590         } else if (strcmp(vis_mode_string, "server") == 0) {
 591                 debug_log(LOG_TYPE_NOTICE, "Setting VIS mode to server\n");
 592                 vis_set_mode(VIS_TYPE_SERVER_SYNC);
 593         } else
 594                 debug_log(LOG_TYPE_WARN, "Unknown VIS mode: %s\n",
 595                           vis_mode_string);
 596
 597         kfree(vis_mode_string);
 598         return count;
 599 }
 600
 601 static int proc_vis_open(struct inode *inode, struct file *file)
 602 {
 603         return single_open(file, proc_vis_read, NULL);
 604 }
 605
 606 static int proc_vis_format_read(struct seq_file *seq, void *offset)
 607 {
 608         uint8_t current_format = vis_format;
 609
 610         seq_printf(seq, "[%c] %s\n",
 611                    (current_format == DOT_DRAW) ? 'x' : ' ',
 612                    VIS_FORMAT_DD_NAME);
 613         seq_printf(seq, "[%c] %s\n",
 614                    (current_format == JSON) ? 'x' : ' ',
 615                    VIS_FORMAT_JSON_NAME);
 616         return 0;
 617 }
 618
 619 static int proc_vis_format_open(struct inode *inode, struct file *file)
 620 {
 621         return single_open(file, proc_vis_format_read, NULL);
 622 }
 623
 624 static ssize_t proc_vis_format_write(struct file *file,
 625                                      const char __user *buffer,
 626                                      size_t count, loff_t *ppos)
 627 {
 628         char *vis_format_string;
 629         int not_copied = 0;
 630
 631         vis_format_string = kmalloc(count, GFP_KERNEL);
 632
 633         if (!vis_format_string)
 634                 return -ENOMEM;
 635
 636         not_copied = copy_from_user(vis_format_string, buffer, count);
 637         vis_format_string[count - not_copied - 1] = 0;
 638
 639         if (strcmp(vis_format_string, VIS_FORMAT_DD_NAME) == 0) {
 640                 debug_log(LOG_TYPE_NOTICE, "Setting VIS output format to: %s\n",
 641                           VIS_FORMAT_DD_NAME);
 642                 vis_format = DOT_DRAW;
 643         } else if (strcmp(vis_format_string, VIS_FORMAT_JSON_NAME) == 0) {
 644                 debug_log(LOG_TYPE_NOTICE, "Setting VIS output format to: %s\n",
 645                           VIS_FORMAT_JSON_NAME);
 646                 vis_format = JSON;
 647         } else
 648                 debug_log(LOG_TYPE_WARN, "Unknown VIS output format: %s\n",
 649                           vis_format_string);
 650
 651         kfree(vis_format_string);
 652         return count;
 653 }
 654
 655 static int proc_aggr_read(struct seq_file *seq, void *offset)
 656 {
 657         seq_printf(seq, "%i\n", atomic_read(&aggregation_enabled));
 658
 659         return 0;
 660 }
 661
 662 static ssize_t proc_aggr_write(struct file *file, const char __user *buffer,
 663                                size_t count, loff_t *ppos)
 664 {
 665         char *aggr_string;
 666         int not_copied = 0;
 667         unsigned long aggregation_enabled_tmp;
 668
 669         aggr_string = kmalloc(count, GFP_KERNEL);
 670
 671         if (!aggr_string)
 672                 return -ENOMEM;
 673
 674         not_copied = copy_from_user(aggr_string, buffer, count);
 675         aggr_string[count - not_copied - 1] = 0;
 676
 677         strict_strtoul(aggr_string, 10, &aggregation_enabled_tmp);
 678
 679         if ((aggregation_enabled_tmp != 0) && (aggregation_enabled_tmp != 1)) {
 680                 debug_log(LOG_TYPE_WARN, "Aggregation can only be enabled (1) or disabled (0), given value: %li\n", aggregation_enabled_tmp);
 681                 goto end;
 682         }
 683
 684         debug_log(LOG_TYPE_NOTICE, "Changing aggregation from: %s (%i) to: %s (%li)\n",
 685                   (atomic_read(&aggregation_enabled) == 1 ?
 686                    "enabled" : "disabled"),
 687                   atomic_read(&aggregation_enabled),
 688                   (aggregation_enabled_tmp == 1 ? "enabled" : "disabled"),
 689                   aggregation_enabled_tmp);
 690
 691         atomic_set(&aggregation_enabled, (unsigned)aggregation_enabled_tmp);
 692 end:
 693         kfree(aggr_string);
 694         return count;
 695 }
 696
 697 static int proc_aggr_open(struct inode *inode, struct file *file)
 698 {
 699         return single_open(file, proc_aggr_read, NULL);
 700 }
 701
 702 /* satisfying different prototypes ... */
 703 static ssize_t proc_dummy_write(struct file *file, const char __user *buffer,
 704                                 size_t count, loff_t *ppos)
 705 {
 706         return count;
 707 }
 708
 709 static const struct file_operations proc_aggr_fops = {
 710         .owner          = THIS_MODULE,
 711         .open           = proc_aggr_open,
 712         .read           = seq_read,
 713         .write          = proc_aggr_write,
 714         .llseek         = seq_lseek,
 715         .release        = single_release,
 716 };
 717
 718 static const struct file_operations proc_vis_format_fops = {
 719         .owner          = THIS_MODULE,
 720         .open           = proc_vis_format_open,
 721         .read           = seq_read,
 722         .write          = proc_vis_format_write,
 723         .llseek         = seq_lseek,
 724         .release        = single_release,
 725 };
 726
 727 static const struct file_operations proc_vis_fops = {
 728         .owner          = THIS_MODULE,
 729         .open           = proc_vis_open,
 730         .read           = seq_read,
 731         .write          = proc_vis_write,
 732         .llseek         = seq_lseek,
 733         .release        = single_release,
 734 };
 735
 736 static const struct file_operations proc_originators_fops = {
 737         .owner          = THIS_MODULE,
 738         .open           = proc_originators_open,
 739         .read           = seq_read,
 740         .write          = proc_dummy_write,
 741         .llseek         = seq_lseek,
 742         .release        = single_release,
 743 };
 744
 745 static const struct file_operations proc_transt_local_fops = {
 746         .owner          = THIS_MODULE,
 747         .open           = proc_transt_local_open,
 748         .read           = seq_read,
 749         .write          = proc_dummy_write,
 750         .llseek         = seq_lseek,
 751         .release        = single_release,
 752 };
 753
 754 static const struct file_operations proc_transt_global_fops = {
 755         .owner          = THIS_MODULE,
 756         .open           = proc_transt_global_open,
 757         .read           = seq_read,
 758         .write          = proc_dummy_write,
 759         .llseek         = seq_lseek,
 760         .release        = single_release,
 761 };
 762
 763 static const struct file_operations proc_log_level_fops = {
 764         .owner          = THIS_MODULE,
 765         .open           = proc_log_level_open,
 766         .read           = seq_read,
 767         .write          = proc_log_level_write,
 768         .llseek         = seq_lseek,
 769         .release        = single_release,
 770 };
 771
 772 static const struct file_operations proc_interfaces_fops = {
 773         .owner          = THIS_MODULE,
 774         .open           = proc_interfaces_open,
 775         .read           = seq_read,
 776         .write          = proc_interfaces_write,
 777         .llseek         = seq_lseek,
 778         .release        = single_release,
 779 };
 780
 781 static const struct file_operations proc_orig_interval_fops = {
 782         .owner          = THIS_MODULE,
 783         .open           = proc_orig_interval_open,
 784         .read           = seq_read,
 785         .write          = proc_orig_interval_write,
 786         .llseek         = seq_lseek,
 787         .release        = single_release,
 788 };
 789
 790 void cleanup_procfs(void)
 791 {
 792         if (proc_transt_global_file)
 793                 remove_proc_entry(PROC_FILE_TRANST_GLOBAL, proc_batman_dir);
 794
 795         if (proc_transt_local_file)
 796                 remove_proc_entry(PROC_FILE_TRANST_LOCAL, proc_batman_dir);
 797
 798         if (proc_log_file)
 799                 remove_proc_entry(PROC_FILE_LOG, proc_batman_dir);
 800
 801         if (proc_log_level_file)
 802                 remove_proc_entry(PROC_FILE_LOG_LEVEL, proc_batman_dir);
 803
 804         if (proc_originators_file)
 805                 remove_proc_entry(PROC_FILE_ORIGINATORS, proc_batman_dir);
 806
 807         if (proc_orig_interval_file)
 808                 remove_proc_entry(PROC_FILE_ORIG_INTERVAL, proc_batman_dir);
 809
 810         if (proc_interface_file)
 811                 remove_proc_entry(PROC_FILE_INTERFACES, proc_batman_dir);
 812
 813         if (proc_vis_file)
 814                 remove_proc_entry(PROC_FILE_VIS, proc_batman_dir);
 815
 816         if (proc_vis_format_file)
 817                 remove_proc_entry(PROC_FILE_VIS_FORMAT, proc_batman_dir);
 818
 819         if (proc_aggr_file)
 820                 remove_proc_entry(PROC_FILE_AGGR, proc_batman_dir);
 821
 822         if (proc_batman_dir)
 823 #ifdef __NET_NET_NAMESPACE_H
 824                 remove_proc_entry(PROC_ROOT_DIR, init_net.proc_net);
 825 #else
 826                 remove_proc_entry(PROC_ROOT_DIR, proc_net);
 827 #endif
 828 }
 829
 830 int setup_procfs(void)
 831 {
 832 #ifdef __NET_NET_NAMESPACE_H
 833         proc_batman_dir = proc_mkdir(PROC_ROOT_DIR, init_net.proc_net);
 834 #else
 835         proc_batman_dir = proc_mkdir(PROC_ROOT_DIR, proc_net);
 836 #endif
 837
 838         if (!proc_batman_dir) {
 839                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s' folder failed\n", PROC_ROOT_DIR);
 840                 return -EFAULT;
 841         }
 842
 843         proc_interface_file = create_proc_entry(PROC_FILE_INTERFACES,
 844                                                 S_IWUSR | S_IRUGO,
 845                                                 proc_batman_dir);
 846         if (proc_interface_file) {
 847                 proc_interface_file->proc_fops = &proc_interfaces_fops;
 848         } else {
 849                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_INTERFACES);
 850                 cleanup_procfs();
 851                 return -EFAULT;
 852         }
 853
 854         proc_orig_interval_file = create_proc_entry(PROC_FILE_ORIG_INTERVAL,
 855                                                     S_IWUSR | S_IRUGO,
 856                                                     proc_batman_dir);
 857         if (proc_orig_interval_file) {
 858                 proc_orig_interval_file->proc_fops = &proc_orig_interval_fops;
 859         } else {
 860                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_ORIG_INTERVAL);
 861                 cleanup_procfs();
 862                 return -EFAULT;
 863         }
 864
 865         proc_log_level_file = create_proc_entry(PROC_FILE_LOG_LEVEL,
 866                                                 S_IWUSR | S_IRUGO,
 867                                                 proc_batman_dir);
 868         if (proc_log_level_file) {
 869                 proc_log_level_file->proc_fops = &proc_log_level_fops;
 870         } else {
 871                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_LOG_LEVEL);
 872                 cleanup_procfs();
 873                 return -EFAULT;
 874         }
 875
 876         proc_originators_file = create_proc_entry(PROC_FILE_ORIGINATORS,
 877                                                   S_IRUGO, proc_batman_dir);
 878         if (proc_originators_file) {
 879                 proc_originators_file->proc_fops = &proc_originators_fops;
 880         } else {
 881                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_ORIGINATORS);
 882                 cleanup_procfs();
 883                 return -EFAULT;
 884         }
 885
 886         proc_log_file = create_proc_entry(PROC_FILE_LOG,
 887                                           S_IRUGO, proc_batman_dir);
 888         if (proc_log_file) {
 889                 proc_log_file->proc_fops = &proc_log_operations;
 890         } else {
 891                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_FILE_LOG, PROC_FILE_GATEWAYS);
 892                 cleanup_procfs();
 893                 return -EFAULT;
 894         }
 895
 896         proc_transt_local_file = create_proc_entry(PROC_FILE_TRANST_LOCAL,
 897                                                    S_IRUGO, proc_batman_dir);
 898         if (proc_transt_local_file) {
 899                 proc_transt_local_file->proc_fops = &proc_transt_local_fops;
 900         } else {
 901                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_TRANST_LOCAL);
 902                 cleanup_procfs();
 903                 return -EFAULT;
 904         }
 905
 906         proc_transt_global_file = create_proc_entry(PROC_FILE_TRANST_GLOBAL,
 907                                                     S_IRUGO, proc_batman_dir);
 908         if (proc_transt_global_file) {
 909                 proc_transt_global_file->proc_fops = &proc_transt_global_fops;
 910         } else {
 911                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_TRANST_GLOBAL);
 912                 cleanup_procfs();
 913                 return -EFAULT;
 914         }
 915
 916         proc_vis_file = create_proc_entry(PROC_FILE_VIS, S_IWUSR | S_IRUGO,
 917                                           proc_batman_dir);
 918         if (proc_vis_file) {
 919                 proc_vis_file->proc_fops = &proc_vis_fops;
 920         } else {
 921                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_VIS);
 922                 cleanup_procfs();
 923                 return -EFAULT;
 924         }
 925
 926         proc_vis_format_file = create_proc_entry(PROC_FILE_VIS_FORMAT,
 927                                                  S_IWUSR | S_IRUGO,
 928                                                  proc_batman_dir);
 929         if (proc_vis_format_file) {
 930                 proc_vis_format_file->proc_fops = &proc_vis_format_fops;
 931         } else {
 932                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_VIS_FORMAT);
 933                 cleanup_procfs();
 934                 return -EFAULT;
 935         }
 936
 937         proc_aggr_file = create_proc_entry(PROC_FILE_AGGR, S_IWUSR | S_IRUGO,
 938                                            proc_batman_dir);
 939         if (proc_aggr_file) {
 940                 proc_aggr_file->proc_fops = &proc_aggr_fops;
 941         } else {
 942                 printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_AGGR);
 943                 cleanup_procfs();
 944                 return -EFAULT;
 945         }
 946
 947         return 0;
 948 }
 949
 950