Print this page
patch as-lock-macro-simplification

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/exec/elf/elf.c
          +++ new/usr/src/uts/common/exec/elf/elf.c
↓ open down ↓ 1744 lines elided ↑ open up ↑
1745 1745          klwp_t *lwp = ttolwp(curthread);
1746 1746  
1747 1747  top:
1748 1748          /*
1749 1749           * Make sure we have everything we need (registers, etc.).
1750 1750           * All other lwps have already stopped and are in an orderly state.
1751 1751           */
1752 1752          ASSERT(p == ttoproc(curthread));
1753 1753          prstop(0, 0);
1754 1754  
1755      -        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     1755 +        AS_LOCK_ENTER(as, RW_WRITER);
1756 1756          nphdrs = prnsegs(as, 0) + 2;            /* two CORE note sections */
1757 1757  
1758 1758          /*
1759 1759           * Count the number of section headers we're going to need.
1760 1760           */
1761 1761          nshdrs = 0;
1762 1762          if (content & (CC_CONTENT_CTF | CC_CONTENT_SYMTAB)) {
1763 1763                  (void) process_scns(content, p, credp, NULL, NULL, NULL, 0,
1764 1764                      NULL, &nshdrs);
1765 1765          }
1766      -        AS_LOCK_EXIT(as, &as->a_lock);
     1766 +        AS_LOCK_EXIT(as);
1767 1767  
1768 1768          ASSERT(nshdrs == 0 || nshdrs > 1);
1769 1769  
1770 1770          /*
1771 1771           * The core file contents may required zero section headers, but if
1772 1772           * we overflow the 16 bits allotted to the program header count in
1773 1773           * the ELF header, we'll need that program header at index zero.
1774 1774           */
1775 1775          if (nshdrs == 0 && nphdrs >= PN_XNUM)
1776 1776                  nshdrs = 1;
↓ open down ↓ 95 lines elided ↑ open up ↑
1872 1872          mutex_enter(&p->p_lock);
1873 1873  
1874 1874          brkbase = p->p_brkbase;
1875 1875          brksize = p->p_brksize;
1876 1876  
1877 1877          stkbase = p->p_usrstack - p->p_stksize;
1878 1878          stksize = p->p_stksize;
1879 1879  
1880 1880          mutex_exit(&p->p_lock);
1881 1881  
1882      -        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     1882 +        AS_LOCK_ENTER(as, RW_WRITER);
1883 1883          i = 2;
1884 1884          for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) {
1885 1885                  caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0);
1886 1886                  caddr_t saddr, naddr;
1887 1887                  void *tmp = NULL;
1888 1888                  extern struct seg_ops segspt_shmops;
1889 1889  
1890 1890                  for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) {
1891 1891                          uint_t prot;
1892 1892                          size_t size;
↓ open down ↓ 79 lines elided ↑ open up ↑
1972 1972  
1973 1973                          doffset = roundup(doffset, sizeof (Word));
1974 1974                          v[i].p_offset = doffset;
1975 1975                          v[i].p_filesz = size;
1976 1976                          doffset += size;
1977 1977  exclude:
1978 1978                          i++;
1979 1979                  }
1980 1980                  ASSERT(tmp == NULL);
1981 1981          }
1982      -        AS_LOCK_EXIT(as, &as->a_lock);
     1982 +        AS_LOCK_EXIT(as);
1983 1983  
1984 1984          if (overflow || i != nphdrs) {
1985 1985                  if (ntries++ == 0) {
1986 1986                          kmem_free(bigwad, bigsize);
1987 1987                          overflow = 0;
1988 1988                          goto top;
1989 1989                  }
1990 1990                  cmn_err(CE_WARN, "elfcore: core dump failed for "
1991 1991                      "process %d; address space is changing", p->p_pid);
1992 1992                  error = EIO;
↓ open down ↓ 128 lines elided ↑ open up ↑
2121 2121                  if (nshdrs >= SHN_LORESERVE)
2122 2122                          bigwad->shdr[0].sh_size = nshdrs;
2123 2123  
2124 2124                  if (nshdrs - 1 >= SHN_LORESERVE)
2125 2125                          bigwad->shdr[0].sh_link = nshdrs - 1;
2126 2126  
2127 2127                  if (nphdrs >= PN_XNUM)
2128 2128                          bigwad->shdr[0].sh_info = nphdrs;
2129 2129  
2130 2130                  if (nshdrs > 1) {
2131      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     2131 +                        AS_LOCK_ENTER(as, RW_WRITER);
2132 2132                          if ((error = process_scns(content, p, credp, vp,
2133 2133                              &bigwad->shdr[0], nshdrs, rlimit, &doffset,
2134 2134                              NULL)) != 0) {
2135      -                                AS_LOCK_EXIT(as, &as->a_lock);
     2135 +                                AS_LOCK_EXIT(as);
2136 2136                                  goto done;
2137 2137                          }
2138      -                        AS_LOCK_EXIT(as, &as->a_lock);
     2138 +                        AS_LOCK_EXIT(as);
2139 2139                  }
2140 2140  
2141 2141                  if ((error = core_write(vp, UIO_SYSSPACE, soffset,
2142 2142                      &bigwad->shdr[0], shdrsz, rlimit, credp)) != 0)
2143 2143                          goto done;
2144 2144          }
2145 2145  
2146 2146  done:
2147 2147          kmem_free(bigwad, bigsize);
2148 2148          return (error);
↓ open down ↓ 69 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX