net/core/gen_stats.c

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