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

@@ -515,23 +515,23 @@
         size_t nvl_size = 0;
         evchan_t *error_chan;
 
         (void) nvlist_size(ereport, &nvl_size, NV_ENCODE_NATIVE);
         if (nvl_size > ERPT_DATA_SZ || nvl_size == 0) {
-                atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
                 return;
         }
 
         if (sysevent_evc_bind(FM_ERROR_CHAN, &error_chan,
             EVCH_CREAT|EVCH_HOLD_PEND) != 0) {
-                atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
                 return;
         }
 
         if (sysevent_evc_publish(error_chan, EC_FM, ESC_FM_ERROR,
             SUNW_VENDOR, FM_PUB, ereport, evc_flag) != 0) {
-                atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
                 (void) sysevent_evc_unbind(error_chan);
                 return;
         }
         (void) sysevent_evc_unbind(error_chan);
 }

@@ -789,12 +789,11 @@
         name = va_arg(ap, char *);
         ret = i_fm_payload_set(payload, name, ap);
         va_end(ap);
 
         if (ret)
-                atomic_add_64(
-                    &erpt_kstat_data.payload_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.payload_set_failed.value.ui64);
 }
 
 /*
  * Set-up and validate the members of an ereport event according to:
  *

@@ -823,37 +822,37 @@
         const char *name;
         va_list ap;
         int ret;
 
         if (version != FM_EREPORT_VERS0) {
-                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
                 return;
         }
 
         (void) snprintf(ereport_class, FM_MAX_CLASS, "%s.%s",
             FM_EREPORT_CLASS, erpt_class);
         if (nvlist_add_string(ereport, FM_CLASS, ereport_class) != 0) {
-                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
                 return;
         }
 
         if (nvlist_add_uint64(ereport, FM_EREPORT_ENA, ena)) {
-                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
         }
 
         if (nvlist_add_nvlist(ereport, FM_EREPORT_DETECTOR,
             (nvlist_t *)detector) != 0) {
-                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
         }
 
         va_start(ap, detector);
         name = va_arg(ap, const char *);
         ret = i_fm_payload_set(ereport, name, ap);
         va_end(ap);
 
         if (ret)
-                atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
 }
 
 /*
  * Set-up and validate the members of an hc fmri according to;
  *

@@ -872,23 +871,23 @@
 
 static int
 fm_fmri_hc_set_common(nvlist_t *fmri, int version, const nvlist_t *auth)
 {
         if (version != FM_HC_SCHEME_VERSION) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return (0);
         }
 
         if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0 ||
             nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return (0);
         }
 
         if (auth != NULL && nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
             (nvlist_t *)auth) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return (0);
         }
 
         return (1);
 }

@@ -916,26 +915,26 @@
                 (void) snprintf(idstr, sizeof (idstr), "%u", id);
 
                 pairs[i] = fm_nvlist_create(nva);
                 if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 ||
                     nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                 }
         }
         va_end(ap);
 
         if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs, npairs) != 0)
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 
         for (i = 0; i < npairs; i++)
                 fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);
 
         if (snvl != NULL) {
                 if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                 }
         }
 }
 
 /*

@@ -956,11 +955,11 @@
     const char *devpath, const char *devid, const char *tpl0)
 {
         int err = 0;
 
         if (version != DEV_SCHEME_VERSION0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         err |= nvlist_add_uint8(fmri_dev, FM_VERSION, version);
         err |= nvlist_add_string(fmri_dev, FM_FMRI_SCHEME, FM_FMRI_SCHEME_DEV);

@@ -977,11 +976,11 @@
 
         if (tpl0 != NULL)
                 err |= nvlist_add_string(fmri_dev, FM_FMRI_DEV_TGTPTLUN0, tpl0);
 
         if (err)
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
 
 }
 
 /*
  * Set-up and validate the members of an cpu fmri according to:

@@ -1002,39 +1001,39 @@
     uint32_t cpu_id, uint8_t *cpu_maskp, const char *serial_idp)
 {
         uint64_t *failedp = &erpt_kstat_data.fmri_set_failed.value.ui64;
 
         if (version < CPU_SCHEME_VERSION1) {
-                atomic_add_64(failedp, 1);
+                atomic_inc_64(failedp);
                 return;
         }
 
         if (nvlist_add_uint8(fmri_cpu, FM_VERSION, version) != 0) {
-                atomic_add_64(failedp, 1);
+                atomic_inc_64(failedp);
                 return;
         }
 
         if (nvlist_add_string(fmri_cpu, FM_FMRI_SCHEME,
             FM_FMRI_SCHEME_CPU) != 0) {
-                atomic_add_64(failedp, 1);
+                atomic_inc_64(failedp);
                 return;
         }
 
         if (auth != NULL && nvlist_add_nvlist(fmri_cpu, FM_FMRI_AUTHORITY,
             (nvlist_t *)auth) != 0)
-                atomic_add_64(failedp, 1);
+                atomic_inc_64(failedp);
 
         if (nvlist_add_uint32(fmri_cpu, FM_FMRI_CPU_ID, cpu_id) != 0)
-                atomic_add_64(failedp, 1);
+                atomic_inc_64(failedp);
 
         if (cpu_maskp != NULL && nvlist_add_uint8(fmri_cpu, FM_FMRI_CPU_MASK,
             *cpu_maskp) != 0)
-                atomic_add_64(failedp, 1);
+                atomic_inc_64(failedp);
 
         if (serial_idp == NULL || nvlist_add_string(fmri_cpu,
             FM_FMRI_CPU_SERIAL_ID, (char *)serial_idp) != 0)
-                        atomic_add_64(failedp, 1);
+                        atomic_inc_64(failedp);
 }
 
 /*
  * Set-up and validate the members of a mem according to:
  *

@@ -1051,84 +1050,82 @@
 void
 fm_fmri_mem_set(nvlist_t *fmri, int version, const nvlist_t *auth,
     const char *unum, const char *serial, uint64_t offset)
 {
         if (version != MEM_SCHEME_VERSION0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         if (!serial && (offset != (uint64_t)-1)) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_MEM) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         if (auth != NULL) {
                 if (nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
                     (nvlist_t *)auth) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                 }
         }
 
         if (nvlist_add_string(fmri, FM_FMRI_MEM_UNUM, unum) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
         }
 
         if (serial != NULL) {
                 if (nvlist_add_string_array(fmri, FM_FMRI_MEM_SERIAL_ID,
                     (char **)&serial, 1) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
-                }
-                if (offset != (uint64_t)-1) {
-                        if (nvlist_add_uint64(fmri, FM_FMRI_MEM_OFFSET,
-                            offset) != 0) {
-                                atomic_add_64(&erpt_kstat_data.
-                                    fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                         }
+                if (offset != (uint64_t)-1 && nvlist_add_uint64(fmri,
+                    FM_FMRI_MEM_OFFSET, offset) != 0) {
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                 }
         }
 }
 
 void
 fm_fmri_zfs_set(nvlist_t *fmri, int version, uint64_t pool_guid,
     uint64_t vdev_guid)
 {
         if (version != ZFS_SCHEME_VERSION0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_ZFS) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_POOL, pool_guid) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
         }
 
         if (vdev_guid != 0) {
                 if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_VDEV, vdev_guid) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                 }
         }
 }
 
 uint64_t

@@ -1304,24 +1301,24 @@
         /*
          * copy the bboard nvpairs to the pairs array
          */
         if (nvlist_lookup_nvlist_array(bboard, FM_FMRI_HC_LIST, &hcl, &n)
             != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         for (i = 0; i < n; i++) {
                 if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_NAME,
                     &hcname) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                         return;
                 }
                 if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_ID, &hcid) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                         return;
                 }
 
                 pairs[i] = fm_nvlist_create(nva);
                 if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, hcname) != 0 ||

@@ -1329,12 +1326,12 @@
                         for (j = 0; j <= i; j++) {
                                 if (pairs[j] != NULL)
                                         fm_nvlist_destroy(pairs[j],
                                             FM_NVA_RETAIN);
                         }
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                         return;
                 }
         }
 
         /*

@@ -1354,33 +1351,33 @@
                         for (j = 0; j <= i; j++) {
                                 if (pairs[j] != NULL)
                                         fm_nvlist_destroy(pairs[j],
                                             FM_NVA_RETAIN);
                         }
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                            &erpt_kstat_data.fmri_set_failed.value.ui64);
                         return;
                 }
         }
         va_end(ap);
 
         /*
          * Create the fmri hc list
          */
         if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs,
             npairs + n) != 0) {
-                atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
                 return;
         }
 
         for (i = 0; i < npairs + n; i++) {
                         fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);
         }
 
         if (snvl != NULL) {
                 if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
-                        atomic_add_64(
-                            &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
+                        atomic_inc_64(
+                                &erpt_kstat_data.fmri_set_failed.value.ui64);
                         return;
                 }
         }
 }