Print this page
5045 use atomic_{inc,dec}_* instead of atomic_add_*

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/io/rsm/rsm.c
          +++ new/usr/src/uts/common/io/rsm/rsm.c
↓ open down ↓ 4035 lines elided ↑ open up ↑
4036 4036                  rw_enter(&rsm_import_segs.rsmhash_rw, RW_READER);
4037 4037  
4038 4038                  p = (rsmresource_t *)rsmhash_getbkt(&rsm_import_segs, hashval);
4039 4039  
4040 4040                  for (; p; p = p->rsmrc_next) {
4041 4041                          if ((p->rsmrc_key == msg->rsmipc_key) &&
4042 4042                              (p->rsmrc_node == src_node)) {
4043 4043                                  seg = (rsmseg_t *)p;
4044 4044                                  rsmseglock_acquire(seg);
4045 4045  
4046      -                                atomic_add_32(&seg->s_pollevent, 1);
     4046 +                                atomic_inc_32(&seg->s_pollevent);
4047 4047  
4048 4048                                  if (seg->s_pollflag & RSM_SEGMENT_POLL)
4049 4049                                          pollwakeup(&seg->s_poll, POLLRDNORM);
4050 4050  
4051 4051                                  rsmseglock_release(seg);
4052 4052                          }
4053 4053                  }
4054 4054  
4055 4055                  rw_exit(&rsm_import_segs.rsmhash_rw);
4056 4056          } else {
4057 4057                  /* This is for an export segment */
4058 4058                  seg = rsmexport_lookup(msg->rsmipc_key);
4059 4059                  if (!seg) {
4060 4060                          DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
4061 4061                              "rsm_intr_event done: exp seg not found\n"));
4062 4062                          return;
4063 4063                  }
4064 4064  
4065 4065                  ASSERT(rsmseglock_held(seg));
4066 4066  
4067      -                atomic_add_32(&seg->s_pollevent, 1);
     4067 +                atomic_inc_32(&seg->s_pollevent);
