linux/net/can/proc.c
<<
>>
Prefs
   1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
   2/*
   3 * proc.c - procfs support for Protocol family CAN core module
   4 *
   5 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
   6 * All rights reserved.
   7 *
   8 * Redistribution and use in source and binary forms, with or without
   9 * modification, are permitted provided that the following conditions
  10 * are met:
  11 * 1. Redistributions of source code must retain the above copyright
  12 *    notice, this list of conditions and the following disclaimer.
  13 * 2. Redistributions in binary form must reproduce the above copyright
  14 *    notice, this list of conditions and the following disclaimer in the
  15 *    documentation and/or other materials provided with the distribution.
  16 * 3. Neither the name of Volkswagen nor the names of its contributors
  17 *    may be used to endorse or promote products derived from this software
  18 *    without specific prior written permission.
  19 *
  20 * Alternatively, provided that this notice is retained in full, this
  21 * software may be distributed under the terms of the GNU General
  22 * Public License ("GPL") version 2, in which case the provisions of the
  23 * GPL apply INSTEAD OF those given above.
  24 *
  25 * The provided data structures and external interfaces from this code
  26 * are not restricted to be used by modules with a GPL compatible license.
  27 *
  28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  39 * DAMAGE.
  40 *
  41 */
  42
  43#include <linux/module.h>
  44#include <linux/proc_fs.h>
  45#include <linux/list.h>
  46#include <linux/rcupdate.h>
  47#include <linux/if_arp.h>
  48#include <linux/can/can-ml.h>
  49#include <linux/can/core.h>
  50
  51#include "af_can.h"
  52
  53/*
  54 * proc filenames for the PF_CAN core
  55 */
  56
  57#define CAN_PROC_STATS       "stats"
  58#define CAN_PROC_RESET_STATS "reset_stats"
  59#define CAN_PROC_RCVLIST_ALL "rcvlist_all"
  60#define CAN_PROC_RCVLIST_FIL "rcvlist_fil"
  61#define CAN_PROC_RCVLIST_INV "rcvlist_inv"
  62#define CAN_PROC_RCVLIST_SFF "rcvlist_sff"
  63#define CAN_PROC_RCVLIST_EFF "rcvlist_eff"
  64#define CAN_PROC_RCVLIST_ERR "rcvlist_err"
  65
  66static int user_reset;
  67
  68static const char rx_list_name[][8] = {
  69        [RX_ERR] = "rx_err",
  70        [RX_ALL] = "rx_all",
  71        [RX_FIL] = "rx_fil",
  72        [RX_INV] = "rx_inv",
  73};
  74
  75/*
  76 * af_can statistics stuff
  77 */
  78
  79static void can_init_stats(struct net *net)
  80{
  81        struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
  82        struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
  83        /*
  84         * This memset function is called from a timer context (when
  85         * can_stattimer is active which is the default) OR in a process
  86         * context (reading the proc_fs when can_stattimer is disabled).
  87         */
  88        memset(pkg_stats, 0, sizeof(struct can_pkg_stats));
  89        pkg_stats->jiffies_init = jiffies;
  90
  91        rcv_lists_stats->stats_reset++;
  92
  93        if (user_reset) {
  94                user_reset = 0;
  95                rcv_lists_stats->user_reset++;
  96        }
  97}
  98
  99static unsigned long calc_rate(unsigned long oldjif, unsigned long newjif,
 100                               unsigned long count)
 101{
 102        unsigned long rate;
 103
 104        if (oldjif == newjif)
 105                return 0;
 106
 107        /* see can_stat_update() - this should NEVER happen! */
 108        if (count > (ULONG_MAX / HZ)) {
 109                printk(KERN_ERR "can: calc_rate: count exceeded! %ld\n",
 110                       count);
 111                return 99999999;
 112        }
 113
 114        rate = (count * HZ) / (newjif - oldjif);
 115
 116        return rate;
 117}
 118
 119void can_stat_update(struct timer_list *t)
 120{
 121        struct net *net = from_timer(net, t, can.stattimer);
 122        struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
 123        unsigned long j = jiffies; /* snapshot */
 124
 125        /* restart counting in timer context on user request */
 126        if (user_reset)
 127                can_init_stats(net);
 128
 129        /* restart counting on jiffies overflow */
 130        if (j < pkg_stats->jiffies_init)
 131                can_init_stats(net);
 132
 133        /* prevent overflow in calc_rate() */
 134        if (pkg_stats->rx_frames > (ULONG_MAX / HZ))
 135                can_init_stats(net);
 136
 137        /* prevent overflow in calc_rate() */
 138        if (pkg_stats->tx_frames > (ULONG_MAX / HZ))
 139                can_init_stats(net);
 140
 141        /* matches overflow - very improbable */
 142        if (pkg_stats->matches > (ULONG_MAX / 100))
 143                can_init_stats(net);
 144
 145        /* calc total values */
 146        if (pkg_stats->rx_frames)
 147                pkg_stats->total_rx_match_ratio = (pkg_stats->matches * 100) /
 148                        pkg_stats->rx_frames;
 149
 150        pkg_stats->total_tx_rate = calc_rate(pkg_stats->jiffies_init, j,
 151                                            pkg_stats->tx_frames);
 152        pkg_stats->total_rx_rate = calc_rate(pkg_stats->jiffies_init, j,
 153                                            pkg_stats->rx_frames);
 154
 155        /* calc current values */
 156        if (pkg_stats->rx_frames_delta)
 157                pkg_stats->current_rx_match_ratio =
 158                        (pkg_stats->matches_delta * 100) /
 159                        pkg_stats->rx_frames_delta;
 160
 161        pkg_stats->current_tx_rate = calc_rate(0, HZ, pkg_stats->tx_frames_delta);
 162        pkg_stats->current_rx_rate = calc_rate(0, HZ, pkg_stats->rx_frames_delta);
 163
 164        /* check / update maximum values */
 165        if (pkg_stats->max_tx_rate < pkg_stats->current_tx_rate)
 166                pkg_stats->max_tx_rate = pkg_stats->current_tx_rate;
 167
 168        if (pkg_stats->max_rx_rate < pkg_stats->current_rx_rate)
 169                pkg_stats->max_rx_rate = pkg_stats->current_rx_rate;
 170
 171        if (pkg_stats->max_rx_match_ratio < pkg_stats->current_rx_match_ratio)
 172                pkg_stats->max_rx_match_ratio = pkg_stats->current_rx_match_ratio;
 173
 174        /* clear values for 'current rate' calculation */
 175        pkg_stats->tx_frames_delta = 0;
 176        pkg_stats->rx_frames_delta = 0;
 177        pkg_stats->matches_delta   = 0;
 178
 179        /* restart timer (one second) */
 180        mod_timer(&net->can.stattimer, round_jiffies(jiffies + HZ));
 181}
 182
 183/*
 184 * proc read functions
 185 */
 186
 187static void can_print_rcvlist(struct seq_file *m, struct hlist_head *rx_list,
 188                              struct net_device *dev)
 189{
 190        struct receiver *r;
 191
 192        hlist_for_each_entry_rcu(r, rx_list, list) {
 193                char *fmt = (r->can_id & CAN_EFF_FLAG)?
 194                        "   %-5s  %08x  %08x  %pK  %pK  %8ld  %s\n" :
 195                        "   %-5s     %03x    %08x  %pK  %pK  %8ld  %s\n";
 196
 197                seq_printf(m, fmt, DNAME(dev), r->can_id, r->mask,
 198                                r->func, r->data, r->matches, r->ident);
 199        }
 200}
 201
 202static void can_print_recv_banner(struct seq_file *m)
 203{
 204        /*
 205         *                  can1.  00000000  00000000  00000000
 206         *                 .......          0  tp20
 207         */
 208        seq_puts(m, "  device   can_id   can_mask  function"
 209                        "  userdata   matches  ident\n");
 210}
 211
 212static int can_stats_proc_show(struct seq_file *m, void *v)
 213{
 214        struct net *net = m->private;
 215        struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
 216        struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
 217
 218        seq_putc(m, '\n');
 219        seq_printf(m, " %8ld transmitted frames (TXF)\n", pkg_stats->tx_frames);
 220        seq_printf(m, " %8ld received frames (RXF)\n", pkg_stats->rx_frames);
 221        seq_printf(m, " %8ld matched frames (RXMF)\n", pkg_stats->matches);
 222
 223        seq_putc(m, '\n');
 224
 225        if (net->can.stattimer.function == can_stat_update) {
 226                seq_printf(m, " %8ld %% total match ratio (RXMR)\n",
 227                                pkg_stats->total_rx_match_ratio);
 228
 229                seq_printf(m, " %8ld frames/s total tx rate (TXR)\n",
 230                                pkg_stats->total_tx_rate);
 231                seq_printf(m, " %8ld frames/s total rx rate (RXR)\n",
 232                                pkg_stats->total_rx_rate);
 233
 234                seq_putc(m, '\n');
 235
 236                seq_printf(m, " %8ld %% current match ratio (CRXMR)\n",
 237                                pkg_stats->current_rx_match_ratio);
 238
 239                seq_printf(m, " %8ld frames/s current tx rate (CTXR)\n",
 240                                pkg_stats->current_tx_rate);
 241                seq_printf(m, " %8ld frames/s current rx rate (CRXR)\n",
 242                                pkg_stats->current_rx_rate);
 243
 244                seq_putc(m, '\n');
 245
 246                seq_printf(m, " %8ld %% max match ratio (MRXMR)\n",
 247                                pkg_stats->max_rx_match_ratio);
 248
 249                seq_printf(m, " %8ld frames/s max tx rate (MTXR)\n",
 250                                pkg_stats->max_tx_rate);
 251                seq_printf(m, " %8ld frames/s max rx rate (MRXR)\n",
 252                                pkg_stats->max_rx_rate);
 253
 254                seq_putc(m, '\n');
 255        }
 256
 257        seq_printf(m, " %8ld current receive list entries (CRCV)\n",
 258                        rcv_lists_stats->rcv_entries);
 259        seq_printf(m, " %8ld maximum receive list entries (MRCV)\n",
 260                        rcv_lists_stats->rcv_entries_max);
 261
 262        if (rcv_lists_stats->stats_reset)
 263                seq_printf(m, "\n %8ld statistic resets (STR)\n",
 264                                rcv_lists_stats->stats_reset);
 265
 266        if (rcv_lists_stats->user_reset)
 267                seq_printf(m, " %8ld user statistic resets (USTR)\n",
 268                                rcv_lists_stats->user_reset);
 269
 270        seq_putc(m, '\n');
 271        return 0;
 272}
 273
 274static int can_reset_stats_proc_show(struct seq_file *m, void *v)
 275{
 276        struct net *net = m->private;
 277        struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
 278        struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
 279
 280        user_reset = 1;
 281
 282        if (net->can.stattimer.function == can_stat_update) {
 283                seq_printf(m, "Scheduled statistic reset #%ld.\n",
 284                                rcv_lists_stats->stats_reset + 1);
 285        } else {
 286                if (pkg_stats->jiffies_init != jiffies)
 287                        can_init_stats(net);
 288
 289                seq_printf(m, "Performed statistic reset #%ld.\n",
 290                                rcv_lists_stats->stats_reset);
 291        }
 292        return 0;
 293}
 294
 295static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx,
 296                                             struct net_device *dev,
 297                                             struct can_dev_rcv_lists *dev_rcv_lists)
 298{
 299        if (!hlist_empty(&dev_rcv_lists->rx[idx])) {
 300                can_print_recv_banner(m);
 301                can_print_rcvlist(m, &dev_rcv_lists->rx[idx], dev);
 302        } else
 303                seq_printf(m, "  (%s: no entry)\n", DNAME(dev));
 304
 305}
 306
 307static int can_rcvlist_proc_show(struct seq_file *m, void *v)
 308{
 309        /* double cast to prevent GCC warning */
 310        int idx = (int)(long)PDE_DATA(m->file->f_inode);
 311        struct net_device *dev;
 312        struct can_dev_rcv_lists *dev_rcv_lists;
 313        struct net *net = m->private;
 314
 315        seq_printf(m, "\nreceive list '%s':\n", rx_list_name[idx]);
 316
 317        rcu_read_lock();
 318
 319        /* receive list for 'all' CAN devices (dev == NULL) */
 320        dev_rcv_lists = net->can.rx_alldev_list;
 321        can_rcvlist_proc_show_one(m, idx, NULL, dev_rcv_lists);
 322
 323        /* receive list for registered CAN devices */
 324        for_each_netdev_rcu(net, dev) {
 325                if (dev->type == ARPHRD_CAN && dev->ml_priv)
 326                        can_rcvlist_proc_show_one(m, idx, dev, dev->ml_priv);
 327        }
 328
 329        rcu_read_unlock();
 330
 331        seq_putc(m, '\n');
 332        return 0;
 333}
 334
 335static inline void can_rcvlist_proc_show_array(struct seq_file *m,
 336                                               struct net_device *dev,
 337                                               struct hlist_head *rcv_array,
 338                                               unsigned int rcv_array_sz)
 339{
 340        unsigned int i;
 341        int all_empty = 1;
 342
 343        /* check whether at least one list is non-empty */
 344        for (i = 0; i < rcv_array_sz; i++)
 345                if (!hlist_empty(&rcv_array[i])) {
 346                        all_empty = 0;
 347                        break;
 348                }
 349
 350        if (!all_empty) {
 351                can_print_recv_banner(m);
 352                for (i = 0; i < rcv_array_sz; i++) {
 353                        if (!hlist_empty(&rcv_array[i]))
 354                                can_print_rcvlist(m, &rcv_array[i], dev);
 355                }
 356        } else
 357                seq_printf(m, "  (%s: no entry)\n", DNAME(dev));
 358}
 359
 360static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v)
 361{
 362        struct net_device *dev;
 363        struct can_dev_rcv_lists *dev_rcv_lists;
 364        struct net *net = m->private;
 365
 366        /* RX_SFF */
 367        seq_puts(m, "\nreceive list 'rx_sff':\n");
 368
 369        rcu_read_lock();
 370
 371        /* sff receive list for 'all' CAN devices (dev == NULL) */
 372        dev_rcv_lists = net->can.rx_alldev_list;
 373        can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_sff,
 374                                    ARRAY_SIZE(dev_rcv_lists->rx_sff));
 375
 376        /* sff receive list for registered CAN devices */
 377        for_each_netdev_rcu(net, dev) {
 378                if (dev->type == ARPHRD_CAN && dev->ml_priv) {
 379                        dev_rcv_lists = dev->ml_priv;
 380                        can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_sff,
 381                                                    ARRAY_SIZE(dev_rcv_lists->rx_sff));
 382                }
 383        }
 384
 385        rcu_read_unlock();
 386
 387        seq_putc(m, '\n');
 388        return 0;
 389}
 390
 391static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v)
 392{
 393        struct net_device *dev;
 394        struct can_dev_rcv_lists *dev_rcv_lists;
 395        struct net *net = m->private;
 396
 397        /* RX_EFF */
 398        seq_puts(m, "\nreceive list 'rx_eff':\n");
 399
 400        rcu_read_lock();
 401
 402        /* eff receive list for 'all' CAN devices (dev == NULL) */
 403        dev_rcv_lists = net->can.rx_alldev_list;
 404        can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_eff,
 405                                    ARRAY_SIZE(dev_rcv_lists->rx_eff));
 406
 407        /* eff receive list for registered CAN devices */
 408        for_each_netdev_rcu(net, dev) {
 409                if (dev->type == ARPHRD_CAN && dev->ml_priv) {
 410                        dev_rcv_lists = dev->ml_priv;
 411                        can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_eff,
 412                                                    ARRAY_SIZE(dev_rcv_lists->rx_eff));
 413                }
 414        }
 415
 416        rcu_read_unlock();
 417
 418        seq_putc(m, '\n');
 419        return 0;
 420}
 421
 422/*
 423 * can_init_proc - create main CAN proc directory and procfs entries
 424 */
 425void can_init_proc(struct net *net)
 426{
 427        /* create /proc/net/can directory */
 428        net->can.proc_dir = proc_net_mkdir(net, "can", net->proc_net);
 429
 430        if (!net->can.proc_dir) {
 431                printk(KERN_INFO "can: failed to create /proc/net/can . "
 432                           "CONFIG_PROC_FS missing?\n");
 433                return;
 434        }
 435
 436        /* own procfs entries from the AF_CAN core */
 437        net->can.pde_stats = proc_create_net_single(CAN_PROC_STATS, 0644,
 438                        net->can.proc_dir, can_stats_proc_show, NULL);
 439        net->can.pde_reset_stats = proc_create_net_single(CAN_PROC_RESET_STATS,
 440                        0644, net->can.proc_dir, can_reset_stats_proc_show,
 441                        NULL);
 442        net->can.pde_rcvlist_err = proc_create_net_single(CAN_PROC_RCVLIST_ERR,
 443                        0644, net->can.proc_dir, can_rcvlist_proc_show,
 444                        (void *)RX_ERR);
 445        net->can.pde_rcvlist_all = proc_create_net_single(CAN_PROC_RCVLIST_ALL,
 446                        0644, net->can.proc_dir, can_rcvlist_proc_show,
 447                        (void *)RX_ALL);
 448        net->can.pde_rcvlist_fil = proc_create_net_single(CAN_PROC_RCVLIST_FIL,
 449                        0644, net->can.proc_dir, can_rcvlist_proc_show,
 450                        (void *)RX_FIL);
 451        net->can.pde_rcvlist_inv = proc_create_net_single(CAN_PROC_RCVLIST_INV,
 452                        0644, net->can.proc_dir, can_rcvlist_proc_show,
 453                        (void *)RX_INV);
 454        net->can.pde_rcvlist_eff = proc_create_net_single(CAN_PROC_RCVLIST_EFF,
 455                        0644, net->can.proc_dir, can_rcvlist_eff_proc_show, NULL);
 456        net->can.pde_rcvlist_sff = proc_create_net_single(CAN_PROC_RCVLIST_SFF,
 457                        0644, net->can.proc_dir, can_rcvlist_sff_proc_show, NULL);
 458}
 459
 460/*
 461 * can_remove_proc - remove procfs entries and main CAN proc directory
 462 */
 463void can_remove_proc(struct net *net)
 464{
 465        if (!net->can.proc_dir)
 466                return;
 467
 468        if (net->can.pde_stats)
 469                remove_proc_entry(CAN_PROC_STATS, net->can.proc_dir);
 470
 471        if (net->can.pde_reset_stats)
 472                remove_proc_entry(CAN_PROC_RESET_STATS, net->can.proc_dir);
 473
 474        if (net->can.pde_rcvlist_err)
 475                remove_proc_entry(CAN_PROC_RCVLIST_ERR, net->can.proc_dir);
 476
 477        if (net->can.pde_rcvlist_all)
 478                remove_proc_entry(CAN_PROC_RCVLIST_ALL, net->can.proc_dir);
 479
 480        if (net->can.pde_rcvlist_fil)
 481                remove_proc_entry(CAN_PROC_RCVLIST_FIL, net->can.proc_dir);
 482
 483        if (net->can.pde_rcvlist_inv)
 484                remove_proc_entry(CAN_PROC_RCVLIST_INV, net->can.proc_dir);
 485
 486        if (net->can.pde_rcvlist_eff)
 487                remove_proc_entry(CAN_PROC_RCVLIST_EFF, net->can.proc_dir);
 488
 489        if (net->can.pde_rcvlist_sff)
 490                remove_proc_entry(CAN_PROC_RCVLIST_SFF, net->can.proc_dir);
 491
 492        remove_proc_entry("can", net->proc_net);
 493}
 494