Print this page
patch as-lock-macro-simplification

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/os/watchpoint.c
          +++ new/usr/src/uts/common/os/watchpoint.c
↓ open down ↓ 188 lines elided ↑ open up ↑
 189  189           * lock, we need to grab as lock (reader lock is good enough).
 190  190           *
 191  191           * p_maplock prevents simultaneous execution of this function.  Under
 192  192           * normal circumstances, holdwatch() will stop all other threads, so the
 193  193           * lock isn't really needed.  But there may be multiple threads within
 194  194           * stop() when SWATCHOK is set, so we need to handle multiple threads
 195  195           * at once.  See holdwatch() for the details of this dance.
 196  196           */
 197  197  
 198  198          mutex_enter(&p->p_maplock);
 199      -        AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
      199 +        AS_LOCK_ENTER(as, RW_READER);
 200  200  
 201  201          tpw.wp_vaddr = (caddr_t)((uintptr_t)addr & (uintptr_t)PAGEMASK);
 202  202          if ((pwp = avl_find(&as->a_wpage, &tpw, &where)) == NULL)
 203  203                  pwp = avl_nearest(&as->a_wpage, where, AVL_AFTER);
 204  204  
 205  205          for (; pwp != NULL && pwp->wp_vaddr < eaddr;
 206  206                  pwp = AVL_NEXT(&as->a_wpage, pwp)) {
 207  207  
 208  208                  /*
 209  209                   * If the requested protection has not been
↓ open down ↓ 18 lines elided ↑ open up ↑
 228  228                  if (mapin) {
 229  229                          /*
 230  230                           * Before mapping the page in, ensure that
 231  231                           * all other lwps are held in the kernel.
 232  232                           */
 233  233                          if (p->p_mapcnt == 0) {
 234  234                                  /*
 235  235                                   * Release as lock while in holdwatch()
 236  236                                   * in case other threads need to grab it.
 237  237                                   */
 238      -                                AS_LOCK_EXIT(as, &as->a_lock);
      238 +                                AS_LOCK_EXIT(as);
 239  239                                  mutex_exit(&p->p_maplock);
 240  240                                  if (holdwatch() != 0) {
 241  241                                          /*
 242  242                                           * We stopped in holdwatch().
 243  243                                           * Start all over again because the
 244  244                                           * watched page list may have changed.
 245  245                                           */
 246  246                                          goto startover;
 247  247                                  }
 248  248                                  mutex_enter(&p->p_maplock);
 249      -                                AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
      249 +                                AS_LOCK_ENTER(as, RW_READER);
 250  250                          }
 251  251                          p->p_mapcnt++;
 252  252                  }
 253  253  
 254  254                  addr = pwp->wp_vaddr;
 255  255                  rv++;
 256  256  
 257  257                  prot = pwp->wp_prot;
 258  258                  if (mapin) {
 259  259                          if (kernel)
↓ open down ↓ 39 lines elided ↑ open up ↑
 299  299  #endif
 300  300                          }
 301  301                  }
 302  302  
 303  303  
 304  304                  if (pwp->wp_oprot != 0) {       /* if page exists */
 305  305                          struct seg *seg;
 306  306                          uint_t oprot;
 307  307                          int err, retrycnt = 0;
 308  308  
 309      -                        AS_LOCK_EXIT(as, &as->a_lock);
 310      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
      309 +                        AS_LOCK_EXIT(as);
      310 +                        AS_LOCK_ENTER(as, RW_WRITER);
 311  311                  retry:
 312  312                          seg = as_segat(as, addr);
 313  313                          ASSERT(seg != NULL);
 314  314                          SEGOP_GETPROT(seg, addr, 0, &oprot);
 315  315                          if (prot != oprot) {
 316  316                                  err = SEGOP_SETPROT(seg, addr, PAGESIZE, prot);
 317  317                                  if (err == IE_RETRY) {
 318  318                                          ASSERT(retrycnt == 0);
 319  319                                          retrycnt++;
 320  320                                          goto retry;
 321  321                                  }
 322  322                          }
 323      -                        AS_LOCK_EXIT(as, &as->a_lock);
      323 +                        AS_LOCK_EXIT(as);
 324  324                  } else
 325      -                        AS_LOCK_EXIT(as, &as->a_lock);
      325 +                        AS_LOCK_EXIT(as);
 326  326  
 327  327                  /*
 328  328                   * When all pages are mapped back to their normal state,
 329  329                   * continue the other lwps.
 330  330                   */
 331  331                  if (!mapin) {
 332  332                          ASSERT(p->p_mapcnt > 0);
 333  333                          p->p_mapcnt--;
 334  334                          if (p->p_mapcnt == 0) {
 335  335                                  mutex_exit(&p->p_maplock);
 336  336                                  mutex_enter(&p->p_lock);
 337  337                                  continuelwps(p);
 338  338                                  mutex_exit(&p->p_lock);
 339  339                                  mutex_enter(&p->p_maplock);
 340  340                          }
 341  341                  }
 342  342  
 343      -                AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
      343 +                AS_LOCK_ENTER(as, RW_READER);
 344  344          }
 345  345  
 346      -        AS_LOCK_EXIT(as, &as->a_lock);
      346 +        AS_LOCK_EXIT(as);
 347  347          mutex_exit(&p->p_maplock);
 348  348  
 349  349          return (rv);
 350  350  }
 351  351  
 352  352  /*
 353  353   * Restore the original page protections on an address range.
 354  354   * If 'kernel' is non-zero, just do it for the kernel.
 355  355   * pr_mappage() returns non-zero if it actually changed anything.
 356  356   *
↓ open down ↓ 30 lines elided ↑ open up ↑
 387  387          struct seg *seg;
 388  388          caddr_t vaddr;
 389  389          uint_t prot;
 390  390          int err, retrycnt;
 391  391  
 392  392          if (p->p_wprot == NULL)
 393  393                  return;
 394  394  
 395  395          ASSERT(MUTEX_NOT_HELD(&curproc->p_lock));
 396  396  
 397      -        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
      397 +        AS_LOCK_ENTER(as, RW_WRITER);
 398  398  
 399  399          pwp = p->p_wprot;
 400  400          while (pwp != NULL) {
 401  401  
 402  402                  vaddr = pwp->wp_vaddr;
 403  403                  retrycnt = 0;
 404  404          retry:
 405  405                  ASSERT(pwp->wp_flags & WP_SETPROT);
 406  406                  if ((seg = as_segat(as, vaddr)) != NULL &&
 407  407                      !(pwp->wp_flags & WP_NOWATCH)) {
↓ open down ↓ 16 lines elided ↑ open up ↑
 424  424                          avl_remove(&as->a_wpage, pwp);
 425  425                          kmem_free(pwp, sizeof (struct watched_page));
 426  426                  } else {
 427  427                          pwp->wp_flags &= ~WP_SETPROT;
 428  428                  }
 429  429  
 430  430                  pwp = next;
 431  431          }
 432  432          p->p_wprot = NULL;
 433  433  
 434      -        AS_LOCK_EXIT(as, &as->a_lock);
      434 +        AS_LOCK_EXIT(as);
 435  435  }
 436  436  
 437  437  
 438  438  
 439  439  /* Must be called with as lock held */
 440  440  int
 441  441  pr_is_watchpage_as(caddr_t addr, enum seg_rw rw, struct as *as)
 442  442  {
 443  443          register struct watched_page *pwp;
 444  444          struct watched_page tpw;
↓ open down ↓ 53 lines elided ↑ open up ↑
 498  498  int
 499  499  pr_is_watchpage(caddr_t addr, enum seg_rw rw)
 500  500  {
 501  501          struct as *as = curproc->p_as;
 502  502          int rv;
 503  503  
 504  504          if ((as == &kas) || avl_numnodes(&as->a_wpage) == 0)
 505  505                  return (0);
 506  506  
 507  507          /* Grab the lock because of XHAT (see comment in pr_mappage()) */
 508      -        AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
      508 +        AS_LOCK_ENTER(as, RW_READER);
 509  509          rv = pr_is_watchpage_as(addr, rw, as);
 510      -        AS_LOCK_EXIT(as, &as->a_lock);
      510 +        AS_LOCK_EXIT(as);
 511  511  
 512  512          return (rv);
 513  513  }
 514  514  
 515  515  
 516  516  
 517  517  /*
 518  518   * trap() calls here to determine if a fault is a watchpoint.
 519  519   */
 520  520  int
↓ open down ↓ 1224 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX