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

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/os/fm.c
          +++ new/usr/src/uts/common/os/fm.c
↓ open down ↓ 509 lines elided ↑ open up ↑
 510  510   * before publication may occur.
 511  511   */
 512  512  void
 513  513  fm_ereport_post(nvlist_t *ereport, int evc_flag)
 514  514  {
 515  515          size_t nvl_size = 0;
 516  516          evchan_t *error_chan;
 517  517  
 518  518          (void) nvlist_size(ereport, &nvl_size, NV_ENCODE_NATIVE);
 519  519          if (nvl_size > ERPT_DATA_SZ || nvl_size == 0) {
 520      -                atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
      520 +                atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
 521  521                  return;
 522  522          }
 523  523  
 524  524          if (sysevent_evc_bind(FM_ERROR_CHAN, &error_chan,
 525  525              EVCH_CREAT|EVCH_HOLD_PEND) != 0) {
 526      -                atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
      526 +                atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
 527  527                  return;
 528  528          }
 529  529  
 530  530          if (sysevent_evc_publish(error_chan, EC_FM, ESC_FM_ERROR,
 531  531              SUNW_VENDOR, FM_PUB, ereport, evc_flag) != 0) {
 532      -                atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
      532 +                atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
 533  533                  (void) sysevent_evc_unbind(error_chan);
 534  534                  return;
 535  535          }
 536  536          (void) sysevent_evc_unbind(error_chan);
 537  537  }
 538  538  
 539  539  /*
 540  540   * Wrapppers for FM nvlist allocators
 541  541   */
 542  542  /* ARGSUSED */