4068 4068  
4069 4069                  /*
4070 4070                   * We must hold the segment lock here, or else the segment
4071 4071                   * can be freed while pollwakeup is using it. This implies
4072 4072                   * that we MUST NOT grab the segment lock during rsm_chpoll,
4073 4073                   * as outlined in the chpoll(2) man page.
4074 4074                   */
4075 4075                  if (seg->s_pollflag & RSM_SEGMENT_POLL)
4076 4076                          pollwakeup(&seg->s_poll, POLLRDNORM);
4077 4077  
↓ open down ↓ 1417 lines elided ↑ open up ↑
5495 5495  
5496 5496                  no_reply_cnt++;
5497 5497                  rele_sendq_token(sendq_token);
5498 5498                  if (e != RSM_SUCCESS) {
5499 5499                          DBG_PRINTF((category, RSM_ERR,
5500 5500                              "rsm: rsmipc_send no reply send"
5501 5501                              " err = %d no reply count = %d\n",
5502 5502                              e, no_reply_cnt));
5503 5503                          ASSERT(e != RSMERR_QUEUE_FENCE_UP &&
5504 5504                              e != RSMERR_BAD_BARRIER_HNDL);
5505      -                        atomic_add_64(&rsm_ipcsend_errcnt, 1);
     5505 +                        atomic_inc_64(&rsm_ipcsend_errcnt);
5506 5506                          goto again;
5507 5507                  } else {
5508 5508                          DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
5509 5509                              "rsmipc_send done\n"));
5510 5510                          return (e);
5511 5511                  }
5512 5512  
5513 5513          }
5514 5514  
5515 5515          if (req == NULL) {
↓ open down ↓ 10 lines elided ↑ open up ↑
5526 5526                  is.is_data = (void *)reply;
5527 5527                  is.is_size = sizeof (*reply);
5528 5528                  is.is_flags = RSM_INTR_SEND_DELIVER | RSM_INTR_SEND_SLEEP;
5529 5529                  is.is_wait = 0;
5530 5530                  e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is, NULL);
5531 5531                  rele_sendq_token(sendq_token);
5532 5532                  if (e != RSM_SUCCESS) {
5533 5533                          DBG_PRINTF((category, RSM_ERR,
5534 5534                              "rsm: rsmipc_send reply send"
5535 5535                              " err = %d\n", e));
5536      -                        atomic_add_64(&rsm_ipcsend_errcnt, 1);
     5536 +                        atomic_inc_64(&rsm_ipcsend_errcnt);
5537 5537                          goto again;
5538 5538                  } else {
5539 5539                          DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
5540 5540                              "rsmipc_send done\n"));
5541 5541                          return (e);
5542 5542                  }
5543 5543          }
5544 5544  
5545 5545          /* Reply needed */
5546 5546          rslot = rsmipc_alloc(); /* allocate a new ipc slot */
↓ open down ↓ 85 lines elided ↑ open up ↑
5632 5632                  } else
5633 5633                          e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is,
5634 5634                              NULL);
5635 5635  
5636 5636                  if (e != RSM_SUCCESS) {
5637 5637                          DBG_PRINTF((category, RSM_ERR,
5638 5638                              "rsm: rsmipc_send rsmpi send err = %d\n", e));
5639 5639                          RSMIPC_CLEAR(rslot, RSMIPC_PENDING);
5640 5640                          rsmipc_free(rslot);
5641 5641                          rele_sendq_token(sendq_token);
5642      -                        atomic_add_64(&rsm_ipcsend_errcnt, 1);
     5642 +                        atomic_inc_64(&rsm_ipcsend_errcnt);
5643 5643                          goto again;
5644 5644                  }
5645 5645  
5646 5646                  /* wait for a reply signal, a SIGINT, or 5 sec. timeout */
5647 5647                  e = cv_reltimedwait_sig(&rslot->rsmipc_cv, &rslot->rsmipc_lock,
5648 5648                      drv_usectohz(5000000), TR_CLOCK_TICK);
5649 5649                  if (e < 0) {
5650 5650                          /* timed out - retry */
5651 5651                          e = RSMERR_TIMEOUT;
5652 5652                  } else if (e == 0) {
↓ open down ↓ 275 lines elided ↑ open up ↑
5928 5928  
5929 5929                  ASSERT(e != RSMERR_QUEUE_FENCE_UP &&
5930 5930                      e != RSMERR_BAD_BARRIER_HNDL);
5931 5931  
5932 5932                  mutex_enter(&path->mutex);
5933 5933  
5934 5934                  if (e == RSM_SUCCESS) {
5935 5935                          break;
5936 5936                  }
5937 5937                  /* error counter for statistics */
5938      -                atomic_add_64(&rsm_ctrlmsg_errcnt, 1);
     5938 +                atomic_inc_64(&rsm_ctrlmsg_errcnt);
5939 5939  
5940 5940                  DBG_PRINTF((category, RSM_ERR,
5941 5941                      "rsmipc_send_controlmsg:rsm_send error=%d", e));
5942 5942  
5943 5943                  if (++retry_cnt == min_retry_cnt) { /* backoff before retry */
5944 5944                          (void) cv_reltimedwait(&path->sendq_token.sendq_cv,
5945 5945                              &path->mutex, drv_usectohz(10000), TR_CLOCK_TICK);
5946 5946                          retry_cnt = 0;
5947 5947                  }
5948 5948          } while (path->state == RSMKA_PATH_ACTIVE);
↓ open down ↓ 493 lines elided ↑ open up ↑
6442 6442                  seg->s_handle.in = sharedp->rsmsi_handle;
6443 6443  
6444 6444          }
6445 6445  
6446 6446          seg->s_state = RSM_STATE_CONNECT;
6447 6447  
6448 6448  
6449 6449          seg->s_flags &= ~RSM_IMPORT_DUMMY;      /* clear dummy flag */
6450 6450          if (bar_va) {
6451 6451                  /* increment generation number on barrier page */
6452      -                atomic_add_16(bar_va + seg->s_hdr.rsmrc_num, 1);
     6452 +                atomic_inc_16(bar_va + seg->s_hdr.rsmrc_num);
6453 6453                  /* return user off into barrier page where status will be */
6454 6454                  msg->off = (int)seg->s_hdr.rsmrc_num;
6455 6455                  msg->gnum = bar_va[msg->off];   /* gnum race */
6456 6456          } else {
6457 6457                  msg->off = 0;
6458 6458                  msg->gnum = 0;  /* gnum race */
6459 6459          }
6460 6460  
6461 6461          msg->len = (int)sharedp->rsmsi_seglen;
6462 6462          msg->rnum = seg->s_minor;
↓ open down ↓ 215 lines elided ↑ open up ↑
6678 6678                  mutex_destroy(&sharedp->rsmsi_lock);
6679 6679                  cv_destroy(&sharedp->rsmsi_cv);
6680 6680                  kmem_free((void *)(sharedp), sizeof (rsm_import_share_t));
6681 6681  
6682 6682          } else {
6683 6683                  rsmsharelock_release(seg);
6684 6684          }
6685 6685  
6686 6686          /* increment generation number on barrier page */
6687 6687          if (bar_va) {
6688      -                atomic_add_16(bar_va + seg->s_hdr.rsmrc_num, 1);
     6688 +                atomic_inc_16(bar_va + seg->s_hdr.rsmrc_num);
6689 6689          }
6690 6690  
6691 6691          /*
6692 6692           * The following needs to be done after any
6693 6693           * rsmsharelock calls which use seg->s_share.
6694 6694           */
6695 6695          seg->s_share = NULL;
6696 6696  
6697 6697          seg->s_state = RSM_STATE_DISCONNECT;
6698 6698          /* signal anyone waiting in the CONN_QUIESCE state */
↓ open down ↓ 578 lines elided ↑ open up ↑
7277 7277                  rnum = event_list[i].rnum;
7278 7278                  event_list[i].revent = 0;
7279 7279                  /* get the segment structure */
7280 7280                  seg = (rsmseg_t *)rsmresource_lookup(rnum, RSM_LOCK);
7281 7281                  if (seg) {
7282 7282                          DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
7283 7283                              "consumeevent_ioctl: rnum(%d) seg(%p)\n", rnum,
7284 7284                              seg));
7285 7285                          if (seg->s_pollevent) {
7286 7286                                  /* consume the event */
7287      -                                atomic_add_32(&seg->s_pollevent, -1);
     7287 +                                atomic_dec_32(&seg->s_pollevent);
7288 7288                                  event_list[i].revent = POLLRDNORM;
7289 7289                          }
7290 7290                          rsmseglock_release(seg);
7291 7291                  }
7292 7292          }
7293 7293  
7294 7294          if ((rc = rsm_consumeevent_copyout(&msg, event_list, mode)) !=
7295 7295              RSM_SUCCESS) {
7296 7296                  return (rc);
7297 7297          }
↓ open down ↓ 2383 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX