net/kcm/kcmproc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/in.h>
   3 #include <linux/inet.h>
   4 #include <linux/list.h>
   5 #include <linux/module.h>
   6 #include <linux/net.h>
   7 #include <linux/proc_fs.h>
   8 #include <linux/rculist.h>
   9 #include <linux/seq_file.h>
  10 #include <linux/socket.h>
  11 #include <net/inet_sock.h>
  12 #include <net/kcm.h>
  13 #include <net/net_namespace.h>
  14 #include <net/netns/generic.h>
  15 #include <net/tcp.h>
  16
  17 #ifdef CONFIG_PROC_FS
  18 struct kcm_seq_muxinfo {
  19         char                            *name;
  20         const struct file_operations    *seq_fops;
  21         const struct seq_operations     seq_ops;
  22 };
  23
  24 static struct kcm_mux *kcm_get_first(struct seq_file *seq)
  25 {
  26         struct net *net = seq_file_net(seq);
  27         struct kcm_net *knet = net_generic(net, kcm_net_id);
  28
  29         return list_first_or_null_rcu(&knet->mux_list,
  30                                       struct kcm_mux, kcm_mux_list);
  31 }
  32
  33 static struct kcm_mux *kcm_get_next(struct kcm_mux *mux)
  34 {
  35         struct kcm_net *knet = mux->knet;
  36
  37         return list_next_or_null_rcu(&knet->mux_list, &mux->kcm_mux_list,
  38                                      struct kcm_mux, kcm_mux_list);
  39 }
  40
  41 static struct kcm_mux *kcm_get_idx(struct seq_file *seq, loff_t pos)
  42 {
  43         struct net *net = seq_file_net(seq);
  44         struct kcm_net *knet = net_generic(net, kcm_net_id);
  45         struct kcm_mux *m;
  46
  47         list_for_each_entry_rcu(m, &knet->mux_list, kcm_mux_list) {
  48                 if (!pos)
  49                         return m;
  50                 --pos;
  51         }
  52         return NULL;
  53 }
  54
  55 static void *kcm_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  56 {
  57         void *p;
  58
  59         if (v == SEQ_START_TOKEN)
  60                 p = kcm_get_first(seq);
  61         else
  62                 p = kcm_get_next(v);
  63         ++*pos;
  64         return p;
  65 }
  66
  67 static void *kcm_seq_start(struct seq_file *seq, loff_t *pos)
  68         __acquires(rcu)
  69 {
  70         rcu_read_lock();
  71
  72         if (!*pos)
  73                 return SEQ_START_TOKEN;
  74         else
  75                 return kcm_get_idx(seq, *pos - 1);
  76 }
  77
  78 static void kcm_seq_stop(struct seq_file *seq, void *v)
  79         __releases(rcu)
  80 {
  81         rcu_read_unlock();
  82 }
  83
  84 struct kcm_proc_mux_state {
  85         struct seq_net_private p;
  86         int idx;
  87 };
  88
  89 static int kcm_seq_open(struct inode *inode, struct file *file)
  90 {
  91         struct kcm_seq_muxinfo *muxinfo = PDE_DATA(inode);
  92
  93         return seq_open_net(inode, file, &muxinfo->seq_ops,
  94                            sizeof(struct kcm_proc_mux_state));
  95 }
  96
  97 static void kcm_format_mux_header(struct seq_file *seq)
  98 {
  99         struct net *net = seq_file_net(seq);
 100         struct kcm_net *knet = net_generic(net, kcm_net_id);
 101
 102         seq_printf(seq,
 103                    "*** KCM statistics (%d MUX) ****\n",
 104                    knet->count);
 105
 106         seq_printf(seq,
 107                    "%-14s %-10s %-16s %-10s %-16s %-8s %-8s %-8s %-8s %s",
 108                    "Object",
 109                    "RX-Msgs",
 110                    "RX-Bytes",
 111                    "TX-Msgs",
 112                    "TX-Bytes",
 113                    "Recv-Q",
 114                    "Rmem",
 115                    "Send-Q",
 116                    "Smem",
 117                    "Status");
 118
 119         /* XXX: pdsts header stuff here */
 120         seq_puts(seq, "\n");
 121 }
 122
 123 static void kcm_format_sock(struct kcm_sock *kcm, struct seq_file *seq,
 124                             int i, int *len)
 125 {
 126         seq_printf(seq,
 127                    "   kcm-%-7u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8s ",
 128                    kcm->index,
 129                    kcm->stats.rx_msgs,
 130                    kcm->stats.rx_bytes,
 131                    kcm->stats.tx_msgs,
 132                    kcm->stats.tx_bytes,
 133                    kcm->sk.sk_receive_queue.qlen,
 134                    sk_rmem_alloc_get(&kcm->sk),
 135                    kcm->sk.sk_write_queue.qlen,
 136                    "-");
 137
 138         if (kcm->tx_psock)
 139                 seq_printf(seq, "Psck-%u ", kcm->tx_psock->index);
 140
 141         if (kcm->tx_wait)
 142                 seq_puts(seq, "TxWait ");
 143
 144         if (kcm->tx_wait_more)
 145                 seq_puts(seq, "WMore ");
 146
 147         if (kcm->rx_wait)
 148                 seq_puts(seq, "RxWait ");
 149
 150         seq_puts(seq, "\n");
 151 }
 152
 153 static void kcm_format_psock(struct kcm_psock *psock, struct seq_file *seq,
 154                              int i, int *len)
 155 {
 156         seq_printf(seq,
 157                    "   psock-%-5u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8d ",
 158                    psock->index,
 159                    psock->strp.stats.msgs,
 160                    psock->strp.stats.bytes,
 161                    psock->stats.tx_msgs,
 162                    psock->stats.tx_bytes,
 163                    psock->sk->sk_receive_queue.qlen,
 164                    atomic_read(&psock->sk->sk_rmem_alloc),
 165                    psock->sk->sk_write_queue.qlen,
 166                    refcount_read(&psock->sk->sk_wmem_alloc));
 167
 168         if (psock->done)
 169                 seq_puts(seq, "Done ");
 170
 171         if (psock->tx_stopped)
 172                 seq_puts(seq, "TxStop ");
 173
 174         if (psock->strp.stopped)
 175                 seq_puts(seq, "RxStop ");
 176
 177         if (psock->tx_kcm)
 178                 seq_printf(seq, "Rsvd-%d ", psock->tx_kcm->index);
 179
 180         if (!psock->strp.paused && !psock->ready_rx_msg) {
 181                 if (psock->sk->sk_receive_queue.qlen) {
 182                         if (psock->strp.need_bytes)
 183                                 seq_printf(seq, "RxWait=%u ",
 184                                            psock->strp.need_bytes);
 185                         else
 186                                 seq_printf(seq, "RxWait ");
 187                 }
 188         } else  {
 189                 if (psock->strp.paused)
 190                         seq_puts(seq, "RxPause ");
 191
 192                 if (psock->ready_rx_msg)
 193                         seq_puts(seq, "RdyRx ");
 194         }
 195
 196         seq_puts(seq, "\n");
 197 }
 198
 199 static void
 200 kcm_format_mux(struct kcm_mux *mux, loff_t idx, struct seq_file *seq)
 201 {
 202         int i, len;
 203         struct kcm_sock *kcm;
 204         struct kcm_psock *psock;
 205
 206         /* mux information */
 207         seq_printf(seq,
 208                    "%-6s%-8s %-10llu %-16llu %-10llu %-16llu %-8s %-8s %-8s %-8s ",
 209                    "mux", "",
 210                    mux->stats.rx_msgs,
 211                    mux->stats.rx_bytes,
 212                    mux->stats.tx_msgs,
 213                    mux->stats.tx_bytes,
 214                    "-", "-", "-", "-");
 215
 216         seq_printf(seq, "KCMs: %d, Psocks %d\n",
 217                    mux->kcm_socks_cnt, mux->psocks_cnt);
 218
 219         /* kcm sock information */
 220         i = 0;
 221         spin_lock_bh(&mux->lock);
 222         list_for_each_entry(kcm, &mux->kcm_socks, kcm_sock_list) {
 223                 kcm_format_sock(kcm, seq, i, &len);
 224                 i++;
 225         }
 226         i = 0;
 227         list_for_each_entry(psock, &mux->psocks, psock_list) {
 228                 kcm_format_psock(psock, seq, i, &len);
 229                 i++;
 230         }
 231         spin_unlock_bh(&mux->lock);
 232 }
 233
 234 static int kcm_seq_show(struct seq_file *seq, void *v)
 235 {
 236         struct kcm_proc_mux_state *mux_state;
 237
 238         mux_state = seq->private;
 239         if (v == SEQ_START_TOKEN) {
 240                 mux_state->idx = 0;
 241                 kcm_format_mux_header(seq);
 242         } else {
 243                 kcm_format_mux(v, mux_state->idx, seq);
 244                 mux_state->idx++;
 245         }
 246         return 0;
 247 }
 248
 249 static const struct file_operations kcm_seq_fops = {
 250         .open           = kcm_seq_open,
 251         .read           = seq_read,
 252         .llseek         = seq_lseek,
 253         .release        = seq_release_net,
 254 };
 255
 256 static struct kcm_seq_muxinfo kcm_seq_muxinfo = {
 257         .name           = "kcm",
 258         .seq_fops       = &kcm_seq_fops,
 259         .seq_ops        = {
 260                 .show   = kcm_seq_show,
 261                 .start  = kcm_seq_start,
 262                 .next   = kcm_seq_next,
 263                 .stop   = kcm_seq_stop,
 264         }
 265 };
 266
 267 static int kcm_proc_register(struct net *net, struct kcm_seq_muxinfo *muxinfo)
 268 {
 269         struct proc_dir_entry *p;
 270         int rc = 0;
 271
 272         p = proc_create_data(muxinfo->name, S_IRUGO, net->proc_net,
 273                              muxinfo->seq_fops, muxinfo);
 274         if (!p)
 275                 rc = -ENOMEM;
 276         return rc;
 277 }
 278 EXPORT_SYMBOL(kcm_proc_register);
 279
 280 static void kcm_proc_unregister(struct net *net,
 281                                 struct kcm_seq_muxinfo *muxinfo)
 282 {
 283         remove_proc_entry(muxinfo->name, net->proc_net);
 284 }
 285 EXPORT_SYMBOL(kcm_proc_unregister);
 286
 287 static int kcm_stats_seq_show(struct seq_file *seq, void *v)
 288 {
 289         struct kcm_psock_stats psock_stats;
 290         struct kcm_mux_stats mux_stats;
 291         struct strp_aggr_stats strp_stats;
 292         struct kcm_mux *mux;
 293         struct kcm_psock *psock;
 294         struct net *net = seq->private;
 295         struct kcm_net *knet = net_generic(net, kcm_net_id);
 296
 297         memset(&mux_stats, 0, sizeof(mux_stats));
 298         memset(&psock_stats, 0, sizeof(psock_stats));
 299         memset(&strp_stats, 0, sizeof(strp_stats));
 300
 301         mutex_lock(&knet->mutex);
 302
 303         aggregate_mux_stats(&knet->aggregate_mux_stats, &mux_stats);
 304         aggregate_psock_stats(&knet->aggregate_psock_stats,
 305                               &psock_stats);
 306         aggregate_strp_stats(&knet->aggregate_strp_stats,
 307                              &strp_stats);
 308
 309         list_for_each_entry_rcu(mux, &knet->mux_list, kcm_mux_list) {
 310                 spin_lock_bh(&mux->lock);
 311                 aggregate_mux_stats(&mux->stats, &mux_stats);
 312                 aggregate_psock_stats(&mux->aggregate_psock_stats,
 313                                       &psock_stats);
 314                 aggregate_strp_stats(&mux->aggregate_strp_stats,
 315                                      &strp_stats);
 316                 list_for_each_entry(psock, &mux->psocks, psock_list) {
 317                         aggregate_psock_stats(&psock->stats, &psock_stats);
 318                         save_strp_stats(&psock->strp, &strp_stats);
 319                 }
 320
 321                 spin_unlock_bh(&mux->lock);
 322         }
 323
 324         mutex_unlock(&knet->mutex);
 325
 326         seq_printf(seq,
 327                    "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s\n",
 328                    "MUX",
 329                    "RX-Msgs",
 330                    "RX-Bytes",
 331                    "TX-Msgs",
 332                    "TX-Bytes",
 333                    "TX-Retries",
 334                    "Attach",
 335                    "Unattach",
 336                    "UnattchRsvd",
 337                    "RX-RdyDrops");
 338
 339         seq_printf(seq,
 340                    "%-8s %-10llu %-16llu %-10llu %-16llu %-10u %-10u %-10u %-10u %-10u\n",
 341                    "",
 342                    mux_stats.rx_msgs,
 343                    mux_stats.rx_bytes,
 344                    mux_stats.tx_msgs,
 345                    mux_stats.tx_bytes,
 346                    mux_stats.tx_retries,
 347                    mux_stats.psock_attach,
 348                    mux_stats.psock_unattach_rsvd,
 349                    mux_stats.psock_unattach,
 350                    mux_stats.rx_ready_drops);
 351
 352         seq_printf(seq,
 353                    "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n",
 354                    "Psock",
 355                    "RX-Msgs",
 356                    "RX-Bytes",
 357                    "TX-Msgs",
 358                    "TX-Bytes",
 359                    "Reserved",
 360                    "Unreserved",
 361                    "RX-Aborts",
 362                    "RX-Intr",
 363                    "RX-Unrecov",
 364                    "RX-MemFail",
 365                    "RX-NeedMor",
 366                    "RX-BadLen",
 367                    "RX-TooBig",
 368                    "RX-Timeout",
 369                    "TX-Aborts");
 370
 371         seq_printf(seq,
 372                    "%-8s %-10llu %-16llu %-10llu %-16llu %-10llu %-10llu %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u\n",
 373                    "",
 374                    strp_stats.msgs,
 375                    strp_stats.bytes,
 376                    psock_stats.tx_msgs,
 377                    psock_stats.tx_bytes,
 378                    psock_stats.reserved,
 379                    psock_stats.unreserved,
 380                    strp_stats.aborts,
 381                    strp_stats.interrupted,
 382                    strp_stats.unrecov_intr,
 383                    strp_stats.mem_fail,
 384                    strp_stats.need_more_hdr,
 385                    strp_stats.bad_hdr_len,
 386                    strp_stats.msg_too_big,
 387                    strp_stats.msg_timeouts,
 388                    psock_stats.tx_aborts);
 389
 390         return 0;
 391 }
 392
 393 static int kcm_stats_seq_open(struct inode *inode, struct file *file)
 394 {
 395         return single_open_net(inode, file, kcm_stats_seq_show);
 396 }
 397
 398 static const struct file_operations kcm_stats_seq_fops = {
 399         .open    = kcm_stats_seq_open,
 400         .read    = seq_read,
 401         .llseek  = seq_lseek,
 402         .release = single_release_net,
 403 };
 404
 405 static int kcm_proc_init_net(struct net *net)
 406 {
 407         int err;
 408
 409         if (!proc_create("kcm_stats", S_IRUGO, net->proc_net,
 410                          &kcm_stats_seq_fops)) {
 411                 err = -ENOMEM;
 412                 goto out_kcm_stats;
 413         }
 414
 415         err = kcm_proc_register(net, &kcm_seq_muxinfo);
 416         if (err)
 417                 goto out_kcm;
 418
 419         return 0;
 420
 421 out_kcm:
 422         remove_proc_entry("kcm_stats", net->proc_net);
 423 out_kcm_stats:
 424         return err;
 425 }
 426
 427 static void kcm_proc_exit_net(struct net *net)
 428 {
 429         kcm_proc_unregister(net, &kcm_seq_muxinfo);
 430         remove_proc_entry("kcm_stats", net->proc_net);
 431 }
 432
 433 static struct pernet_operations kcm_net_ops = {
 434         .init = kcm_proc_init_net,
 435         .exit = kcm_proc_exit_net,
 436 };
 437
 438 int __init kcm_proc_init(void)
 439 {
 440         return register_pernet_subsys(&kcm_net_ops);
 441 }
 442
 443 void __exit kcm_proc_exit(void)
 444 {
 445         unregister_pernet_subsys(&kcm_net_ops);
 446 }
 447
 448 #endif /* CONFIG_PROC_FS */