↓ open down ↓ 241 lines elided ↑ open up ↑
 784  784          int ret;
 785  785          const char *name;
 786  786          va_list ap;
 787  787  
 788  788          va_start(ap, payload);
 789  789          name = va_arg(ap, char *);
 790  790          ret = i_fm_payload_set(payload, name, ap);
 791  791          va_end(ap);
 792  792  
 793  793          if (ret)
 794      -                atomic_add_64(
 795      -                    &erpt_kstat_data.payload_set_failed.value.ui64, 1);
      794 +                atomic_inc_64(&erpt_kstat_data.payload_set_failed.value.ui64);
 796  795  }
 797  796  
 798  797  /*
 799  798   * Set-up and validate the members of an ereport event according to:
 800  799   *
 801  800   *      Member name             Type            Value
 802  801   *      ====================================================
 803  802   *      class                   string          ereport
 804  803   *      version                 uint8_t         0
 805  804   *      ena                     uint64_t        <ena>
↓ open down ↓ 12 lines elided ↑ open up ↑
 818  817  void
 819  818  fm_ereport_set(nvlist_t *ereport, int version, const char *erpt_class,
 820  819      uint64_t ena, const nvlist_t *detector, ...)
 821  820  {
 822  821          char ereport_class[FM_MAX_CLASS];
 823  822          const char *name;
 824  823          va_list ap;
 825  824          int ret;
 826  825  
 827  826          if (version != FM_EREPORT_VERS0) {
 828      -                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
      827 +                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
 829  828                  return;
 830  829          }
 831  830  
 832  831          (void) snprintf(ereport_class, FM_MAX_CLASS, "%s.%s",
 833  832              FM_EREPORT_CLASS, erpt_class);
 834  833          if (nvlist_add_string(ereport, FM_CLASS, ereport_class) != 0) {
 835      -                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
      834 +                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
 836  835                  return;
 837  836          }
 838  837  
 839  838          if (nvlist_add_uint64(ereport, FM_EREPORT_ENA, ena)) {
 840      -                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
      839 +                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
 841  840          }
 842  841  
 843  842          if (nvlist_add_nvlist(ereport, FM_EREPORT_DETECTOR,
 844  843              (nvlist_t *)detector) != 0) {
 845      -                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
      844 +                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
 846  845          }
 847  846  
 848  847          va_start(ap, detector);
 849  848          name = va_arg(ap, const char *);
 850  849          ret = i_fm_payload_set(ereport, name, ap);
 851  850          va_end(ap);
 852  851  
 853  852          if (ret)
 854      -                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
      853 +                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
 855  854  }
 856  855  
 857  856  /*
 858  857   * Set-up and validate the members of an hc fmri according to;
 859  858   *
 860  859   *      Member name             Type            Value
 861  860   *      ===================================================
 862  861   *      version                 uint8_t         0
 863  862   *      auth                    nvlist_t        <auth>
 864  863   *      hc-name                 string          <name>
↓ open down ↓ 2 lines elided ↑ open up ↑
 867  866   * Note that auth and hc-id are optional members.
 868  867   */
 869  868  
 870  869  #define HC_MAXPAIRS     20
 871  870  #define HC_MAXNAMELEN   50
 872  871  
 873  872  static int
 874  873  fm_fmri_hc_set_common(nvlist_t *fmri, int version, const nvlist_t *auth)
 875  874  {
 876  875          if (version != FM_HC_SCHEME_VERSION) {
 877      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      876 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 878  877                  return (0);
 879  878          }
 880  879  
 881  880          if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0 ||
 882  881              nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC) != 0) {
 883      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      882 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 884  883                  return (0);
 885  884          }
 886  885  
 887  886          if (auth != NULL && nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
 888  887              (nvlist_t *)auth) != 0) {
 889      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      888 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 890  889                  return (0);
 891  890          }
 892  891  
 893  892          return (1);
 894  893  }
 895  894  
 896  895  void
 897  896  fm_fmri_hc_set(nvlist_t *fmri, int version, const nvlist_t *auth,
 898  897      nvlist_t *snvl, int npairs, ...)
 899  898  {
↓ open down ↓ 11 lines elided ↑ open up ↑
 911  910          for (i = 0; i < npairs; i++) {
 912  911                  const char *name = va_arg(ap, const char *);
 913  912                  uint32_t id = va_arg(ap, uint32_t);
 914  913                  char idstr[11];
 915  914  
 916  915                  (void) snprintf(idstr, sizeof (idstr), "%u", id);
 917  916  
 918  917                  pairs[i] = fm_nvlist_create(nva);
 919  918                  if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 ||
 920  919                      nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0) {
 921      -                        atomic_add_64(
 922      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      920 +                        atomic_inc_64(
      921 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
 923  922                  }
 924  923          }
 925  924          va_end(ap);
 926  925  
 927  926          if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs, npairs) != 0)
 928      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      927 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 929  928  
 930  929          for (i = 0; i < npairs; i++)
 931  930                  fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);
 932  931  
 933  932          if (snvl != NULL) {
 934  933                  if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
 935      -                        atomic_add_64(
 936      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      934 +                        atomic_inc_64(
      935 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
 937  936                  }
 938  937          }
 939  938  }
 940  939  
 941  940  /*
 942  941   * Set-up and validate the members of an dev fmri according to:
 943  942   *
 944  943   *      Member name             Type            Value
 945  944   *      ====================================================
 946  945   *      version                 uint8_t         0
↓ open down ↓ 4 lines elided ↑ open up ↑
 951  950   *
 952  951   * Note that auth and devid are optional members.
 953  952   */
 954  953  void
 955  954  fm_fmri_dev_set(nvlist_t *fmri_dev, int version, const nvlist_t *auth,
 956  955      const char *devpath, const char *devid, const char *tpl0)
 957  956  {
 958  957          int err = 0;
 959  958  
 960  959          if (version != DEV_SCHEME_VERSION0) {
 961      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      960 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 962  961                  return;
 963  962          }
 964  963  
 965  964          err |= nvlist_add_uint8(fmri_dev, FM_VERSION, version);
 966  965          err |= nvlist_add_string(fmri_dev, FM_FMRI_SCHEME, FM_FMRI_SCHEME_DEV);
 967  966  
 968  967          if (auth != NULL) {
 969  968                  err |= nvlist_add_nvlist(fmri_dev, FM_FMRI_AUTHORITY,
 970  969                      (nvlist_t *)auth);
 971  970          }
 972  971  
 973  972          err |= nvlist_add_string(fmri_dev, FM_FMRI_DEV_PATH, devpath);
 974  973  
 975  974          if (devid != NULL)
 976  975                  err |= nvlist_add_string(fmri_dev, FM_FMRI_DEV_ID, devid);
 977  976  
 978  977          if (tpl0 != NULL)
 979  978                  err |= nvlist_add_string(fmri_dev, FM_FMRI_DEV_TGTPTLUN0, tpl0);
 980  979  
 981  980          if (err)
 982      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
      981 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 983  982  
 984  983  }
 985  984  
 986  985  /*
 987  986   * Set-up and validate the members of an cpu fmri according to:
 988  987   *
 989  988   *      Member name             Type            Value
 990  989   *      ====================================================
 991  990   *      version                 uint8_t         0
 992  991   *      auth                    nvlist_t        <auth>
↓ open down ↓ 4 lines elided ↑ open up ↑
 997  996   * Note that auth, cpumask, serial are optional members.
 998  997   *
 999  998   */
