Print this page
XXXX adding PID information to netstat output

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/inet/udp/udp_stats.c
          +++ new/usr/src/uts/common/inet/udp/udp_stats.c
↓ open down ↓ 45 lines elided ↑ open up ↑
  46   46  /*
  47   47   * return SNMP stuff in buffer in mpdata. We don't hold any lock and report
  48   48   * information that can be changing beneath us.
  49   49   */
  50   50  mblk_t *
  51   51  udp_snmp_get(queue_t *q, mblk_t *mpctl, boolean_t legacy_req)
  52   52  {
  53   53          mblk_t                  *mpdata;
  54   54          mblk_t                  *mp_conn_ctl;
  55   55          mblk_t                  *mp_attr_ctl;
       56 +        mblk_t                  *mp_pidnode_ctl;
  56   57          mblk_t                  *mp6_conn_ctl;
  57   58          mblk_t                  *mp6_attr_ctl;
       59 +        mblk_t                  *mp6_pidnode_ctl;
  58   60          mblk_t                  *mp_conn_tail;
  59   61          mblk_t                  *mp_attr_tail;
       62 +        mblk_t                  *mp_pidnode_tail;
  60   63          mblk_t                  *mp6_conn_tail;
  61   64          mblk_t                  *mp6_attr_tail;
       65 +        mblk_t                  *mp6_pidnode_tail;
  62   66          struct opthdr           *optp;
  63   67          mib2_udpEntry_t         ude;
  64   68          mib2_udp6Entry_t        ude6;
  65   69          mib2_transportMLPEntry_t mlp;
  66   70          int                     state;
  67   71          zoneid_t                zoneid;
  68   72          int                     i;
  69   73          connf_t                 *connfp;
  70   74          conn_t                  *connp = Q_TO_CONN(q);
  71   75          int                     v4_conn_idx;
  72   76          int                     v6_conn_idx;
  73   77          boolean_t               needattr;
  74   78          udp_t                   *udp;
  75   79          ip_stack_t              *ipst = connp->conn_netstack->netstack_ip;
  76   80          udp_stack_t             *us = connp->conn_netstack->netstack_udp;
  77   81          mblk_t                  *mp2ctl;
  78   82          mib2_udp_t              udp_mib;
  79   83          size_t                  udp_mib_size, ude_size, ude6_size;
  80   84  
       85 +        conn_pid_node_list_hdr_t        *cph;
       86 +
  81   87  
  82   88          /*
  83   89           * make a copy of the original message
  84   90           */
  85   91          mp2ctl = copymsg(mpctl);
  86   92  
  87   93          mp_conn_ctl = mp_attr_ctl = mp6_conn_ctl = NULL;
  88   94          if (mpctl == NULL ||
  89   95              (mpdata = mpctl->b_cont) == NULL ||
  90   96              (mp_conn_ctl = copymsg(mpctl)) == NULL ||
  91   97              (mp_attr_ctl = copymsg(mpctl)) == NULL ||
       98 +            (mp_pidnode_ctl = copymsg(mpctl)) == NULL ||
  92   99              (mp6_conn_ctl = copymsg(mpctl)) == NULL ||
  93      -            (mp6_attr_ctl = copymsg(mpctl)) == NULL) {
      100 +            (mp6_attr_ctl = copymsg(mpctl)) == NULL ||
      101 +            (mp6_pidnode_ctl = copymsg(mpctl)) == NULL) {
  94  102                  freemsg(mp_conn_ctl);
  95  103                  freemsg(mp_attr_ctl);
      104 +                freemsg(mp_pidnode_ctl);
  96  105                  freemsg(mp6_conn_ctl);
      106 +                freemsg(mp6_attr_ctl);
      107 +                freemsg(mp6_pidnode_ctl);
  97  108                  freemsg(mpctl);
  98  109                  freemsg(mp2ctl);
  99  110                  return (0);
 100  111          }
 101  112  
 102  113          zoneid = connp->conn_zoneid;
 103  114  
 104  115          if (legacy_req) {
 105  116                  udp_mib_size = LEGACY_MIB_SIZE(&udp_mib, mib2_udp_t);
 106  117                  ude_size = LEGACY_MIB_SIZE(&ude, mib2_udpEntry_t);
↓ open down ↓ 21 lines elided ↑ open up ↑
 128  139          SYNC32_MIB(&udp_mib, udpOutDatagrams, udpHCOutDatagrams);
 129  140  
 130  141          optp = (struct opthdr *)&mpctl->b_rptr[sizeof (struct T_optmgmt_ack)];
 131  142          optp->level = MIB2_UDP;
 132  143          optp->name = 0;
 133  144          (void) snmp_append_data(mpdata, (char *)&udp_mib, udp_mib_size);
 134  145          optp->len = msgdsize(mpdata);
 135  146          qreply(q, mpctl);
 136  147  
 137  148          mp_conn_tail = mp_attr_tail = mp6_conn_tail = mp6_attr_tail = NULL;
      149 +        mp_pidnode_tail = mp6_pidnode_tail = NULL;
 138  150          v4_conn_idx = v6_conn_idx = 0;
 139  151  
 140  152          for (i = 0; i < CONN_G_HASH_SIZE; i++) {
 141  153                  connfp = &ipst->ips_ipcl_globalhash_fanout[i];
 142  154                  connp = NULL;
 143  155  
 144  156                  while ((connp = ipcl_get_next_conn(connfp, connp,
 145  157                      IPCL_UDPCONN))) {
 146  158                          udp = connp->conn_udp;
 147  159                          if (zoneid != connp->conn_zoneid)
↓ open down ↓ 94 lines elided ↑ open up ↑
 242  254                                   */
 243  255                                  ude.udpInstance = (uint32_t)(uintptr_t)udp;
 244  256                                  ude.udpCreationProcess =
 245  257                                      (connp->conn_cpid < 0) ?
 246  258                                      MIB2_UNKNOWN_PROCESS :
 247  259                                      connp->conn_cpid;
 248  260                                  ude.udpCreationTime = connp->conn_open_time;
 249  261  
 250  262                                  (void) snmp_append_data2(mp_conn_ctl->b_cont,
 251  263                                      &mp_conn_tail, (char *)&ude, ude_size);
      264 +                                /* my data */
      265 +                                (void) snmp_append_data2(mp_pidnode_ctl->b_cont,
      266 +                                    &mp_pidnode_tail, (char *)&ude, ude_size);
      267 +
      268 +                                cph = conn_get_pid_list(connp);
      269 +                                (void) snmp_append_data2(mp_pidnode_ctl->b_cont,
      270 +                                    &mp_pidnode_tail, (char *)cph,
      271 +                                    cph->cph_tot_size);
      272 +
      273 +                                kmem_free(cph, cph->cph_tot_size);
      274 +                                /* end of my data */
      275 +
 252  276                                  mlp.tme_connidx = v4_conn_idx++;
 253  277                                  if (needattr)
 254  278                                          (void) snmp_append_data2(
 255  279                                              mp_attr_ctl->b_cont, &mp_attr_tail,
 256  280                                              (char *)&mlp, sizeof (mlp));
 257  281                          }
 258  282                          if (connp->conn_ipversion == IPV6_VERSION) {
 259  283                                  ude6.udp6EntryInfo.ue_state  = state;
 260  284                                  ude6.udp6LocalAddress = connp->conn_laddr_v6;
 261  285                                  ude6.udp6LocalPort = ntohs(connp->conn_lport);
↓ open down ↓ 23 lines elided ↑ open up ↑
 285  309                                   */
 286  310                                  ude6.udp6Instance = (uint32_t)(uintptr_t)udp;
 287  311                                  ude6.udp6CreationProcess =
 288  312                                      (connp->conn_cpid < 0) ?
 289  313                                      MIB2_UNKNOWN_PROCESS :
 290  314                                      connp->conn_cpid;
 291  315                                  ude6.udp6CreationTime = connp->conn_open_time;
 292  316  
 293  317                                  (void) snmp_append_data2(mp6_conn_ctl->b_cont,
 294  318                                      &mp6_conn_tail, (char *)&ude6, ude6_size);
      319 +                                /* my dat */
      320 +                                (void) snmp_append_data2(
      321 +                                    mp6_pidnode_ctl->b_cont, &mp6_pidnode_tail,
      322 +                                    (char *)&ude6, ude6_size);
      323 +
      324 +                                cph = conn_get_pid_list(connp);
      325 +                                (void) snmp_append_data2(
      326 +                                    mp6_pidnode_ctl->b_cont, &mp6_pidnode_tail,
      327 +                                    (char *)cph, cph->cph_tot_size);
      328 +
      329 +                                kmem_free(cph, cph->cph_tot_size);
      330 +                                /* end of my data */
 295  331                                  mlp.tme_connidx = v6_conn_idx++;
 296  332                                  if (needattr)
 297  333                                          (void) snmp_append_data2(
 298  334                                              mp6_attr_ctl->b_cont,
 299  335                                              &mp6_attr_tail, (char *)&mlp,
 300  336                                              sizeof (mlp));
 301  337                          }
 302  338                  }
 303  339          }
 304  340  
↓ open down ↓ 9 lines elided ↑ open up ↑
 314  350          optp = (struct opthdr *)&mp_attr_ctl->b_rptr[
 315  351              sizeof (struct T_optmgmt_ack)];
 316  352          optp->level = MIB2_UDP;
 317  353          optp->name = EXPER_XPORT_MLP;
 318  354          optp->len = msgdsize(mp_attr_ctl->b_cont);
 319  355          if (optp->len == 0)
 320  356                  freemsg(mp_attr_ctl);
 321  357          else
 322  358                  qreply(q, mp_attr_ctl);
 323  359  
      360 +        /* table of EXPER_XPORT_PROC_INFO  ipv4 */
      361 +        optp = (struct opthdr *)&mp_pidnode_ctl->b_rptr[
      362 +            sizeof (struct T_optmgmt_ack)];
      363 +        optp->level = MIB2_UDP;
      364 +        optp->name = EXPER_XPORT_PROC_INFO;
      365 +        optp->len = msgdsize(mp_pidnode_ctl->b_cont);
      366 +        if (optp->len == 0)
      367 +                freemsg(mp_pidnode_ctl);
      368 +        else
      369 +                qreply(q, mp_pidnode_ctl);
      370 +
 324  371          /* IPv6 UDP endpoints */
 325  372          optp = (struct opthdr *)&mp6_conn_ctl->b_rptr[
 326  373              sizeof (struct T_optmgmt_ack)];
 327  374          optp->level = MIB2_UDP6;
 328  375          optp->name = MIB2_UDP6_ENTRY;
 329  376          optp->len = msgdsize(mp6_conn_ctl->b_cont);
 330  377          qreply(q, mp6_conn_ctl);
 331  378  
 332  379          /* table of MLP attributes... */
 333  380          optp = (struct opthdr *)&mp6_attr_ctl->b_rptr[
 334  381              sizeof (struct T_optmgmt_ack)];
 335  382          optp->level = MIB2_UDP6;
 336  383          optp->name = EXPER_XPORT_MLP;
 337  384          optp->len = msgdsize(mp6_attr_ctl->b_cont);
 338  385          if (optp->len == 0)
 339  386                  freemsg(mp6_attr_ctl);
 340  387          else
 341  388                  qreply(q, mp6_attr_ctl);
      389 +
      390 +        /* table of EXPER_XPORT_PROC_INFO  ipv6 */
      391 +        optp = (struct opthdr *)&mp6_pidnode_ctl->b_rptr[
      392 +            sizeof (struct T_optmgmt_ack)];
      393 +        optp->level = MIB2_UDP6;
      394 +        optp->name = EXPER_XPORT_PROC_INFO;
      395 +        optp->len = msgdsize(mp6_pidnode_ctl->b_cont);
      396 +        if (optp->len == 0)
      397 +                freemsg(mp6_pidnode_ctl);
      398 +        else
      399 +                qreply(q, mp6_pidnode_ctl);
 342  400  
 343  401          return (mp2ctl);
 344  402  }
 345  403  
 346  404  /*
 347  405   * Return 0 if invalid set request, 1 otherwise, including non-udp requests.
 348  406   * NOTE: Per MIB-II, UDP has no writable data.
 349  407   * TODO:  If this ever actually tries to set anything, it needs to be
 350  408   * to do the appropriate locking.
 351  409   */
↓ open down ↓ 238 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX