Print this page
patch as-lock-macro-simplification

@@ -1316,13 +1316,13 @@
             NULL, NULL, NULL, 0);
 
         /*
          * We grab the first hat for the kernel,
          */
-        AS_LOCK_ENTER(&kas, &kas.a_lock, RW_WRITER);
+        AS_LOCK_ENTER(&kas, RW_WRITER);
         kas.a_hat = hat_alloc(&kas);
-        AS_LOCK_EXIT(&kas, &kas.a_lock);
+        AS_LOCK_EXIT(&kas);
 
         /*
          * Initialize hblk_reserve.
          */
         ((struct hme_blk *)hblk_reserve)->hblk_nextpa =

@@ -1461,11 +1461,11 @@
         sfmmu_t *sfmmup;
         int i;
         uint64_t cnum;
         extern uint_t get_color_start(struct as *);
 
-        ASSERT(AS_WRITE_HELD(as, &as->a_lock));
+        ASSERT(AS_WRITE_HELD(as));
         sfmmup = kmem_cache_alloc(sfmmuid_cache, KM_SLEEP);
         sfmmup->sfmmu_as = as;
         sfmmup->sfmmu_flags = 0;
         sfmmup->sfmmu_tteflags = 0;
         sfmmup->sfmmu_rtteflags = 0;

@@ -1915,11 +1915,11 @@
  * Called from as_free when an address space is being destroyed.
  */
 void
 hat_free_start(struct hat *sfmmup)
 {
-        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as));
         ASSERT(sfmmup != ksfmmup);
         ASSERT(sfmmup->sfmmu_xhat_provider == NULL);
 
         sfmmup->sfmmu_free = 1;
         if (sfmmup->sfmmu_scdp != NULL) {

@@ -2245,12 +2245,11 @@
                 ASSERT(!SFMMU_IS_SHMERID_VALID(rid));
                 XHAT_MEMLOAD(hat, addr, pp, attr, flags);
                 return;
         }
 
-        ASSERT((hat == ksfmmup) ||
-            AS_LOCK_HELD(hat->sfmmu_as, &hat->sfmmu_as->a_lock));
+        ASSERT((hat == ksfmmup) || AS_LOCK_HELD(hat->sfmmu_as));
 
         if (flags & ~SFMMU_LOAD_ALLFLAG)
                 cmn_err(CE_NOTE, "hat_memload: unsupported flags %d",
                     flags & ~SFMMU_LOAD_ALLFLAG);
 

@@ -2301,12 +2300,11 @@
                 return;
         }
 
         ASSERT(!(flags & ~SFMMU_LOAD_ALLFLAG));
         ASSERT(!(attr & ~SFMMU_LOAD_ALLATTR));
-        ASSERT((hat == ksfmmup) ||
-            AS_LOCK_HELD(hat->sfmmu_as, &hat->sfmmu_as->a_lock));
+        ASSERT((hat == ksfmmup) || AS_LOCK_HELD(hat->sfmmu_as));
         if (len == 0)
                 panic("hat_devload: zero len");
         if (flags & ~SFMMU_LOAD_ALLFLAG)
                 cmn_err(CE_NOTE, "hat_devload: unsupported flags %d",
                     flags & ~SFMMU_LOAD_ALLFLAG);

@@ -3971,12 +3969,11 @@
         caddr_t endaddr;
 
         ASSERT(sfmmup != NULL);
         ASSERT(sfmmup->sfmmu_xhat_provider == NULL);
 