1000  999  void
1001 1000  fm_fmri_cpu_set(nvlist_t *fmri_cpu, int version, const nvlist_t *auth,
1002 1001      uint32_t cpu_id, uint8_t *cpu_maskp, const char *serial_idp)
1003 1002  {
1004 1003          uint64_t *failedp = &erpt_kstat_data.fmri_set_failed.value.ui64;
1005 1004  
1006 1005          if (version < CPU_SCHEME_VERSION1) {
1007      -                atomic_add_64(failedp, 1);
     1006 +                atomic_inc_64(failedp);
1008 1007                  return;
1009 1008          }
1010 1009  
1011 1010          if (nvlist_add_uint8(fmri_cpu, FM_VERSION, version) != 0) {
1012      -                atomic_add_64(failedp, 1);
     1011 +                atomic_inc_64(failedp);
1013 1012                  return;
1014 1013          }
1015 1014  
1016 1015          if (nvlist_add_string(fmri_cpu, FM_FMRI_SCHEME,
1017 1016              FM_FMRI_SCHEME_CPU) != 0) {
1018      -                atomic_add_64(failedp, 1);
     1017 +                atomic_inc_64(failedp);
1019 1018                  return;
1020 1019          }
1021 1020  
1022 1021          if (auth != NULL && nvlist_add_nvlist(fmri_cpu, FM_FMRI_AUTHORITY,
1023 1022              (nvlist_t *)auth) != 0)
1024      -                atomic_add_64(failedp, 1);
     1023 +                atomic_inc_64(failedp);
1025 1024  
1026 1025          if (nvlist_add_uint32(fmri_cpu, FM_FMRI_CPU_ID, cpu_id) != 0)
1027      -                atomic_add_64(failedp, 1);
     1026 +                atomic_inc_64(failedp);
1028 1027  
1029 1028          if (cpu_maskp != NULL && nvlist_add_uint8(fmri_cpu, FM_FMRI_CPU_MASK,
1030 1029              *cpu_maskp) != 0)
1031      -                atomic_add_64(failedp, 1);
     1030 +                atomic_inc_64(failedp);
1032 1031  
1033 1032          if (serial_idp == NULL || nvlist_add_string(fmri_cpu,
1034 1033              FM_FMRI_CPU_SERIAL_ID, (char *)serial_idp) != 0)
1035      -                        atomic_add_64(failedp, 1);
     1034 +                        atomic_inc_64(failedp);
1036 1035  }
1037 1036  
1038 1037  /*
1039 1038   * Set-up and validate the members of a mem according to:
1040 1039   *
1041 1040   *      Member name             Type            Value
1042 1041   *      ====================================================
1043 1042   *      version                 uint8_t         0
1044 1043   *      auth                    nvlist_t        <auth>          [optional]
1045 1044   *      unum                    string          <unum>
1046 1045   *      serial                  string          <serial>        [optional*]
1047 1046   *      offset                  uint64_t        <offset>        [optional]
1048 1047   *
1049 1048   *      * serial is required if offset is present
1050 1049   */
1051 1050  void
1052 1051  fm_fmri_mem_set(nvlist_t *fmri, int version, const nvlist_t *auth,
1053 1052      const char *unum, const char *serial, uint64_t offset)
1054 1053  {
1055 1054          if (version != MEM_SCHEME_VERSION0) {
1056      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1055 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1057 1056                  return;
1058 1057          }
1059 1058  
1060 1059          if (!serial && (offset != (uint64_t)-1)) {
1061      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1060 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1062 1061                  return;
1063 1062          }
1064 1063  
1065 1064          if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
1066      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1065 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1067 1066                  return;
1068 1067          }
1069 1068  
1070 1069          if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_MEM) != 0) {
1071      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1070 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1072 1071                  return;
1073 1072          }
1074 1073  
1075 1074          if (auth != NULL) {
1076 1075                  if (nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
1077 1076                      (nvlist_t *)auth) != 0) {
1078      -                        atomic_add_64(
1079      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1077 +                        atomic_inc_64(
     1078 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1080 1079                  }
1081 1080          }
1082 1081  
1083 1082          if (nvlist_add_string(fmri, FM_FMRI_MEM_UNUM, unum) != 0) {
1084      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1083 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1085 1084          }
1086 1085  
1087 1086          if (serial != NULL) {
1088 1087                  if (nvlist_add_string_array(fmri, FM_FMRI_MEM_SERIAL_ID,
1089 1088                      (char **)&serial, 1) != 0) {
1090      -                        atomic_add_64(
1091      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1089 +                        atomic_inc_64(
     1090 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1092 1091                  }
1093      -                if (offset != (uint64_t)-1) {
1094      -                        if (nvlist_add_uint64(fmri, FM_FMRI_MEM_OFFSET,
1095      -                            offset) != 0) {
1096      -                                atomic_add_64(&erpt_kstat_data.
1097      -                                    fmri_set_failed.value.ui64, 1);
1098      -                        }
     1092 +                if (offset != (uint64_t)-1 && nvlist_add_uint64(fmri,
     1093 +                    FM_FMRI_MEM_OFFSET, offset) != 0) {
     1094 +                        atomic_inc_64(
     1095 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1099 1096                  }
1100 1097          }
1101 1098  }
1102 1099  
1103 1100  void
1104 1101  fm_fmri_zfs_set(nvlist_t *fmri, int version, uint64_t pool_guid,
1105 1102      uint64_t vdev_guid)
1106 1103  {
1107 1104          if (version != ZFS_SCHEME_VERSION0) {
1108      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1105 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1109 1106                  return;
1110 1107          }
1111 1108  
1112 1109          if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
1113      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1110 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1114 1111                  return;
1115 1112          }
1116 1113  
1117 1114          if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_ZFS) != 0) {
1118      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1115 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1119 1116                  return;
1120 1117          }
1121 1118  
1122 1119          if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_POOL, pool_guid) != 0) {
1123      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1120 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1124 1121          }
1125 1122  
1126 1123          if (vdev_guid != 0) {
1127 1124                  if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_VDEV, vdev_guid) != 0) {
1128      -                        atomic_add_64(
1129      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1125 +                        atomic_inc_64(
     1126 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1130 1127                  }
1131 1128          }
1132 1129  }
1133 1130  
1134 1131  uint64_t
1135 1132  fm_ena_increment(uint64_t ena)
1136 1133  {
1137 1134          uint64_t new_ena;
1138 1135  
1139 1136          switch (ENA_FORMAT(ena)) {
↓ open down ↓ 159 lines elided ↑ open up ↑
1299 1296          char *hcname, *hcid;
1300 1297  
1301 1298          if (!fm_fmri_hc_set_common(fmri, version, auth))
1302 1299                  return;
1303 1300  
1304 1301          /*
1305 1302           * copy the bboard nvpairs to the pairs array
1306 1303           */
1307 1304          if (nvlist_lookup_nvlist_array(bboard, FM_FMRI_HC_LIST, &hcl, &n)
1308 1305              != 0) {
1309      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1306 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1310 1307                  return;
1311 1308          }
1312 1309  
1313 1310          for (i = 0; i < n; i++) {
1314 1311                  if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_NAME,
1315 1312                      &hcname) != 0) {
1316      -                        atomic_add_64(
1317      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1313 +                        atomic_inc_64(
     1314 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1318 1315                          return;
1319 1316                  }
1320 1317                  if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_ID, &hcid) != 0) {
1321      -                        atomic_add_64(
1322      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1318 +                        atomic_inc_64(
     1319 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1323 1320                          return;
1324 1321                  }
1325 1322  
1326 1323                  pairs[i] = fm_nvlist_create(nva);
1327 1324                  if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, hcname) != 0 ||
1328 1325                      nvlist_add_string(pairs[i], FM_FMRI_HC_ID, hcid) != 0) {
1329 1326                          for (j = 0; j <= i; j++) {
1330 1327                                  if (pairs[j] != NULL)
1331 1328                                          fm_nvlist_destroy(pairs[j],
1332 1329                                              FM_NVA_RETAIN);
1333 1330                          }
1334      -                        atomic_add_64(
1335      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1331 +                        atomic_inc_64(
     1332 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1336 1333                          return;
1337 1334                  }
1338 1335          }
1339 1336  
1340 1337          /*
1341 1338           * create the pairs from passed in pairs
1342 1339           */
1343 1340          npairs = MIN(npairs, HC_MAXPAIRS);
1344 1341  
1345 1342          va_start(ap, npairs);
↓ open down ↓ 3 lines elided ↑ open up ↑
1349 1346                  char idstr[11];
1350 1347                  (void) snprintf(idstr, sizeof (idstr), "%u", id);
1351 1348                  pairs[i] = fm_nvlist_create(nva);
1352 1349                  if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 ||
1353 1350                      nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0) {
1354 1351                          for (j = 0; j <= i; j++) {
1355 1352                                  if (pairs[j] != NULL)
1356 1353                                          fm_nvlist_destroy(pairs[j],
1357 1354                                              FM_NVA_RETAIN);
1358 1355                          }
1359      -                        atomic_add_64(
1360      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1356 +                        atomic_inc_64(
     1357 +                            &erpt_kstat_data.fmri_set_failed.value.ui64);
1361 1358                          return;
1362 1359                  }
1363 1360          }
1364 1361          va_end(ap);
1365 1362  
1366 1363          /*
1367 1364           * Create the fmri hc list
1368 1365           */
1369 1366          if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs,
1370 1367              npairs + n) != 0) {
1371      -                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1368 +                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
1372 1369                  return;
1373 1370          }
1374 1371  
1375 1372          for (i = 0; i < npairs + n; i++) {
1376 1373                          fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);
1377 1374          }
1378 1375  
1379 1376          if (snvl != NULL) {
1380 1377                  if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
1381      -                        atomic_add_64(
1382      -                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
     1378 +                        atomic_inc_64(
     1379 +                                &erpt_kstat_data.fmri_set_failed.value.ui64);
1383 1380                          return;
1384 1381                  }
1385 1382          }
1386 1383  }
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX