MAP_PRIVATE
MAP_PRIVATE|MAP_ANON, -1, 0);
cap_buffp = mmap(0, cap_len, PROT_READ, MAP_PRIVATE, capfile_in, 0);
MAP_ANON | MAP_PRIVATE, -1, 0)) == (caddr_t)-1)
MAP_PRIVATE, bd->fd, 0)) == MAP_FAILED)
addr = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
PROT_READ | PROT_WRITE, MAP_PRIVATE, Conffd, 0)) == (char *)-1)
PROT_READ | PROT_WRITE, MAP_PRIVATE,
(PROT_READ | PROT_WRITE), MAP_PRIVATE, fd, 0);
if ((cp1 = mmap(NULL, sb1.st_size, PROT_READ, MAP_PRIVATE,
if ((cp2 = mmap(NULL, sb2.st_size, PROT_READ, MAP_PRIVATE,
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE, zfd, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON | MAP_ALIGN, -1, 0)) == MAP_FAILED) {
flags = is_rdonly ? MAP_PRIVATE : MAP_SHARED;
(void) mmap(0, 1, PROT_READ, MAP_PRIVATE|MAP_FIXED, fd, 0);
MAP_PRIVATE, fd, 0)) == MAP_FAILED) {
fmem = mmap(0, *fsz, PROT_READ, MAP_PRIVATE, fd, 0);
(MAP_FIXED | MAP_PRIVATE), fd, 0) == MAP_FAILED) {
(MAP_FIXED | MAP_PRIVATE), fd, 0) == MAP_FAILED) {
MAP_PRIVATE, fd, (off_t)0)) != (char *)-1) {
if ((addr = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED)
MAP_FIXED | MAP_PRIVATE) == MAP_FAILED))
MAP_PRIVATE)) == MAP_FAILED)
MAP_PRIVATE)) == MAP_FAILED)
MAP_PRIVATE)) == MAP_FAILED)
MAP_PRIVATE, 0);
PROT_WRITE, MAP_PRIVATE, 0);
PROT_WRITE, MAP_PRIVATE, 0);
MAP_PRIVATE, fd, 0);
map = mmap(0, stb.st_size, PROT_READ, MAP_PRIVATE, cnt, 0);
map = mmap(0, stb.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE,
MAP_PRIVATE|MAP_ANON, -1, 0);
MAP_ANON | (sharedmem? MAP_SHARED : MAP_PRIVATE),
case MAP_PRIVATE:
PROT_READ+PROT_WRITE, MAP_PRIVATE, ulogfd, 0);
PROT_READ, MAP_PRIVATE, rfd,
MAP_FIXED | MAP_PRIVATE, ldfd, foff) == (caddr_t)-1)
MAP_FIXED | MAP_PRIVATE, dzfd,
MAP_PRIVATE | MAP_ANON, -1, (off_t)0);
MAP_PRIVATE | MAP_ANON, -1, (off_t)0);
MAP_PRIVATE | MAP_ANON, -1, (off_t)0);
MAP_PRIVATE | MAP_ANON, -1, 0);
map = mmap(NULL, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
fdata = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
_MAP_NEW | MAP_PRIVATE | MAP_ANON | MAP_ALIGN, -1L, (off_t)0) != 0)
MAP_PRIVATE|MAP_ANON|MAP_ALIGN, -1, (off_t)0);
MAP_PRIVATE|MAP_ANON|MAP_ALIGN, -1, (off_t)0);
PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, (off_t)0);
PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, (off_t)0))
PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON,
PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON,
PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, (off_t)0))
MAP_PRIVATE|MAP_NORESERVE|MAP_ANON, -1, (off_t)0)) != MAP_FAILED) {
MAP_FIXED | MAP_PRIVATE, ldfd, foff) == (caddr_t)-1)
MAP_FIXED | MAP_PRIVATE, dzfd,
PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, (off_t)0))
MAP_PRIVATE, fd, sp->cts_offset & _PAGEMASK);
MAP_PRIVATE, fd, 0);
strs_map = mmap64(NULL, strs_mapsz, PROT_READ, MAP_PRIVATE,
MAP_PRIVATE | MAP_ANON, -1, 0));
PROT_READ|PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0))
MAP_PRIVATE, fd, 0);
MAP_PRIVATE, (*pam_fh)->fconfig, 0)) == MAP_FAILED) {
MAP_PRIVATE|MAP_FIXED, fileno(fp), (off_t)0);
MAP_PRIVATE)) == MAP_FAILED) {
#define ALLOC_FLAGS MAP_PRIVATE | MAP_ANON
#define FREE_FLAGS MAP_PRIVATE | MAP_ANON | MAP_NORESERVE
MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0);
#define MAP_GUARD (MAP_PRIVATE | MAP_ANON | MAP_NORESERVE)
} else if (advice_mapprivate >= 0 && (flags & MAP_PRIVATE)) {
} else if (advice_mapprivate >= 0 && (flags & MAP_PRIVATE)) {
PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
maddr = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
int flags = MAP_PRIVATE|MAP_ANON;
void *addr = mmap(NULL, pgsz, PROT_NONE, MAP_PRIVATE | MAP_ANON,
MAP_PRIVATE | MAP_ANON, -1, 0);
PROT_READ, MAP_ANON | MAP_FIXED | MAP_PRIVATE, -1, 0),
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_ANON|MAP_PRIVATE, -1, 0);
PROT_READ, MAP_ANON | MAP_FIXED | MAP_PRIVATE, -1, 0),
addr = mmap(NULL, 4096, PROT_READ, MAP_PRIVATE | MAP_ANON, -1, 0);
addr = mmap(NULL, 4096, PROT_READ, MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
buf = mmap(NULL, mapsz, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
unmap = mmap(NULL, 1024 * 1024, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1,
p = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
void *map = mmap(NULL, map_sz, PROT_READ, MAP_PRIVATE, fd, 0);
MAP_ANON|MAP_PRIVATE, -1, 0)) == (void*)-1)
badaddr = mmap(NULL, PAGESIZE, PROT_READ, MAP_PRIVATE | MAP_ANON, -1,
unmap = mmap(NULL, page, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
MAP_PRIVATE | MAP_ANON, -1, 0);
void *addr = mmap(NULL, pgsz * 2, PROT_NONE, MAP_PRIVATE | MAP_ANON,
mflags0 |= MAP_PRIVATE;
mflags1 |= MAP_PRIVATE;
if ((addr = mmap(NULL, len, PROT_READ, MAP_PRIVATE | MAP_ANON, -1,
if ((map = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
(MAP_SHARED | MAP_PRIVATE)) == 0))
if (flags & MAP_PRIVATE) {
if (flags & MAP_PRIVATE) {
uint_t mflag = MAP_PRIVATE | MAP_FIXED;
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | _MAP_NEW |
if (type != MAP_PRIVATE && type != MAP_SHARED)
policy = lgrp_mem_policy_default(size, MAP_PRIVATE);
uint_t mflag = MAP_PRIVATE | MAP_FIXED;
(MAP_SHARED | MAP_PRIVATE)) == 0) &&
ma_flags |= MAP_PRIVATE;
((SEGOP_GETTYPE(seg, addr) & (MAP_SHARED | MAP_PRIVATE)) == 0))
} else if ((SEGOP_GETTYPE(seg, uaddr) & MAP_PRIVATE) == 0) {
if ((flags & MAP_PRIVATE) != 0) {
MAP_PRIVATE)) == 0) {
((SEGOP_GETTYPE(seg, (seg)->s_base) & (MAP_SHARED | MAP_PRIVATE)) == 0))
return (MAP_PRIVATE);
ASSERT(svd1->type == MAP_PRIVATE);
ASSERT(svd->type == MAP_PRIVATE);
if (amp->refcnt == 1 || svd->type == MAP_PRIVATE) {
if (amp->refcnt == 1 || svd->type == MAP_PRIVATE) {
if (amp->refcnt == 1 || svd->type == MAP_PRIVATE) {
ASSERT(svd->type == MAP_PRIVATE);
if (svd->type == MAP_PRIVATE) {
} else if (svd->type == MAP_PRIVATE) {
ASSERT(svd->type == MAP_PRIVATE);
if (svd->type == MAP_PRIVATE) {
if (rw == S_WRITE && segtype == MAP_PRIVATE) {
segtype == MAP_PRIVATE ? ppa : NULL)) {
segtype == MAP_PRIVATE ||
ASSERT(segtype == MAP_PRIVATE);
if (segtype == MAP_PRIVATE) {
ASSERT(segtype == MAP_PRIVATE);
ASSERT(segtype == MAP_PRIVATE ||
ASSERT(svd->type == MAP_PRIVATE);
svd->type == MAP_PRIVATE && svd->pageprot == 0) {
} else if (rw == S_WRITE && svd->type == MAP_PRIVATE ||
if (rw == S_WRITE && svd->type == MAP_PRIVATE) {
if (svd->type == MAP_PRIVATE)
if (a->type != MAP_PRIVATE && a->type != MAP_SHARED) {
if (a->type == MAP_PRIVATE && (a->flags & MAP_TEXT) &&
if (svd->type == MAP_PRIVATE || svd->vp != NULL) {
if (svd->type == MAP_PRIVATE) {
(a->amp != NULL && a->type == MAP_PRIVATE) ||
} else if (svd->type == MAP_PRIVATE) {
(svd->vp != NULL || svd->type == MAP_PRIVATE)) ||
(a->type == MAP_PRIVATE && (a->prot & PROT_WRITE)))) {
ASSERT(svd->type == MAP_PRIVATE);
if (svd->type == MAP_PRIVATE) {
ASSERT(svd->type == MAP_PRIVATE);
if (svd->amp != NULL && svd->type == MAP_PRIVATE) {
a->type == MAP_PRIVATE && swresv == 0 &&
if ((a->vp == NULL) && (a->type == MAP_PRIVATE) &&
segtype = (attr & SHARED) ? MAP_SHARED : MAP_PRIVATE;
segtype = attr & SHARED ? MAP_SHARED : MAP_PRIVATE;
(svd->type == MAP_PRIVATE));
if (svd->type == MAP_PRIVATE &&
svd->type != MAP_PRIVATE ||
if (svd->type == MAP_PRIVATE) {
if (svd->type == MAP_PRIVATE) {
ASSERT(svd->type == MAP_PRIVATE);
ASSERT(svd->type == MAP_PRIVATE);
if (svd->type == MAP_PRIVATE) {
if (svd->type == MAP_PRIVATE) {
ASSERT(svd->type == MAP_PRIVATE);
seg_type == MAP_PRIVATE)
{ NULL, NULL, 0, MAP_PRIVATE, prot, max, 0, NULL, 0, 0 }
ASSERT(vn_a->type == MAP_SHARED || vn_a->type == MAP_PRIVATE);
} else if (vn_a->type == MAP_PRIVATE) {
rtype = rtype & (MAP_SHARED | MAP_PRIVATE);
stype &= (MAP_SHARED | MAP_PRIVATE);
if (svd->type == MAP_PRIVATE && svd->swresv > 0)
if (flags & MAP_PRIVATE) {