LCOV - code coverage report
Current view: top level - net/core - gen_stats.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 119 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 14 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * net/core/gen_stats.c
       4                 :            :  *
       5                 :            :  * Authors:  Thomas Graf <tgraf@suug.ch>
       6                 :            :  *           Jamal Hadi Salim
       7                 :            :  *           Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
       8                 :            :  *
       9                 :            :  * See Documentation/networking/gen_stats.txt
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <linux/types.h>
      13                 :            : #include <linux/kernel.h>
      14                 :            : #include <linux/module.h>
      15                 :            : #include <linux/interrupt.h>
      16                 :            : #include <linux/socket.h>
      17                 :            : #include <linux/rtnetlink.h>
      18                 :            : #include <linux/gen_stats.h>
      19                 :            : #include <net/netlink.h>
      20                 :            : #include <net/gen_stats.h>
      21                 :            : 
      22                 :            : 
      23                 :            : static inline int
      24                 :          0 : gnet_stats_copy(struct gnet_dump *d, int type, void *buf, int size, int padattr)
      25                 :            : {
      26                 :          0 :         if (nla_put_64bit(d->skb, type, size, buf, padattr))
      27                 :            :                 goto nla_put_failure;
      28                 :            :         return 0;
      29                 :            : 
      30                 :            : nla_put_failure:
      31                 :          0 :         if (d->lock)
      32                 :            :                 spin_unlock_bh(d->lock);
      33                 :          0 :         kfree(d->xstats);
      34                 :          0 :         d->xstats = NULL;
      35                 :          0 :         d->xstats_len = 0;
      36                 :          0 :         return -1;
      37                 :            : }
      38                 :            : 
      39                 :            : /**
      40                 :            :  * gnet_stats_start_copy_compat - start dumping procedure in compatibility mode
      41                 :            :  * @skb: socket buffer to put statistics TLVs into
      42                 :            :  * @type: TLV type for top level statistic TLV
      43                 :            :  * @tc_stats_type: TLV type for backward compatibility struct tc_stats TLV
      44                 :            :  * @xstats_type: TLV type for backward compatibility xstats TLV
      45                 :            :  * @lock: statistics lock
      46                 :            :  * @d: dumping handle
      47                 :            :  * @padattr: padding attribute
      48                 :            :  *
      49                 :            :  * Initializes the dumping handle, grabs the statistic lock and appends
      50                 :            :  * an empty TLV header to the socket buffer for use a container for all
      51                 :            :  * other statistic TLVS.
      52                 :            :  *
      53                 :            :  * The dumping handle is marked to be in backward compatibility mode telling
      54                 :            :  * all gnet_stats_copy_XXX() functions to fill a local copy of struct tc_stats.
      55                 :            :  *
      56                 :            :  * Returns 0 on success or -1 if the room in the socket buffer was not sufficient.
      57                 :            :  */
      58                 :            : int
      59                 :          0 : gnet_stats_start_copy_compat(struct sk_buff *skb, int type, int tc_stats_type,
      60                 :            :                              int xstats_type, spinlock_t *lock,
      61                 :            :                              struct gnet_dump *d, int padattr)
      62                 :            :         __acquires(lock)
      63                 :            : {
      64                 :          0 :         memset(d, 0, sizeof(*d));
      65                 :            : 
      66                 :          0 :         if (type)
      67                 :          0 :                 d->tail = (struct nlattr *)skb_tail_pointer(skb);
      68                 :          0 :         d->skb = skb;
      69                 :          0 :         d->compat_tc_stats = tc_stats_type;
      70                 :          0 :         d->compat_xstats = xstats_type;
      71                 :          0 :         d->padattr = padattr;
      72                 :          0 :         if (lock) {
      73                 :          0 :                 d->lock = lock;
      74                 :            :                 spin_lock_bh(lock);
      75                 :            :         }
      76                 :          0 :         if (d->tail) {
      77                 :          0 :                 int ret = gnet_stats_copy(d, type, NULL, 0, padattr);
      78                 :            : 
      79                 :            :                 /* The initial attribute added in gnet_stats_copy() may be
      80                 :            :                  * preceded by a padding attribute, in which case d->tail will
      81                 :            :                  * end up pointing at the padding instead of the real attribute.
      82                 :            :                  * Fix this so gnet_stats_finish_copy() adjusts the length of
      83                 :            :                  * the right attribute.
      84                 :            :                  */
      85                 :          0 :                 if (ret == 0 && d->tail->nla_type == padattr)
      86                 :          0 :                         d->tail = (struct nlattr *)((char *)d->tail +
      87                 :          0 :                                                     NLA_ALIGN(d->tail->nla_len));
      88                 :          0 :                 return ret;
      89                 :            :         }
      90                 :            : 
      91                 :            :         return 0;
      92                 :            : }
      93                 :            : EXPORT_SYMBOL(gnet_stats_start_copy_compat);
      94                 :            : 
      95                 :            : /**
      96                 :            :  * gnet_stats_start_copy - start dumping procedure in compatibility mode
      97                 :            :  * @skb: socket buffer to put statistics TLVs into
      98                 :            :  * @type: TLV type for top level statistic TLV
      99                 :            :  * @lock: statistics lock
     100                 :            :  * @d: dumping handle
     101                 :            :  * @padattr: padding attribute
     102                 :            :  *
     103                 :            :  * Initializes the dumping handle, grabs the statistic lock and appends
     104                 :            :  * an empty TLV header to the socket buffer for use a container for all
     105                 :            :  * other statistic TLVS.
     106                 :            :  *
     107                 :            :  * Returns 0 on success or -1 if the room in the socket buffer was not sufficient.
     108                 :            :  */
     109                 :            : int
     110                 :          0 : gnet_stats_start_copy(struct sk_buff *skb, int type, spinlock_t *lock,
     111                 :            :                       struct gnet_dump *d, int padattr)
     112                 :            : {
     113                 :          0 :         return gnet_stats_start_copy_compat(skb, type, 0, 0, lock, d, padattr);
     114                 :            : }
     115                 :            : EXPORT_SYMBOL(gnet_stats_start_copy);
     116                 :            : 
     117                 :            : static void
     118                 :          0 : __gnet_stats_copy_basic_cpu(struct gnet_stats_basic_packed *bstats,
     119                 :            :                             struct gnet_stats_basic_cpu __percpu *cpu)
     120                 :            : {
     121                 :            :         int i;
     122                 :            : 
     123                 :          0 :         for_each_possible_cpu(i) {
     124                 :          0 :                 struct gnet_stats_basic_cpu *bcpu = per_cpu_ptr(cpu, i);
     125                 :            :                 unsigned int start;
     126                 :            :                 u64 bytes;
     127                 :            :                 u32 packets;
     128                 :            : 
     129                 :            :                 do {
     130                 :            :                         start = u64_stats_fetch_begin_irq(&bcpu->syncp);
     131                 :          0 :                         bytes = bcpu->bstats.bytes;
     132                 :          0 :                         packets = bcpu->bstats.packets;
     133                 :          0 :                 } while (u64_stats_fetch_retry_irq(&bcpu->syncp, start));
     134                 :            : 
     135                 :          0 :                 bstats->bytes += bytes;
     136                 :          0 :                 bstats->packets += packets;
     137                 :            :         }
     138                 :          0 : }
     139                 :            : 
     140                 :            : void
     141                 :          0 : __gnet_stats_copy_basic(const seqcount_t *running,
     142                 :            :                         struct gnet_stats_basic_packed *bstats,
     143                 :            :                         struct gnet_stats_basic_cpu __percpu *cpu,
     144                 :            :                         struct gnet_stats_basic_packed *b)
     145                 :            : {
     146                 :            :         unsigned int seq;
     147                 :            : 
     148                 :          0 :         if (cpu) {
     149                 :          0 :                 __gnet_stats_copy_basic_cpu(bstats, cpu);
     150                 :          0 :                 return;
     151                 :            :         }
     152                 :            :         do {
     153                 :          0 :                 if (running)
     154                 :            :                         seq = read_seqcount_begin(running);
     155                 :          0 :                 bstats->bytes = b->bytes;
     156                 :          0 :                 bstats->packets = b->packets;
     157                 :          0 :         } while (running && read_seqcount_retry(running, seq));
     158                 :            : }
     159                 :            : EXPORT_SYMBOL(__gnet_stats_copy_basic);
     160                 :            : 
     161                 :            : static int
     162                 :          0 : ___gnet_stats_copy_basic(const seqcount_t *running,
     163                 :            :                          struct gnet_dump *d,
     164                 :            :                          struct gnet_stats_basic_cpu __percpu *cpu,
     165                 :            :                          struct gnet_stats_basic_packed *b,
     166                 :            :                          int type)
     167                 :            : {
     168                 :          0 :         struct gnet_stats_basic_packed bstats = {0};
     169                 :            : 
     170                 :          0 :         __gnet_stats_copy_basic(running, &bstats, cpu, b);
     171                 :            : 
     172                 :          0 :         if (d->compat_tc_stats && type == TCA_STATS_BASIC) {
     173                 :          0 :                 d->tc_stats.bytes = bstats.bytes;
     174                 :          0 :                 d->tc_stats.packets = bstats.packets;
     175                 :            :         }
     176                 :            : 
     177                 :          0 :         if (d->tail) {
     178                 :            :                 struct gnet_stats_basic sb;
     179                 :            : 
     180                 :          0 :                 memset(&sb, 0, sizeof(sb));
     181                 :          0 :                 sb.bytes = bstats.bytes;
     182                 :          0 :                 sb.packets = bstats.packets;
     183                 :          0 :                 return gnet_stats_copy(d, type, &sb, sizeof(sb),
     184                 :            :                                        TCA_STATS_PAD);
     185                 :            :         }
     186                 :            :         return 0;
     187                 :            : }
     188                 :            : 
     189                 :            : /**
     190                 :            :  * gnet_stats_copy_basic - copy basic statistics into statistic TLV
     191                 :            :  * @running: seqcount_t pointer
     192                 :            :  * @d: dumping handle
     193                 :            :  * @cpu: copy statistic per cpu
     194                 :            :  * @b: basic statistics
     195                 :            :  *
     196                 :            :  * Appends the basic statistics to the top level TLV created by
     197                 :            :  * gnet_stats_start_copy().
     198                 :            :  *
     199                 :            :  * Returns 0 on success or -1 with the statistic lock released
     200                 :            :  * if the room in the socket buffer was not sufficient.
     201                 :            :  */
     202                 :            : int
     203                 :          0 : gnet_stats_copy_basic(const seqcount_t *running,
     204                 :            :                       struct gnet_dump *d,
     205                 :            :                       struct gnet_stats_basic_cpu __percpu *cpu,
     206                 :            :                       struct gnet_stats_basic_packed *b)
     207                 :            : {
     208                 :          0 :         return ___gnet_stats_copy_basic(running, d, cpu, b,
     209                 :            :                                         TCA_STATS_BASIC);
     210                 :            : }
     211                 :            : EXPORT_SYMBOL(gnet_stats_copy_basic);
     212                 :            : 
     213                 :            : /**
     214                 :            :  * gnet_stats_copy_basic_hw - copy basic hw statistics into statistic TLV
     215                 :            :  * @running: seqcount_t pointer
     216                 :            :  * @d: dumping handle
     217                 :            :  * @cpu: copy statistic per cpu
     218                 :            :  * @b: basic statistics
     219                 :            :  *
     220                 :            :  * Appends the basic statistics to the top level TLV created by
     221                 :            :  * gnet_stats_start_copy().
     222                 :            :  *
     223                 :            :  * Returns 0 on success or -1 with the statistic lock released
     224                 :            :  * if the room in the socket buffer was not sufficient.
     225                 :            :  */
     226                 :            : int
     227                 :          0 : gnet_stats_copy_basic_hw(const seqcount_t *running,
     228                 :            :                          struct gnet_dump *d,
     229                 :            :                          struct gnet_stats_basic_cpu __percpu *cpu,
     230                 :            :                          struct gnet_stats_basic_packed *b)
     231                 :            : {
     232                 :          0 :         return ___gnet_stats_copy_basic(running, d, cpu, b,
     233                 :            :                                         TCA_STATS_BASIC_HW);
     234                 :            : }
     235                 :            : EXPORT_SYMBOL(gnet_stats_copy_basic_hw);
     236                 :            : 
     237                 :            : /**
     238                 :            :  * gnet_stats_copy_rate_est - copy rate estimator statistics into statistics TLV
     239                 :            :  * @d: dumping handle
     240                 :            :  * @rate_est: rate estimator
     241                 :            :  *
     242                 :            :  * Appends the rate estimator statistics to the top level TLV created by
     243                 :            :  * gnet_stats_start_copy().
     244                 :            :  *
     245                 :            :  * Returns 0 on success or -1 with the statistic lock released
     246                 :            :  * if the room in the socket buffer was not sufficient.
     247                 :            :  */
     248                 :            : int
     249                 :          0 : gnet_stats_copy_rate_est(struct gnet_dump *d,
     250                 :            :                          struct net_rate_estimator __rcu **rate_est)
     251                 :            : {
     252                 :            :         struct gnet_stats_rate_est64 sample;
     253                 :            :         struct gnet_stats_rate_est est;
     254                 :            :         int res;
     255                 :            : 
     256                 :          0 :         if (!gen_estimator_read(rate_est, &sample))
     257                 :            :                 return 0;
     258                 :          0 :         est.bps = min_t(u64, UINT_MAX, sample.bps);
     259                 :            :         /* we have some time before reaching 2^32 packets per second */
     260                 :          0 :         est.pps = sample.pps;
     261                 :            : 
     262                 :          0 :         if (d->compat_tc_stats) {
     263                 :          0 :                 d->tc_stats.bps = est.bps;
     264                 :          0 :                 d->tc_stats.pps = est.pps;
     265                 :            :         }
     266                 :            : 
     267                 :          0 :         if (d->tail) {
     268                 :          0 :                 res = gnet_stats_copy(d, TCA_STATS_RATE_EST, &est, sizeof(est),
     269                 :            :                                       TCA_STATS_PAD);
     270                 :          0 :                 if (res < 0 || est.bps == sample.bps)
     271                 :            :                         return res;
     272                 :            :                 /* emit 64bit stats only if needed */
     273                 :          0 :                 return gnet_stats_copy(d, TCA_STATS_RATE_EST64, &sample,
     274                 :            :                                        sizeof(sample), TCA_STATS_PAD);
     275                 :            :         }
     276                 :            : 
     277                 :            :         return 0;
     278                 :            : }
     279                 :            : EXPORT_SYMBOL(gnet_stats_copy_rate_est);
     280                 :            : 
     281                 :            : static void
     282                 :          0 : __gnet_stats_copy_queue_cpu(struct gnet_stats_queue *qstats,
     283                 :            :                             const struct gnet_stats_queue __percpu *q)
     284                 :            : {
     285                 :            :         int i;
     286                 :            : 
     287                 :          0 :         for_each_possible_cpu(i) {
     288                 :          0 :                 const struct gnet_stats_queue *qcpu = per_cpu_ptr(q, i);
     289                 :            : 
     290                 :          0 :                 qstats->qlen = 0;
     291                 :          0 :                 qstats->backlog += qcpu->backlog;
     292                 :          0 :                 qstats->drops += qcpu->drops;
     293                 :          0 :                 qstats->requeues += qcpu->requeues;
     294                 :          0 :                 qstats->overlimits += qcpu->overlimits;
     295                 :            :         }
     296                 :          0 : }
     297                 :            : 
     298                 :          0 : void __gnet_stats_copy_queue(struct gnet_stats_queue *qstats,
     299                 :            :                              const struct gnet_stats_queue __percpu *cpu,
     300                 :            :                              const struct gnet_stats_queue *q,
     301                 :            :                              __u32 qlen)
     302                 :            : {
     303                 :          0 :         if (cpu) {
     304                 :          0 :                 __gnet_stats_copy_queue_cpu(qstats, cpu);
     305                 :            :         } else {
     306                 :          0 :                 qstats->qlen = q->qlen;
     307                 :          0 :                 qstats->backlog = q->backlog;
     308                 :          0 :                 qstats->drops = q->drops;
     309                 :          0 :                 qstats->requeues = q->requeues;
     310                 :          0 :                 qstats->overlimits = q->overlimits;
     311                 :            :         }
     312                 :            : 
     313                 :          0 :         qstats->qlen = qlen;
     314                 :          0 : }
     315                 :            : EXPORT_SYMBOL(__gnet_stats_copy_queue);
     316                 :            : 
     317                 :            : /**
     318                 :            :  * gnet_stats_copy_queue - copy queue statistics into statistics TLV
     319                 :            :  * @d: dumping handle
     320                 :            :  * @cpu_q: per cpu queue statistics
     321                 :            :  * @q: queue statistics
     322                 :            :  * @qlen: queue length statistics
     323                 :            :  *
     324                 :            :  * Appends the queue statistics to the top level TLV created by
     325                 :            :  * gnet_stats_start_copy(). Using per cpu queue statistics if
     326                 :            :  * they are available.
     327                 :            :  *
     328                 :            :  * Returns 0 on success or -1 with the statistic lock released
     329                 :            :  * if the room in the socket buffer was not sufficient.
     330                 :            :  */
     331                 :            : int
     332                 :          0 : gnet_stats_copy_queue(struct gnet_dump *d,
     333                 :            :                       struct gnet_stats_queue __percpu *cpu_q,
     334                 :            :                       struct gnet_stats_queue *q, __u32 qlen)
     335                 :            : {
     336                 :          0 :         struct gnet_stats_queue qstats = {0};
     337                 :            : 
     338                 :          0 :         __gnet_stats_copy_queue(&qstats, cpu_q, q, qlen);
     339                 :            : 
     340                 :          0 :         if (d->compat_tc_stats) {
     341                 :          0 :                 d->tc_stats.drops = qstats.drops;
     342                 :          0 :                 d->tc_stats.qlen = qstats.qlen;
     343                 :          0 :                 d->tc_stats.backlog = qstats.backlog;
     344                 :          0 :                 d->tc_stats.overlimits = qstats.overlimits;
     345                 :            :         }
     346                 :            : 
     347                 :          0 :         if (d->tail)
     348                 :          0 :                 return gnet_stats_copy(d, TCA_STATS_QUEUE,
     349                 :            :                                        &qstats, sizeof(qstats),
     350                 :            :                                        TCA_STATS_PAD);
     351                 :            : 
     352                 :            :         return 0;
     353                 :            : }
     354                 :            : EXPORT_SYMBOL(gnet_stats_copy_queue);
     355                 :            : 
     356                 :            : /**
     357                 :            :  * gnet_stats_copy_app - copy application specific statistics into statistics TLV
     358                 :            :  * @d: dumping handle
     359                 :            :  * @st: application specific statistics data
     360                 :            :  * @len: length of data
     361                 :            :  *
     362                 :            :  * Appends the application specific statistics to the top level TLV created by
     363                 :            :  * gnet_stats_start_copy() and remembers the data for XSTATS if the dumping
     364                 :            :  * handle is in backward compatibility mode.
     365                 :            :  *
     366                 :            :  * Returns 0 on success or -1 with the statistic lock released
     367                 :            :  * if the room in the socket buffer was not sufficient.
     368                 :            :  */
     369                 :            : int
     370                 :          0 : gnet_stats_copy_app(struct gnet_dump *d, void *st, int len)
     371                 :            : {
     372                 :          0 :         if (d->compat_xstats) {
     373                 :          0 :                 d->xstats = kmemdup(st, len, GFP_ATOMIC);
     374                 :          0 :                 if (!d->xstats)
     375                 :            :                         goto err_out;
     376                 :          0 :                 d->xstats_len = len;
     377                 :            :         }
     378                 :            : 
     379                 :          0 :         if (d->tail)
     380                 :          0 :                 return gnet_stats_copy(d, TCA_STATS_APP, st, len,
     381                 :            :                                        TCA_STATS_PAD);
     382                 :            : 
     383                 :            :         return 0;
     384                 :            : 
     385                 :            : err_out:
     386                 :          0 :         if (d->lock)
     387                 :            :                 spin_unlock_bh(d->lock);
     388                 :          0 :         d->xstats_len = 0;
     389                 :          0 :         return -1;
     390                 :            : }
     391                 :            : EXPORT_SYMBOL(gnet_stats_copy_app);
     392                 :            : 
     393                 :            : /**
     394                 :            :  * gnet_stats_finish_copy - finish dumping procedure
     395                 :            :  * @d: dumping handle
     396                 :            :  *
     397                 :            :  * Corrects the length of the top level TLV to include all TLVs added
     398                 :            :  * by gnet_stats_copy_XXX() calls. Adds the backward compatibility TLVs
     399                 :            :  * if gnet_stats_start_copy_compat() was used and releases the statistics
     400                 :            :  * lock.
     401                 :            :  *
     402                 :            :  * Returns 0 on success or -1 with the statistic lock released
     403                 :            :  * if the room in the socket buffer was not sufficient.
     404                 :            :  */
     405                 :            : int
     406                 :          0 : gnet_stats_finish_copy(struct gnet_dump *d)
     407                 :            : {
     408                 :          0 :         if (d->tail)
     409                 :          0 :                 d->tail->nla_len = skb_tail_pointer(d->skb) - (u8 *)d->tail;
     410                 :            : 
     411                 :          0 :         if (d->compat_tc_stats)
     412                 :          0 :                 if (gnet_stats_copy(d, d->compat_tc_stats, &d->tc_stats,
     413                 :            :                                     sizeof(d->tc_stats), d->padattr) < 0)
     414                 :            :                         return -1;
     415                 :            : 
     416                 :          0 :         if (d->compat_xstats && d->xstats) {
     417                 :          0 :                 if (gnet_stats_copy(d, d->compat_xstats, d->xstats,
     418                 :            :                                     d->xstats_len, d->padattr) < 0)
     419                 :            :                         return -1;
     420                 :            :         }
     421                 :            : 
     422                 :          0 :         if (d->lock)
     423                 :            :                 spin_unlock_bh(d->lock);
     424                 :          0 :         kfree(d->xstats);
     425                 :          0 :         d->xstats = NULL;
     426                 :          0 :         d->xstats_len = 0;
     427                 :          0 :         return 0;
     428                 :            : }
     429                 :            : EXPORT_SYMBOL(gnet_stats_finish_copy);
    

Generated by: LCOV version 1.14