-        ASSERT((sfmmup == ksfmmup) ||
-            AS_LOCK_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT((sfmmup == ksfmmup) || AS_LOCK_HELD(sfmmup->sfmmu_as));
         ASSERT((len & MMU_PAGEOFFSET) == 0);
         endaddr = addr + len;
         hblktag.htag_id = sfmmup;
         hblktag.htag_rid = SFMMU_INVALID_SHMERID;
 

@@ -4768,12 +4765,11 @@
         tte_t tte;
 
         ASSERT(sfmmup != NULL);
         ASSERT(sfmmup->sfmmu_xhat_provider == NULL);
 
-        ASSERT((sfmmup == ksfmmup) ||
-            AS_LOCK_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT((sfmmup == ksfmmup) || AS_LOCK_HELD(sfmmup->sfmmu_as));
 
         if (sfmmup == ksfmmup) {
                 while ((pfn = sfmmu_vatopfn(addr, sfmmup, &tte))
                     == PFN_SUSPENDED) {
                         sfmmu_vatopfn_suspended(addr, sfmmup, &tte);

@@ -4918,12 +4914,11 @@
         cpuset_t cpuset;
         demap_range_t dmr;
 
         CPUSET_ZERO(cpuset);
 
-        ASSERT((sfmmup == ksfmmup) ||
-            AS_LOCK_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT((sfmmup == ksfmmup) || AS_LOCK_HELD(sfmmup->sfmmu_as));
         ASSERT((len & MMU_PAGEOFFSET) == 0);
         ASSERT(((uintptr_t)addr & MMU_PAGEOFFSET) == 0);
 
         if ((attr & PROT_USER) && (mode != SFMMU_CLRATTR) &&
             ((addr + len) > (caddr_t)USERLIMIT)) {

@@ -5712,11 +5707,11 @@
                         xhat_unload_callback_all(sfmmup->sfmmu_as, addr,
                             len, flags, callback);
         }
 
         ASSERT((sfmmup == ksfmmup) || (flags & HAT_UNLOAD_OTHER) || \
-            AS_LOCK_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+            AS_LOCK_HELD(sfmmup->sfmmu_as));
 
         ASSERT(sfmmup != NULL);
         ASSERT((len & MMU_PAGEOFFSET) == 0);
         ASSERT(!((uintptr_t)addr & MMU_PAGEOFFSET));
 

@@ -6330,12 +6325,11 @@
         struct hme_blk *hmeblkp, *list = NULL;
         caddr_t endaddr;
         cpuset_t cpuset;
 
         ASSERT(sfmmup->sfmmu_xhat_provider == NULL);
-        ASSERT((sfmmup == ksfmmup) ||
-            AS_LOCK_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT((sfmmup == ksfmmup) || AS_LOCK_HELD(sfmmup->sfmmu_as));
         ASSERT((len & MMU_PAGEOFFSET) == 0);
         ASSERT((clearflag == HAT_SYNC_DONTZERO) ||
             (clearflag == HAT_SYNC_ZERORM));
 
         CPUSET_ZERO(cpuset);

@@ -7974,11 +7968,11 @@
         pfn_t pfn;
         tte_t tte;
 
         /*
          * We would like to
-         * ASSERT(AS_LOCK_HELD(as, &as->a_lock));
+         * ASSERT(AS_LOCK_HELD(as));
          * but we can't because the iommu driver will call this
          * routine at interrupt time and it can't grab the as lock
          * or it will deadlock: A thread could have the as lock
          * and be waiting for io.  The io can't complete
          * because the interrupt thread is blocked trying to grab

@@ -14029,11 +14023,11 @@
                 return (HAT_INVALID_REGION_COOKIE);
         }
 
         ASSERT(sfmmup->sfmmu_xhat_provider == NULL);
         ASSERT(sfmmup != ksfmmup);
-        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as));
         ASSERT(srdp->srd_refcnt > 0);
         ASSERT(!(flags & ~HAT_REGION_TYPE_MASK));
         ASSERT(flags == HAT_REGION_TEXT || flags == HAT_REGION_ISM);
         ASSERT(r_pgszc < mmu_page_sizes);
         if (!IS_P2ALIGNED(r_saddr, TTEBYTES(r_pgszc)) ||

@@ -14332,11 +14326,11 @@
         }
         ASSERT(rgnp != NULL);
         ASSERT(rgnp->rgn_id == rid);
         ASSERT((rgnp->rgn_flags & SFMMU_REGION_TYPE_MASK) == r_type);
         ASSERT(!(rgnp->rgn_flags & SFMMU_REGION_FREE));
-        ASSERT(AS_LOCK_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT(AS_LOCK_HELD(sfmmup->sfmmu_as));
 
         ASSERT(sfmmup->sfmmu_xhat_provider == NULL);
         if (r_type == SFMMU_REGION_HME && sfmmup->sfmmu_as->a_xhat != NULL) {
                 xhat_unload_callback_all(sfmmup->sfmmu_as, rgnp->rgn_saddr,
                     rgnp->rgn_size, 0, NULL);

@@ -15128,11 +15122,11 @@
         sf_scd_t *old_scdp;
 
         ASSERT(srdp != NULL);
         ASSERT(scdp != NULL);
         ASSERT(scdp->scd_refcnt > 0);
-        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as));
 
         if ((old_scdp = sfmmup->sfmmu_scdp) != NULL) {
                 ASSERT(old_scdp != scdp);
 
                 mutex_enter(&old_scdp->scd_mutex);

@@ -15240,11 +15234,11 @@
         sf_srd_t *srdp = sfmmup->sfmmu_srdp;
         sf_scd_t *scdp, *new_scdp;
         int ret;
 
         ASSERT(srdp != NULL);
-        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT(AS_WRITE_HELD(sfmmup->sfmmu_as));
 
         mutex_enter(&srdp->srd_scd_mutex);
         for (scdp = srdp->srd_scdp; scdp != NULL;
             scdp = scdp->scd_next) {
                 SF_RGNMAP_EQUAL(&scdp->scd_region_map,

@@ -15346,11 +15340,11 @@
         ASSERT(r_type != SFMMU_REGION_ISM ||
             SFMMU_FLAGS_ISSET(sfmmup, HAT_ISMBUSY));
         ASSERT(scdp->scd_refcnt);
         ASSERT(!sfmmup->sfmmu_free);
         ASSERT(sfmmu_hat_lock_held(sfmmup));
-        ASSERT(AS_LOCK_HELD(sfmmup->sfmmu_as, &sfmmup->sfmmu_as->a_lock));
+        ASSERT(AS_LOCK_HELD(sfmmup->sfmmu_as));
 
         /*
          * Wait for ISM maps to be updated.
          */
         if (r_type != SFMMU_REGION_ISM) {