Print this page
patch as-lock-macro-simplification

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/os/urw.c
          +++ new/usr/src/uts/common/os/urw.c
↓ open down ↓ 194 lines elided ↑ open up ↑
 195  195          on_trap_data_t otd;
 196  196          int retrycnt;
 197  197          struct as *as = p->p_as;
 198  198          enum seg_rw rw;
 199  199  
 200  200          /*
 201  201           * Locate segment containing address of interest.
 202  202           */
 203  203          page = (caddr_t)(uintptr_t)((uintptr_t)addr & PAGEMASK);
 204  204          retrycnt = 0;
 205      -        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
      205 +        AS_LOCK_ENTER(as, RW_WRITER);
 206  206  retry:
 207  207          if ((seg = as_segat(as, page)) == NULL ||
 208  208              !page_valid(seg, page)) {
 209      -                AS_LOCK_EXIT(as, &as->a_lock);
      209 +                AS_LOCK_EXIT(as);
 210  210                  return (ENXIO);
 211  211          }
 212  212          SEGOP_GETPROT(seg, page, 0, &prot);
 213  213  
 214  214          protchanged = 0;
 215  215          if ((prot & prot_rw) == 0) {
 216  216                  protchanged = 1;
 217  217                  err = SEGOP_SETPROT(seg, page, PAGESIZE, prot | prot_rw);
 218  218  
 219  219                  if (err == IE_RETRY) {
 220  220                          protchanged = 0;
 221  221                          ASSERT(retrycnt == 0);
 222  222                          retrycnt++;
 223  223                          goto retry;
 224  224                  }
 225  225  
 226  226                  if (err != 0) {
 227      -                        AS_LOCK_EXIT(as, &as->a_lock);
      227 +                        AS_LOCK_EXIT(as);
 228  228                          return (ENXIO);
 229  229                  }
 230  230          }
 231  231  
 232  232          /*
 233  233           * segvn may do a copy-on-write for F_SOFTLOCK/S_READ case to break
 234  234           * sharing to avoid a copy on write of a softlocked page by another
 235  235           * thread. But since we locked the address space as a writer no other
 236  236           * thread can cause a copy on write. S_READ_NOCOW is passed as the
 237  237           * access type to tell segvn that it's ok not to do a copy-on-write
↓ open down ↓ 2 lines elided ↑ open up ↑
 240  240          if (writing)
 241  241                  rw = S_WRITE;
 242  242          else if (seg->s_ops == &segvn_ops)
 243  243                  rw = S_READ_NOCOW;
 244  244          else
 245  245                  rw = S_READ;
 246  246  
 247  247          if (SEGOP_FAULT(as->a_hat, seg, page, PAGESIZE, F_SOFTLOCK, rw)) {
 248  248                  if (protchanged)
 249  249                          (void) SEGOP_SETPROT(seg, page, PAGESIZE, prot);
 250      -                AS_LOCK_EXIT(as, &as->a_lock);
      250 +                AS_LOCK_EXIT(as);
 251  251                  return (ENXIO);
 252  252          }
 253  253          CPU_STATS_ADD_K(vm, softlock, 1);
 254  254  
 255  255          /*
 256  256           * Make sure we're not trying to read or write off the end of the page.
 257  257           */
 258  258          ASSERT(len <= page + PAGESIZE - addr);
 259  259  
 260  260          /*
↓ open down ↓ 40 lines elided ↑ open up ↑
 301  301          mapout(as, addr, vaddr, writing);
 302  302  
 303  303          if (rw == S_READ_NOCOW)
 304  304                  rw = S_READ;
 305  305  
 306  306          (void) SEGOP_FAULT(as->a_hat, seg, page, PAGESIZE, F_SOFTUNLOCK, rw);
 307  307  
 308  308          if (protchanged)
 309  309                  (void) SEGOP_SETPROT(seg, page, PAGESIZE, prot);
 310  310  
 311      -        AS_LOCK_EXIT(as, &as->a_lock);
      311 +        AS_LOCK_EXIT(as);
 312  312  
 313  313          return (error);
 314  314  }
 315  315  
 316  316  int
 317  317  uread(proc_t *p, void *buf, size_t len, uintptr_t a)
 318  318  {
 319  319          return (urw(p, 0, buf, len, a));
 320  320  }
 321  321  
 322  322  int
 323  323  uwrite(proc_t *p, void *buf, size_t len, uintptr_t a)
 324  324  {
 325  325          return (urw(p, 1, buf, len, a));
 326  326  }
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX