Print this page 
XXXX adding PID information to netstat output
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/os/strsubr.c
          +++ new/usr/src/uts/common/os/strsubr.c
↓ open down ↓ 643 lines elided ↑ open up ↑ 
 644  644   */
 645  645  /* ARGSUSED */
 646  646  static int
 647  647  stream_head_constructor(void *buf, void *cdrarg, int kmflags)
 648  648  {
 649  649          stdata_t *stp = buf;
 650  650  
 651  651          mutex_init(&stp->sd_lock, NULL, MUTEX_DEFAULT, NULL);
 652  652          mutex_init(&stp->sd_reflock, NULL, MUTEX_DEFAULT, NULL);
 653  653          mutex_init(&stp->sd_qlock, NULL, MUTEX_DEFAULT, NULL);
      654 +        mutex_init(&stp->sd_pid_list_lock, NULL, MUTEX_DEFAULT, NULL);
 654  655          cv_init(&stp->sd_monitor, NULL, CV_DEFAULT, NULL);
 655  656          cv_init(&stp->sd_iocmonitor, NULL, CV_DEFAULT, NULL);
 656  657          cv_init(&stp->sd_refmonitor, NULL, CV_DEFAULT, NULL);
 657  658          cv_init(&stp->sd_qcv, NULL, CV_DEFAULT, NULL);
 658  659          cv_init(&stp->sd_zcopy_wait, NULL, CV_DEFAULT, NULL);
      660 +        list_create(&stp->sd_pid_list, sizeof (pid_node_t),
      661 +                offsetof(pid_node_t, pn_ref_link));
 659  662          stp->sd_wrq = NULL;
 660  663  
 661  664          return (0);
 662  665  }
 663  666  
 664  667  /* ARGSUSED */
 665  668  static void
 666  669  stream_head_destructor(void *buf, void *cdrarg)
 667  670  {
 668  671          stdata_t *stp = buf;
 669  672  
 670  673          mutex_destroy(&stp->sd_lock);
 671  674          mutex_destroy(&stp->sd_reflock);
 672  675          mutex_destroy(&stp->sd_qlock);
      676 +        mutex_destroy(&stp->sd_pid_list_lock);
 673  677          cv_destroy(&stp->sd_monitor);
 674  678          cv_destroy(&stp->sd_iocmonitor);
 675  679          cv_destroy(&stp->sd_refmonitor);
 676  680          cv_destroy(&stp->sd_qcv);
 677  681          cv_destroy(&stp->sd_zcopy_wait);
      682 +        list_destroy(&stp->sd_pid_list);
 678  683  }
 679  684  
 680  685  /*
 681  686   * Constructor/destructor routines for the queue cache
 682  687   */
 683  688  /* ARGSUSED */
 684  689  static int
 685  690  queue_constructor(void *buf, void *cdrarg, int kmflags)
 686  691  {
 687  692          queinfo_t *qip = buf;
↓ open down ↓ 2621 lines elided ↑ open up ↑ 
3309 3314  
3310 3315          return (stp);
3311 3316  }
3312 3317  
3313 3318  /*
3314 3319   * Free a stream head.
3315 3320   */
3316 3321  void
3317 3322  shfree(stdata_t *stp)
3318 3323  {
     3324 +        pid_node_t *pn;
     3325 +
3319 3326          ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
3320 3327  
3321 3328          stp->sd_wrq = NULL;
3322 3329  
3323 3330          mutex_enter(&stp->sd_qlock);
3324 3331          while (stp->sd_svcflags & STRS_SCHEDULED) {
3325 3332                  STRSTAT(strwaits);
3326 3333                  cv_wait(&stp->sd_qcv, &stp->sd_qlock);
3327 3334          }
3328 3335          mutex_exit(&stp->sd_qlock);
↓ open down ↓ 3 lines elided ↑ open up ↑ 
3332 3339                  SUMCHECK_CIPUTCTRL_COUNTS(stp->sd_ciputctrl,
3333 3340                      stp->sd_nciputctrl, 0);
3334 3341                  ASSERT(ciputctrl_cache != NULL);
3335 3342                  kmem_cache_free(ciputctrl_cache, stp->sd_ciputctrl);
3336 3343                  stp->sd_ciputctrl = NULL;
3337 3344                  stp->sd_nciputctrl = 0;
3338 3345          }
3339 3346          ASSERT(stp->sd_qhead == NULL);
3340 3347          ASSERT(stp->sd_qtail == NULL);
3341 3348          ASSERT(stp->sd_nqueues == 0);
     3349 +
     3350 +        mutex_enter(&stp->sd_pid_list_lock);
     3351 +        while ((pn = list_head(&stp->sd_pid_list)) != NULL) {
     3352 +                list_remove(&stp->sd_pid_list, pn);
     3353 +                kmem_free(pn, sizeof (*pn));
     3354 +        }
     3355 +        mutex_exit(&stp->sd_pid_list_lock);
     3356 +
