Print this page
patch as-lock-macro-simplification

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/sparc/v9/vm/seg_nf.c
          +++ new/usr/src/uts/sparc/v9/vm/seg_nf.c
↓ open down ↓ 180 lines elided ↑ open up ↑
 181  181          uint_t prot;
 182  182          pgcnt_t vacpgs;
 183  183          u_offset_t off = 0;
 184  184          caddr_t vaddr = NULL;
 185  185          int i, color;
 186  186          struct seg *s1;
 187  187          struct seg *s2;
 188  188          size_t size;
 189  189          struct as *as = seg->s_as;
 190  190  
 191      -        ASSERT(as && AS_WRITE_HELD(as, &as->a_lock));
      191 +        ASSERT(as && AS_WRITE_HELD(as));
 192  192  
 193  193          /*
 194  194           * Need a page per virtual color or just 1 if no vac.
 195  195           */
 196  196          mutex_enter(&segnf_lock);
 197  197          if (nfpp == NULL) {
 198  198                  struct seg kseg;
 199  199  
 200  200                  vacpgs = 1;
 201  201                  if (shm_alignment > PAGESIZE) {
↓ open down ↓ 97 lines elided ↑ open up ↑
 299  299          panic("segnf_dup");
 300  300          return (0);
 301  301  }
 302  302  
 303  303  /*
 304  304   * Split a segment at addr for length len.
 305  305   */
 306  306  static int
 307  307  segnf_unmap(struct seg *seg, caddr_t addr, size_t len)
 308  308  {
 309      -        ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as, &seg->s_as->a_lock));
      309 +        ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as));
 310  310  
 311  311          /*
 312  312           * Check for bad sizes.
 313  313           */
 314  314          if (addr < seg->s_base || addr + len > seg->s_base + seg->s_size ||
 315  315              (len & PAGEOFFSET) || ((uintptr_t)addr & PAGEOFFSET)) {
 316  316                  cmn_err(CE_PANIC, "segnf_unmap: bad unmap size");
 317  317          }
 318  318  
 319  319          /*
↓ open down ↓ 48 lines elided ↑ open up ↑
 368  368  
 369  369          return (0);
 370  370  }
 371  371  
 372  372  /*
 373  373   * Free a segment.
 374  374   */
 375  375  static void
 376  376  segnf_free(struct seg *seg)
 377  377  {
 378      -        ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as, &seg->s_as->a_lock));
      378 +        ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as));
 379  379  }
 380  380  
 381  381  /*
 382  382   * No faults allowed on segnf.
 383  383   */
 384  384  static faultcode_t
 385  385  segnf_nomap(void)
 386  386  {
 387  387          return (FC_NOMAP);
 388  388  }
 389  389  
 390  390  /* ARGSUSED */
 391  391  static int
 392  392  segnf_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
 393  393  {
 394      -        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
      394 +        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));
 395  395          return (EACCES);
 396  396  }
 397  397  
 398  398  /* ARGSUSED */
 399  399  static int
 400  400  segnf_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
 401  401  {
 402  402          uint_t sprot;
 403      -        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
      403 +        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));
 404  404  
 405  405          sprot = seg->s_as == &kas ?  PROT_READ : PROT_READ|PROT_USER;
 406  406          return ((prot & sprot) == prot ? 0 : EACCES);
 407  407  }
 408  408  
 409  409  static void
 410  410  segnf_badop(void)
 411  411  {
 412  412          panic("segnf_badop");
 413  413          /*NOTREACHED*/
↓ open down ↓ 3 lines elided ↑ open up ↑
 417  417  segnf_nop(void)
 418  418  {
 419  419          return (0);
 420  420  }
 421  421  
 422  422  static int
 423  423  segnf_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
 424  424  {
 425  425          size_t pgno = seg_page(seg, addr + len) - seg_page(seg, addr) + 1;
 426  426          size_t p;
 427      -        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
      427 +        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));
 428  428  
 429  429          for (p = 0; p < pgno; ++p)
 430  430                  protv[p] = PROT_READ;
 431  431          return (0);
 432  432  }
 433  433  
 434  434  /* ARGSUSED */
 435  435  static u_offset_t
 436  436  segnf_getoffset(struct seg *seg, caddr_t addr)
 437  437  {
 438      -        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
      438 +        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));
 439  439  
 440  440          return ((u_offset_t)0);
 441  441  }
 442  442  
 443  443  /* ARGSUSED */
 444  444  static int
 445  445  segnf_gettype(struct seg *seg, caddr_t addr)
 446  446  {
 447      -        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
      447 +        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));
 448  448  
 449  449          return (MAP_SHARED);
 450  450  }
 451  451  
 452  452  /* ARGSUSED */
 453  453  static int
 454  454  segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
 455  455  {
 456      -        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
      456 +        ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as));
 457  457  
 458  458          *vpp = &nfvp;
 459  459          return (0);
 460  460  }
 461  461  
 462  462  /*
 463  463   * segnf pages are not dumped, so we just return
 464  464   */
 465  465  /* ARGSUSED */
 466  466  static void
↓ open down ↓ 32 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX