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


  62         return (res);
  63 }
  64 
  65 void
  66 ksid_hold(ksid_t *ks)
  67 {
  68         if (ks->ks_domain != NULL)
  69                 ksiddomain_hold(ks->ks_domain);
  70 }
  71 
  72 void
  73 ksid_rele(ksid_t *ks)
  74 {
  75         if (ks->ks_domain != NULL)
  76                 ksiddomain_rele(ks->ks_domain);
  77 }
  78 
  79 void
  80 ksiddomain_hold(ksiddomain_t *kd)
  81 {
  82         atomic_add_32(&kd->kd_ref, 1);
  83 }
  84 
  85 void
  86 ksiddomain_rele(ksiddomain_t *kd)
  87 {
  88         if (atomic_add_32_nv(&kd->kd_ref, -1) == 0) {
  89                 /*
  90                  * The kd reference can only be incremented from 0 when
  91                  * the sid_lock is held; so we lock and then check need to
  92                  * check for 0 again.
  93                  */
  94                 mutex_enter(&sid_lock);
  95                 if (kd->kd_ref == 0) {
  96                         avl_remove(&sid_tree, kd);
  97                         kmem_free(kd->kd_name, kd->kd_len);
  98                         kmem_free(kd, sizeof (*kd));
  99                 }
 100                 mutex_exit(&sid_lock);
 101         }
 102 }
 103 
 104 void
 105 ksidlist_hold(ksidlist_t *ksl)
 106 {
 107         atomic_add_32(&ksl->ksl_ref, 1);
 108 }
 109 
 110 void
 111 ksidlist_rele(ksidlist_t *ksl)
 112 {
 113         if (atomic_add_32_nv(&ksl->ksl_ref, -1) == 0) {
 114                 int i;
 115 
 116                 for (i = 0; i < ksl->ksl_nsid; i++)
 117                         ksid_rele(&ksl->ksl_sids[i]);
 118 
 119                 kmem_free(ksl, KSIDLIST_MEM(ksl->ksl_nsid));
 120         }
 121 }
 122 
 123 static int
 124 ksid_cmp(const void *a, const void *b)
 125 {
 126         const ksiddomain_t *ap = a;
 127         const ksiddomain_t *bp = b;
 128         int res;
 129 
 130         res = strcmp(ap->kd_name, bp->kd_name);
 131         if (res > 0)
 132                 return (1);
 133         if (res != 0)


 244         if (org->kr_ref == 1)
 245                 return (org);
 246         new = kcrsid_alloc();
 247 
 248         /* Copy, then update reference counts */
 249         *new = *org;
 250         new->kr_ref = 1;
 251         for (ki = 0; ki < KSID_COUNT; ki++)
 252                 ksid_hold(&new->kr_sidx[ki]);
 253 
 254         if (new->kr_sidlist != NULL)
 255                 ksidlist_hold(new->kr_sidlist);
 256 
 257         kcrsid_rele(org);
 258         return (new);
 259 }
 260 
 261 void
 262 kcrsid_hold(credsid_t *kcr)
 263 {
 264         atomic_add_32(&kcr->kr_ref, 1);
 265 }
 266 
 267 void
 268 kcrsid_rele(credsid_t *kcr)
 269 {
 270         if (atomic_add_32_nv(&kcr->kr_ref, -1) == 0) {
 271                 ksid_index_t i;
 272 
 273                 for (i = 0; i < KSID_COUNT; i++)
 274                         ksid_rele(&kcr->kr_sidx[i]);
 275 
 276                 if (kcr->kr_sidlist != NULL)
 277                         ksidlist_rele(kcr->kr_sidlist);
 278 
 279                 kmem_free(kcr, sizeof (*kcr));
 280         }
 281 }
 282 
 283 /*
 284  * Copy the SID credential into a previously allocated piece of memory.
 285  */
 286 void
 287 kcrsidcopy_to(const credsid_t *okcr, credsid_t *nkcr)
 288 {
 289         int i;
 290 




  62         return (res);
  63 }
  64 
  65 void
  66 ksid_hold(ksid_t *ks)
  67 {
  68         if (ks->ks_domain != NULL)
  69                 ksiddomain_hold(ks->ks_domain);
  70 }
  71 
  72 void
  73 ksid_rele(ksid_t *ks)
  74 {
  75         if (ks->ks_domain != NULL)
  76                 ksiddomain_rele(ks->ks_domain);
  77 }
  78 
  79 void
  80 ksiddomain_hold(ksiddomain_t *kd)
  81 {
  82         atomic_inc_32(&kd->kd_ref);
  83 }
  84 
  85 void
  86 ksiddomain_rele(ksiddomain_t *kd)
  87 {
  88         if (atomic_dec_32_nv(&kd->kd_ref) == 0) {
  89                 /*
  90                  * The kd reference can only be incremented from 0 when
  91                  * the sid_lock is held; so we lock and then check need to
  92                  * check for 0 again.
  93                  */
  94                 mutex_enter(&sid_lock);
  95                 if (kd->kd_ref == 0) {
  96                         avl_remove(&sid_tree, kd);
  97                         kmem_free(kd->kd_name, kd->kd_len);
  98                         kmem_free(kd, sizeof (*kd));
  99                 }
 100                 mutex_exit(&sid_lock);
 101         }
 102 }
 103 
 104 void
 105 ksidlist_hold(ksidlist_t *ksl)
 106 {
 107         atomic_inc_32(&ksl->ksl_ref);
 108 }
 109 
 110 void
 111 ksidlist_rele(ksidlist_t *ksl)
 112 {
 113         if (atomic_dec_32_nv(&ksl->ksl_ref) == 0) {
 114                 int i;
 115 
 116                 for (i = 0; i < ksl->ksl_nsid; i++)
 117                         ksid_rele(&ksl->ksl_sids[i]);
 118 
 119                 kmem_free(ksl, KSIDLIST_MEM(ksl->ksl_nsid));
 120         }
 121 }
 122 
 123 static int
 124 ksid_cmp(const void *a, const void *b)
 125 {
 126         const ksiddomain_t *ap = a;
 127         const ksiddomain_t *bp = b;
 128         int res;
 129 
 130         res = strcmp(ap->kd_name, bp->kd_name);
 131         if (res > 0)
 132                 return (1);
 133         if (res != 0)


 244         if (org->kr_ref == 1)
 245                 return (org);
 246         new = kcrsid_alloc();
 247 
 248         /* Copy, then update reference counts */
 249         *new = *org;
 250         new->kr_ref = 1;
 251         for (ki = 0; ki < KSID_COUNT; ki++)
 252                 ksid_hold(&new->kr_sidx[ki]);
 253 
 254         if (new->kr_sidlist != NULL)
 255                 ksidlist_hold(new->kr_sidlist);
 256 
 257         kcrsid_rele(org);
 258         return (new);
 259 }
 260 
 261 void
 262 kcrsid_hold(credsid_t *kcr)
 263 {
 264         atomic_inc_32(&kcr->kr_ref);
 265 }
 266 
 267 void
 268 kcrsid_rele(credsid_t *kcr)
 269 {
 270         if (atomic_dec_32_nv(&kcr->kr_ref) == 0) {
 271                 ksid_index_t i;
 272 
 273                 for (i = 0; i < KSID_COUNT; i++)
 274                         ksid_rele(&kcr->kr_sidx[i]);
 275 
 276                 if (kcr->kr_sidlist != NULL)
 277                         ksidlist_rele(kcr->kr_sidlist);
 278 
 279                 kmem_free(kcr, sizeof (*kcr));
 280         }
 281 }
 282 
 283 /*
 284  * Copy the SID credential into a previously allocated piece of memory.
 285  */
 286 void
 287 kcrsidcopy_to(const credsid_t *okcr, credsid_t *nkcr)
 288 {
 289         int i;
 290