Lines Matching defs:mrp

535  * num_mapped is the number of elements of mrp which have been mapped, and
536 * num_segs is the total number of elements in mrp.
537 * For e_type ET_EXEC, we need to unmap all of the elements in mrp since
542 * end of the last mapped segment to the end of the last segment in mrp
547 mmapobj_unmap(mmapobj_result_t *mrp, int num_mapped, int num_segs,
573 if (mrp[i].mr_flags & MR_RESV) {
577 (void) as_unmap(as, mrp[i].mr_addr, mrp[i].mr_msize);
580 if (mrp[i].mr_flags & MR_RESV) {
595 (void) as_map(as, mrp[i].mr_addr, mrp[i].mr_msize,
606 addr = mrp[0].mr_addr;
608 addr = mrp[num_mapped - 1].mr_addr +
609 mrp[num_mapped - 1].mr_msize;
611 size = (size_t)mrp[num_segs - 1].mr_addr +
612 mrp[num_segs - 1].mr_msize - (size_t)addr;
624 addr = mrp[i - 1].mr_addr + mrp[i - 1].mr_msize;
625 size = mrp[i].mr_addr - addr;
632 * We need to add the start address into mrp so that the unmap function
636 mmapobj_unmap_exec(mmapobj_result_t *mrp, int num_mapped, caddr_t start_addr)
641 mrp[i].mr_addr += (size_t)start_addr;
643 mmapobj_unmap(mrp, num_mapped, num_mapped, ET_EXEC);
896 mmapobj_map_flat(vnode_t *vp, mmapobj_result_t *mrp, size_t padding,
928 mrp[0].mr_addr = addr;
929 mrp[0].mr_msize = len;
930 mrp[0].mr_fsize = len;
931 mrp[0].mr_offset = 0;
932 mrp[0].mr_prot = prot;
933 mrp[0].mr_flags = 0;
961 mrp[0].mr_addr = start_addr;
962 mrp[0].mr_msize = padding;
963 mrp[0].mr_fsize = 0;
964 mrp[0].mr_offset = 0;
965 mrp[0].mr_prot = 0;
966 mrp[0].mr_flags = MR_PADDING;
968 mrp[1].mr_addr = addr;
969 mrp[1].mr_msize = len;
970 mrp[1].mr_fsize = len;
971 mrp[1].mr_offset = 0;
972 mrp[1].mr_prot = prot;
973 mrp[1].mr_flags = 0;
975 mrp[2].mr_addr = addr + P2ROUNDUP(len, PAGESIZE);
976 mrp[2].mr_msize = padding;
977 mrp[2].mr_fsize = 0;
978 mrp[2].mr_offset = 0;
979 mrp[2].mr_prot = 0;
980 mrp[2].mr_flags = MR_PADDING;
1193 * mappings. The mappings are described by the data in mrp which may be
1198 mmapobj_map_elf(struct vnode *vp, caddr_t start_addr, mmapobj_result_t *mrp,
1217 addr = start_addr + (size_t)(mrp[i].mr_addr);
1218 mrp[i].mr_addr =
1222 if (MR_GET_TYPE(mrp[i].mr_flags) == MR_PADDING) {
1225 p_memsz = mrp[i].mr_msize;
1226 p_filesz = mrp[i].mr_fsize;
1228 p_offset = mrp[i].mr_offset;
1230 prot = mrp[i].mr_prot | PROT_USER;
1235 mmapobj_unmap(mrp, i, num_elements, e_type);
1239 /* Need to cleanup mrp to reflect the actual values used */
1240 mrp[i].mr_msize += dif;
1241 mrp[i].mr_offset = (size_t)addr & PAGEOFFSET;
1255 hi = mrp[0].mr_addr;
1259 lo = (caddr_t)P2ROUNDUP((size_t)(mrp[i].mr_addr) +
1260 mrp[i].mr_msize, PAGESIZE);
1261 hi = mrp[i + 1].mr_addr;
1444 check_exec_addrs(int loadable, mmapobj_result_t *mrp, caddr_t start_addr)
1459 myaddr = start_addr + (size_t)mrp[i].mr_addr;
1460 mylen = mrp[i].mr_msize;
1464 ASSERT(myaddr == start_addr + (size_t)mrp[i].mr_addr);
1465 ASSERT(mylen == mrp[i].mr_msize);
1468 if (MR_GET_TYPE(mrp[i].mr_flags) == MR_PADDING) {
1475 mmapobj_unmap_exec(mrp, i, start_addr);
1501 mrp[i].mr_flags |= MR_RESV;
1505 mmapobj_unmap_exec(mrp, i + 1,
1512 mmapobj_unmap_exec(mrp, i, start_addr);
1524 * for PT_LOAD and PT_SUNWBSS segments into mrp.
1528 process_phdr(Ehdr *ehdrp, caddr_t phdrbase, int nphdrs, mmapobj_result_t *mrp,
1738 * for our mappings. Now we need to start filling out the mrp
1742 * using fixed addresses. While filling in the mrp array below,
1749 /* We'll fill out padding later, so start filling in mrp at index 1 */
1761 /* Now fill out the mrp structs from the program headers */
1793 mrp[current].mr_msize = p_memsz;
1794 mrp[current].mr_fsize = p_filesz;
1795 mrp[current].mr_offset = p_offset;
1796 mrp[current].mr_prot = prot;
1799 mrp[current].mr_flags = MR_HDR_ELF;
1811 mrp[current].mr_offset = 0;
1812 mrp[current].mr_msize += p_offset;
1813 mrp[current].mr_fsize += p_offset;
1823 mrp[current].mr_addr = (caddr_t)padding;
1828 mrp[current].mr_addr =
1831 mrp[current].mr_addr = vaddr + padding;
1833 mrp[current].mr_flags = 0;
1846 mrp[0].mr_addr = NULL;
1847 mrp[0].mr_msize = padding;
1848 mrp[0].mr_fsize = 0;
1849 mrp[0].mr_offset = 0;
1850 mrp[0].mr_prot = 0;
1851 mrp[0].mr_flags = MR_PADDING;
1855 mrp[current].mr_addr = (caddr_t)lib_len + padding;
1856 mrp[current].mr_msize = padding;
1857 mrp[current].mr_fsize = 0;
1858 mrp[current].mr_offset = 0;
1859 mrp[current].mr_prot = 0;
1860 mrp[current].mr_flags = MR_PADDING;
1869 ret = check_exec_addrs(loadable, mrp, start_addr);
1881 bcopy(mrp, lvp->lv_mps,
1897 /* Now that we have mrp completely filled out go map it */
1898 ret = mmapobj_map_elf(vp, start_addr, mrp, loadable, fcred, e_type);
1909 * num_mapped out - # sections mapped and length of mrp array if
1913 doelfwork(Ehdr *ehdrp, vnode_t *vp, mmapobj_result_t *mrp,
1952 error = mmapobj_map_flat(vp, mrp, padding, fcred);
1955 mrp[padding ? 1 : 0].mr_flags = MR_HDR_ELF;
2029 error = process_phdr(ehdrp, phbasep, nphdrs, mrp, vp, num_mapped,
2047 doaoutwork(vnode_t *vp, mmapobj_result_t *mrp,
2169 mrp[0].mr_addr = addr;
2170 mrp[0].mr_msize = hdr->a_text;
2171 mrp[0].mr_fsize = hdr->a_text;
2172 mrp[0].mr_offset = 0;
2173 mrp[0].mr_prot = PROT_READ | PROT_EXEC;
2174 mrp[0].mr_flags = MR_HDR_AOUT;
2192 mrp[1].mr_addr = addr;
2193 mrp[1].mr_msize = size;
2194 mrp[1].mr_fsize = size;
2195 mrp[1].mr_offset = 0;
2196 mrp[1].mr_prot = PROT_READ | PROT_WRITE | PROT_EXEC;
2197 mrp[1].mr_flags = 0;
2237 mrp[2].mr_addr = addr;
2238 mrp[2].mr_msize = size;
2239 mrp[2].mr_fsize = 0;
2240 mrp[2].mr_offset = 0;
2241 mrp[2].mr_prot = PROT_READ | PROT_WRITE | PROT_EXEC;
2242 mrp[2].mr_flags = 0;
2256 mrp[segnum].mr_addr = addr;
2257 mrp[segnum].mr_msize = nsize - msize;
2258 mrp[segnum].mr_fsize = 0;
2259 mrp[segnum].mr_offset = 0;
2260 mrp[segnum].mr_prot = PROT_READ | PROT_EXEC;
2261 mrp[segnum].mr_flags = 0;
2278 * num_mapped in - # elements in mrp
2279 * num_mapped out - # sections mapped and length of mrp array if
2285 mmapobj_map_interpret(vnode_t *vp, mmapobj_result_t *mrp,
2347 bcopy(lvp->lv_mps, mrp,
2350 error = mmapobj_map_elf(vp, start_addr, mrp,
2384 return (doelfwork((Ehdr *)lheader, vp, mrp, num_mapped,
2394 return (doaoutwork(vp, mrp, num_mapped,
2411 * distinct mappings created, and mrp will point to the array of
2420 mmapobj(vnode_t *vp, uint_t flags, mmapobj_result_t *mrp,
2438 error = mmapobj_map_flat(vp, mrp, padding, fcred);
2447 error = mmapobj_map_interpret(vp, mrp, num_mapped, padding, fcred);