net/smc/smc_stats.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Shared Memory Communications over RDMA (SMC-R) and RoCE
   4  *
   5  * SMC statistics netlink routines
   6  *
   7  * Copyright IBM Corp. 2021
   8  *
   9  * Author(s):  Guvenc Gulce
  10  */
  11 #include <linux/init.h>
  12 #include <linux/mutex.h>
  13 #include <linux/percpu.h>
  14 #include <linux/ctype.h>
  15 #include <linux/smc.h>
  16 #include <net/genetlink.h>
  17 #include <net/sock.h>
  18 #include "smc_netlink.h"
  19 #include "smc_stats.h"
  20
  21 int smc_stats_init(struct net *net)
  22 {
  23         net->smc.fback_rsn = kzalloc(sizeof(*net->smc.fback_rsn), GFP_KERNEL);
  24         if (!net->smc.fback_rsn)
  25                 goto err_fback;
  26         net->smc.smc_stats = alloc_percpu(struct smc_stats);
  27         if (!net->smc.smc_stats)
  28                 goto err_stats;
  29         mutex_init(&net->smc.mutex_fback_rsn);
  30         return 0;
  31
  32 err_stats:
  33         kfree(net->smc.fback_rsn);
  34 err_fback:
  35         return -ENOMEM;
  36 }
  37
  38 void smc_stats_exit(struct net *net)
  39 {
  40         kfree(net->smc.fback_rsn);
  41         if (net->smc.smc_stats)
  42                 free_percpu(net->smc.smc_stats);
  43 }
  44
  45 static int smc_nl_fill_stats_rmb_data(struct sk_buff *skb,
  46                                       struct smc_stats *stats, int tech,
  47                                       int type)
  48 {
  49         struct smc_stats_rmbcnt *stats_rmb_cnt;
  50         struct nlattr *attrs;
  51
  52         if (type == SMC_NLA_STATS_T_TX_RMB_STATS)
  53                 stats_rmb_cnt = &stats->smc[tech].rmb_tx;
  54         else
  55                 stats_rmb_cnt = &stats->smc[tech].rmb_rx;
  56
  57         attrs = nla_nest_start(skb, type);
  58         if (!attrs)
  59                 goto errout;
  60         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_REUSE_CNT,
  61                               stats_rmb_cnt->reuse_cnt,
  62                               SMC_NLA_STATS_RMB_PAD))
  63                 goto errattr;
  64         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_SIZE_SM_PEER_CNT,
  65                               stats_rmb_cnt->buf_size_small_peer_cnt,
  66                               SMC_NLA_STATS_RMB_PAD))
  67                 goto errattr;
  68         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_SIZE_SM_CNT,
  69                               stats_rmb_cnt->buf_size_small_cnt,
  70                               SMC_NLA_STATS_RMB_PAD))
  71                 goto errattr;
  72         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_FULL_PEER_CNT,
  73                               stats_rmb_cnt->buf_full_peer_cnt,
  74                               SMC_NLA_STATS_RMB_PAD))
  75                 goto errattr;
  76         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_FULL_CNT,
  77                               stats_rmb_cnt->buf_full_cnt,
  78                               SMC_NLA_STATS_RMB_PAD))
  79                 goto errattr;
  80         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_ALLOC_CNT,
  81                               stats_rmb_cnt->alloc_cnt,
  82                               SMC_NLA_STATS_RMB_PAD))
  83                 goto errattr;
  84         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_RMB_DGRADE_CNT,
  85                               stats_rmb_cnt->dgrade_cnt,
  86                               SMC_NLA_STATS_RMB_PAD))
  87                 goto errattr;
  88
  89         nla_nest_end(skb, attrs);
  90         return 0;
  91
  92 errattr:
  93         nla_nest_cancel(skb, attrs);
  94 errout:
  95         return -EMSGSIZE;
  96 }
  97
  98 static int smc_nl_fill_stats_bufsize_data(struct sk_buff *skb,
  99                                           struct smc_stats *stats, int tech,
 100                                           int type)
 101 {
 102         struct smc_stats_memsize *stats_pload;
 103         struct nlattr *attrs;
 104
 105         if (type == SMC_NLA_STATS_T_TXPLOAD_SIZE)
 106                 stats_pload = &stats->smc[tech].tx_pd;
 107         else if (type == SMC_NLA_STATS_T_RXPLOAD_SIZE)
 108                 stats_pload = &stats->smc[tech].rx_pd;
 109         else if (type == SMC_NLA_STATS_T_TX_RMB_SIZE)
 110                 stats_pload = &stats->smc[tech].tx_rmbsize;
 111         else if (type == SMC_NLA_STATS_T_RX_RMB_SIZE)
 112                 stats_pload = &stats->smc[tech].rx_rmbsize;
 113         else
 114                 goto errout;
 115
 116         attrs = nla_nest_start(skb, type);
 117         if (!attrs)
 118                 goto errout;
 119         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_8K,
 120                               stats_pload->buf[SMC_BUF_8K],
 121                               SMC_NLA_STATS_PLOAD_PAD))
 122                 goto errattr;
 123         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_16K,
 124                               stats_pload->buf[SMC_BUF_16K],
 125                               SMC_NLA_STATS_PLOAD_PAD))
 126                 goto errattr;
 127         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_32K,
 128                               stats_pload->buf[SMC_BUF_32K],
 129                               SMC_NLA_STATS_PLOAD_PAD))
 130                 goto errattr;
 131         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_64K,
 132                               stats_pload->buf[SMC_BUF_64K],
 133                               SMC_NLA_STATS_PLOAD_PAD))
 134                 goto errattr;
 135         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_128K,
 136                               stats_pload->buf[SMC_BUF_128K],
 137                               SMC_NLA_STATS_PLOAD_PAD))
 138                 goto errattr;
 139         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_256K,
 140                               stats_pload->buf[SMC_BUF_256K],
 141                               SMC_NLA_STATS_PLOAD_PAD))
 142                 goto errattr;
 143         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_512K,
 144                               stats_pload->buf[SMC_BUF_512K],
 145                               SMC_NLA_STATS_PLOAD_PAD))
 146                 goto errattr;
 147         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_1024K,
 148                               stats_pload->buf[SMC_BUF_1024K],
 149                               SMC_NLA_STATS_PLOAD_PAD))
 150                 goto errattr;
 151         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_PLOAD_G_1024K,
 152                               stats_pload->buf[SMC_BUF_G_1024K],
 153                               SMC_NLA_STATS_PLOAD_PAD))
 154                 goto errattr;
 155
 156         nla_nest_end(skb, attrs);
 157         return 0;
 158
 159 errattr:
 160         nla_nest_cancel(skb, attrs);
 161 errout:
 162         return -EMSGSIZE;
 163 }
 164
 165 static int smc_nl_fill_stats_tech_data(struct sk_buff *skb,
 166                                        struct smc_stats *stats, int tech)
 167 {
 168         struct smc_stats_tech *smc_tech;
 169         struct nlattr *attrs;
 170
 171         smc_tech = &stats->smc[tech];
 172         if (tech == SMC_TYPE_D)
 173                 attrs = nla_nest_start(skb, SMC_NLA_STATS_SMCD_TECH);
 174         else
 175                 attrs = nla_nest_start(skb, SMC_NLA_STATS_SMCR_TECH);
 176
 177         if (!attrs)
 178                 goto errout;
 179         if (smc_nl_fill_stats_rmb_data(skb, stats, tech,
 180                                        SMC_NLA_STATS_T_TX_RMB_STATS))
 181                 goto errattr;
 182         if (smc_nl_fill_stats_rmb_data(skb, stats, tech,
 183                                        SMC_NLA_STATS_T_RX_RMB_STATS))
 184                 goto errattr;
 185         if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
 186                                            SMC_NLA_STATS_T_TXPLOAD_SIZE))
 187                 goto errattr;
 188         if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
 189                                            SMC_NLA_STATS_T_RXPLOAD_SIZE))
 190                 goto errattr;
 191         if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
 192                                            SMC_NLA_STATS_T_TX_RMB_SIZE))
 193                 goto errattr;
 194         if (smc_nl_fill_stats_bufsize_data(skb, stats, tech,
 195                                            SMC_NLA_STATS_T_RX_RMB_SIZE))
 196                 goto errattr;
 197         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_CLNT_V1_SUCC,
 198                               smc_tech->clnt_v1_succ_cnt,
 199                               SMC_NLA_STATS_PAD))
 200                 goto errattr;
 201         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_CLNT_V2_SUCC,
 202                               smc_tech->clnt_v2_succ_cnt,
 203                               SMC_NLA_STATS_PAD))
 204                 goto errattr;
 205         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SRV_V1_SUCC,
 206                               smc_tech->srv_v1_succ_cnt,
 207                               SMC_NLA_STATS_PAD))
 208                 goto errattr;
 209         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SRV_V2_SUCC,
 210                               smc_tech->srv_v2_succ_cnt,
 211                               SMC_NLA_STATS_PAD))
 212                 goto errattr;
 213         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_RX_BYTES,
 214                               smc_tech->rx_bytes,
 215                               SMC_NLA_STATS_PAD))
 216                 goto errattr;
 217         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_TX_BYTES,
 218                               smc_tech->tx_bytes,
 219                               SMC_NLA_STATS_PAD))
 220                 goto errattr;
 221         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_RX_CNT,
 222                               smc_tech->rx_cnt,
 223                               SMC_NLA_STATS_PAD))
 224                 goto errattr;
 225         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_TX_CNT,
 226                               smc_tech->tx_cnt,
 227                               SMC_NLA_STATS_PAD))
 228                 goto errattr;
 229         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SENDPAGE_CNT,
 230                               0,
 231                               SMC_NLA_STATS_PAD))
 232                 goto errattr;
 233         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_CORK_CNT,
 234                               smc_tech->cork_cnt,
 235                               SMC_NLA_STATS_PAD))
 236                 goto errattr;
 237         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_NDLY_CNT,
 238                               smc_tech->ndly_cnt,
 239                               SMC_NLA_STATS_PAD))
 240                 goto errattr;
 241         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_SPLICE_CNT,
 242                               smc_tech->splice_cnt,
 243                               SMC_NLA_STATS_PAD))
 244                 goto errattr;
 245         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_T_URG_DATA_CNT,
 246                               smc_tech->urg_data_cnt,
 247                               SMC_NLA_STATS_PAD))
 248                 goto errattr;
 249
 250         nla_nest_end(skb, attrs);
 251         return 0;
 252
 253 errattr:
 254         nla_nest_cancel(skb, attrs);
 255 errout:
 256         return -EMSGSIZE;
 257 }
 258
 259 int smc_nl_get_stats(struct sk_buff *skb,
 260                      struct netlink_callback *cb)
 261 {
 262         struct smc_nl_dmp_ctx *cb_ctx = smc_nl_dmp_ctx(cb);
 263         struct net *net = sock_net(skb->sk);
 264         struct smc_stats *stats;
 265         struct nlattr *attrs;
 266         int cpu, i, size;
 267         void *nlh;
 268         u64 *src;
 269         u64 *sum;
 270
 271         if (cb_ctx->pos[0])
 272                 goto errmsg;
 273         nlh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
 274                           &smc_gen_nl_family, NLM_F_MULTI,
 275                           SMC_NETLINK_GET_STATS);
 276         if (!nlh)
 277                 goto errmsg;
 278
 279         attrs = nla_nest_start(skb, SMC_GEN_STATS);
 280         if (!attrs)
 281                 goto errnest;
 282         stats = kzalloc(sizeof(*stats), GFP_KERNEL);
 283         if (!stats)
 284                 goto erralloc;
 285         size = sizeof(*stats) / sizeof(u64);
 286         for_each_possible_cpu(cpu) {
 287                 src = (u64 *)per_cpu_ptr(net->smc.smc_stats, cpu);
 288                 sum = (u64 *)stats;
 289                 for (i = 0; i < size; i++)
 290                         *(sum++) += *(src++);
 291         }
 292         if (smc_nl_fill_stats_tech_data(skb, stats, SMC_TYPE_D))
 293                 goto errattr;
 294         if (smc_nl_fill_stats_tech_data(skb, stats, SMC_TYPE_R))
 295                 goto errattr;
 296         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_CLNT_HS_ERR_CNT,
 297                               stats->clnt_hshake_err_cnt,
 298                               SMC_NLA_STATS_PAD))
 299                 goto errattr;
 300         if (nla_put_u64_64bit(skb, SMC_NLA_STATS_SRV_HS_ERR_CNT,
 301                               stats->srv_hshake_err_cnt,
 302                               SMC_NLA_STATS_PAD))
 303                 goto errattr;
 304
 305         nla_nest_end(skb, attrs);
 306         genlmsg_end(skb, nlh);
 307         cb_ctx->pos[0] = 1;
 308         kfree(stats);
 309         return skb->len;
 310
 311 errattr:
 312         kfree(stats);
 313 erralloc:
 314         nla_nest_cancel(skb, attrs);
 315 errnest:
 316         genlmsg_cancel(skb, nlh);
 317 errmsg:
 318         return skb->len;
 319 }
 320
 321 static int smc_nl_get_fback_details(struct sk_buff *skb,
 322                                     struct netlink_callback *cb, int pos,
 323                                     bool is_srv)
 324 {
 325         struct smc_nl_dmp_ctx *cb_ctx = smc_nl_dmp_ctx(cb);
 326         struct net *net = sock_net(skb->sk);
 327         int cnt_reported = cb_ctx->pos[2];
 328         struct smc_stats_fback *trgt_arr;
 329         struct nlattr *attrs;
 330         int rc = 0;
 331         void *nlh;
 332
 333         if (is_srv)
 334                 trgt_arr = &net->smc.fback_rsn->srv[0];
 335         else
 336                 trgt_arr = &net->smc.fback_rsn->clnt[0];
 337         if (!trgt_arr[pos].fback_code)
 338                 return -ENODATA;
 339         nlh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
 340                           &smc_gen_nl_family, NLM_F_MULTI,
 341                           SMC_NETLINK_GET_FBACK_STATS);
 342         if (!nlh)
 343                 goto errmsg;
 344         attrs = nla_nest_start(skb, SMC_GEN_FBACK_STATS);
 345         if (!attrs)
 346                 goto errout;
 347         if (nla_put_u8(skb, SMC_NLA_FBACK_STATS_TYPE, is_srv))
 348                 goto errattr;
 349         if (!cnt_reported) {
 350                 if (nla_put_u64_64bit(skb, SMC_NLA_FBACK_STATS_SRV_CNT,
 351                                       net->smc.fback_rsn->srv_fback_cnt,
 352                                       SMC_NLA_FBACK_STATS_PAD))
 353                         goto errattr;
 354                 if (nla_put_u64_64bit(skb, SMC_NLA_FBACK_STATS_CLNT_CNT,
 355                                       net->smc.fback_rsn->clnt_fback_cnt,
 356                                       SMC_NLA_FBACK_STATS_PAD))
 357                         goto errattr;
 358                 cnt_reported = 1;
 359         }
 360
 361         if (nla_put_u32(skb, SMC_NLA_FBACK_STATS_RSN_CODE,
 362                         trgt_arr[pos].fback_code))
 363                 goto errattr;
 364         if (nla_put_u16(skb, SMC_NLA_FBACK_STATS_RSN_CNT,
 365                         trgt_arr[pos].count))
 366                 goto errattr;
 367
 368         cb_ctx->pos[2] = cnt_reported;
 369         nla_nest_end(skb, attrs);
 370         genlmsg_end(skb, nlh);
 371         return rc;
 372
 373 errattr:
 374         nla_nest_cancel(skb, attrs);
 375 errout:
 376         genlmsg_cancel(skb, nlh);
 377 errmsg:
 378         return -EMSGSIZE;
 379 }
 380
 381 int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb)
 382 {
 383         struct smc_nl_dmp_ctx *cb_ctx = smc_nl_dmp_ctx(cb);
 384         struct net *net = sock_net(skb->sk);
 385         int rc_srv = 0, rc_clnt = 0, k;
 386         int skip_serv = cb_ctx->pos[1];
 387         int snum = cb_ctx->pos[0];
 388         bool is_srv = true;
 389
 390         mutex_lock(&net->smc.mutex_fback_rsn);
 391         for (k = 0; k < SMC_MAX_FBACK_RSN_CNT; k++) {
 392                 if (k < snum)
 393                         continue;
 394                 if (!skip_serv) {
 395                         rc_srv = smc_nl_get_fback_details(skb, cb, k, is_srv);
 396                         if (rc_srv && rc_srv != -ENODATA)
 397                                 break;
 398                 } else {
 399                         skip_serv = 0;
 400                 }
 401                 rc_clnt = smc_nl_get_fback_details(skb, cb, k, !is_srv);
 402                 if (rc_clnt && rc_clnt != -ENODATA) {
 403                         skip_serv = 1;
 404                         break;
 405                 }
 406                 if (rc_clnt == -ENODATA && rc_srv == -ENODATA)
 407                         break;
 408         }
 409         mutex_unlock(&net->smc.mutex_fback_rsn);
 410         cb_ctx->pos[1] = skip_serv;
 411         cb_ctx->pos[0] = k;
 412         return skb->len;
 413 }