3342 3357          kmem_cache_free(stream_head_cache, stp);
     3358 +}
     3359 +
     3360 +void
     3361 +sh_insert_pid(struct stdata *stp, pid_t pid)
     3362 +{
     3363 +        pid_node_t *pn;
     3364 +
     3365 +        mutex_enter(&stp->sd_pid_list_lock);
     3366 +        for (pn = list_head(&stp->sd_pid_list);
     3367 +            pn != NULL && pn->pn_pid != pid;
     3368 +            pn = list_next(&stp->sd_pid_list, pn))
     3369 +                ;
     3370 +
     3371 +        if (pn != NULL) {
     3372 +                pn->pn_count++;
     3373 +        } else {
     3374 +                pn = kmem_zalloc(sizeof (*pn), KM_SLEEP);
     3375 +                list_link_init(&pn->pn_ref_link);
     3376 +                pn->pn_pid = pid;
     3377 +                pn->pn_count = 1;
     3378 +                list_insert_tail(&stp->sd_pid_list, pn);
     3379 +        }
     3380 +        mutex_exit(&stp->sd_pid_list_lock);
     3381 +}
     3382 +
     3383 +void
     3384 +sh_remove_pid(struct stdata *stp, pid_t pid)
     3385 +{
     3386 +        pid_node_t *pn;
     3387 +
     3388 +        mutex_enter(&stp->sd_pid_list_lock);
     3389 +        for (pn = list_head(&stp->sd_pid_list);
     3390 +            pn != NULL && pn->pn_pid != pid;
     3391 +            pn = list_next(&stp->sd_pid_list, pn))
     3392 +                ;
     3393 +
     3394 +        if (pn != NULL) {
     3395 +                if (pn->pn_count > 1) {
     3396 +                        pn->pn_count--;
     3397 +                } else {
     3398 +                        list_remove(&stp->sd_pid_list, pn);
     3399 +                        kmem_free(pn, sizeof (*pn));
     3400 +                }
     3401 +        }
     3402 +        mutex_exit(&stp->sd_pid_list_lock);
     3403 +}
     3404 +
     3405 +mblk_t *
     3406 +sh_get_pid_mblk(struct stdata *stp)
     3407 +{
     3408 +        mblk_t *mblk;
     3409 +        int sz, n = 0;
     3410 +        pid_t *pids;
     3411 +        pid_node_t *pn;
     3412 +        conn_pid_info_t *cpi;
     3413 +
     3414 +        mutex_enter(&stp->sd_pid_list_lock);
     3415 +
     3416 +        n = list_numnodes(&stp->sd_pid_list);
     3417 +        sz = sizeof (conn_pid_info_t);
     3418 +        sz += (n > 1) ? ((n - 1) * sizeof (pid_t)) : 0;
     3419 +        if ((mblk = allocb(sz, BPRI_HI)) == NULL) {
     3420 +                mutex_exit(&stp->sd_pid_list_lock);
     3421 +                return (NULL);
     3422 +        }
     3423 +        mblk->b_wptr += sz;
     3424 +        cpi = (conn_pid_info_t *)mblk->b_datap->db_base;
     3425 +        cpi->cpi_magic = CONN_PID_INFO_MGC;
     3426 +        cpi->cpi_contents = CONN_PID_INFO_XTI;
     3427 +        cpi->cpi_pids_cnt = n;
     3428 +        cpi->cpi_tot_size = sz;
     3429 +        cpi->cpi_pids[0] = 0;
     3430 +
     3431 +        if (cpi->cpi_pids_cnt > 0) {
     3432 +                pids = cpi->cpi_pids;
     3433 +                for (pn = list_head(&stp->sd_pid_list); pn != NULL;
     3434 +                    pids++, pn = list_next(&stp->sd_pid_list, pn))
     3435 +                        *pids = pn->pn_pid;
     3436 +        }
     3437 +        mutex_exit(&stp->sd_pid_list_lock);
     3438 +        return (mblk);
3343 3439  }
3344 3440  
3345 3441  /*
3346 3442   * Allocate a pair of queues and a syncq for the pair
3347 3443   */
3348 3444  queue_t *
3349 3445  allocq(void)
3350 3446  {
3351 3447          queinfo_t *qip;
3352 3448          queue_t *qp, *wqp;
↓ open down ↓ 5444 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX