Print this page
XXXX introduce drv_sectohz

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/io/ib/clients/rdsv3/rdsv3_impl.c
          +++ new/usr/src/uts/common/io/ib/clients/rdsv3/rdsv3_impl.c
↓ open down ↓ 557 lines elided ↑ open up ↑
 558  558                  ASSERT(list_is_empty(&wq->wq_queue));
 559  559                  break;
 560  560  
 561  561          case RDSV3_WQ_THREAD_RUNNING:
 562  562                  wq->wq_state = RDSV3_WQ_THREAD_FLUSHING;
 563  563                  /* FALLTHRU */
 564  564          case RDSV3_WQ_THREAD_FLUSHING:
 565  565                  /* already flushing, wait until the flushing is complete */
 566  566                  do {
 567  567                          mutex_exit(&wq->wq_lock);
 568      -                        delay(drv_usectohz(1000000));
      568 +                        delay(drv_sectohz(1));
 569  569                          mutex_enter(&wq->wq_lock);
 570  570                  } while (wq->wq_state == RDSV3_WQ_THREAD_FLUSHING);
 571  571                  break;
 572  572          case RDSV3_WQ_THREAD_EXITING:
 573  573                  mutex_exit(&wq->wq_lock);
 574  574                  rdsv3_worker_thread(wq);
 575  575                  return;
 576  576          }
 577  577          mutex_exit(&wq->wq_lock);
 578  578  
↓ open down ↓ 16 lines elided ↑ open up ↑
 595  595  
 596  596          switch (wq->wq_state) {
 597  597          case RDSV3_WQ_THREAD_RUNNING:
 598  598                  list_insert_tail(&wq->wq_queue, wp);
 599  599                  mutex_exit(&wq->wq_lock);
 600  600                  break;
 601  601  
 602  602          case RDSV3_WQ_THREAD_FLUSHING:
 603  603                  do {
 604  604                          mutex_exit(&wq->wq_lock);
 605      -                        delay(drv_usectohz(1000000));
      605 +                        delay(drv_sectohz(1));
 606  606                          mutex_enter(&wq->wq_lock);
 607  607                  } while (wq->wq_state == RDSV3_WQ_THREAD_FLUSHING);
 608  608  
 609  609                  if (wq->wq_state == RDSV3_WQ_THREAD_RUNNING) {
 610  610                          list_insert_tail(&wq->wq_queue, wp);
 611  611                          mutex_exit(&wq->wq_lock);
 612  612                          break;
 613  613                  }
 614  614                  /* FALLTHRU */
 615  615  
↓ open down ↓ 113 lines elided ↑ open up ↑
 729  729  {
 730  730          RDSV3_DPRINTF2("rdsv3_destroy_workqueue", "Enter");
 731  731  
 732  732          ASSERT(wq);
 733  733  
 734  734          mutex_enter(&wq->wq_lock);
 735  735          wq->wq_state = RDSV3_WQ_THREAD_EXITING;
 736  736  
 737  737          while (wq->wq_pending > 0) {
 738  738                  mutex_exit(&wq->wq_lock);
 739      -                delay(drv_usectohz(1000000));
      739 +                delay(drv_sectohz(1));
 740  740                  mutex_enter(&wq->wq_lock);
 741  741          };
 742  742          mutex_exit(&wq->wq_lock);
 743  743  
 744  744          rdsv3_flush_workqueue(wq);
 745  745  
 746  746          list_destroy(&wq->wq_queue);
 747  747          mutex_destroy(&wq->wq_lock);
 748  748          kmem_free(wq, sizeof (rdsv3_workqueue_struct_t));
 749  749  
↓ open down ↓ 35 lines elided ↑ open up ↑
 785  785                  RDSV3_DPRINTF2(__FILE__, "kmem_zalloc failed for wq");
 786  786                  ddi_taskq_destroy(rdsv3_taskq);
 787  787                  return (NULL);
 788  788          }
 789  789  
 790  790          list_create(&wq->wq_queue, sizeof (struct rdsv3_work_s),
 791  791              offsetof(struct rdsv3_work_s, work_item));
 792  792          mutex_init(&wq->wq_lock, NULL, MUTEX_DRIVER, NULL);
 793  793          wq->wq_state = RDSV3_WQ_THREAD_IDLE;
 794  794          wq->wq_pending = 0;
 795      -        rdsv3_one_sec_in_hz = drv_usectohz(1000000);
      795 +        rdsv3_one_sec_in_hz = drv_sectohz(1);
 796  796  
 797  797          RDSV3_DPRINTF2("create_singlethread_workqueue", "Return");
 798  798  
 799  799          return (wq);
 800  800  }
 801  801  
 802  802  /*
 803  803   * Implementation for struct sock
 804  804   */
 805  805  
↓ open down ↓ 534 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX