diff options
Diffstat (limited to 'coregrind/m_aspacemgr/aspacemgr-aix5.c')
| -rw-r--r-- | coregrind/m_aspacemgr/aspacemgr-aix5.c | 2641 |
1 files changed, 2641 insertions, 0 deletions
diff --git a/coregrind/m_aspacemgr/aspacemgr-aix5.c b/coregrind/m_aspacemgr/aspacemgr-aix5.c new file mode 100644 index 0000000..ce529e5 --- /dev/null +++ b/coregrind/m_aspacemgr/aspacemgr-aix5.c @@ -0,0 +1,2641 @@ + +/*--------------------------------------------------------------------*/ +/*--- The address space manager: segment initialisation and ---*/ +/*--- tracking, stack operations ---*/ +/*--- ---*/ +/*--- Implementation for AIX5 m_aspacemgr-aix5.c ---*/ +/*--------------------------------------------------------------------*/ + +/* + This file is part of Valgrind, a dynamic binary instrumentation + framework. + + Copyright (C) 2006-2009 OpenWorks LLP + info@open-works.co.uk + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307, USA. + + The GNU General Public License is contained in the file COPYING. + + Neither the names of the U.S. Department of Energy nor the + University of California nor the names of its contributors may be + used to endorse or promote products derived from this software + without prior written permission. +*/ + +/* ************************************************************* + DO NOT INCLUDE ANY OTHER FILES HERE. + ADD NEW INCLUDES ONLY TO priv_aspacemgr.h + AND THEN ONLY AFTER READING DIRE WARNINGS THERE TOO. + ************************************************************* */ + +#include "priv_aspacemgr.h" + + +/* Note: many of the exported functions implemented below are + described more fully in comments in pub_core_aspacemgr.h. +*/ + +/* This provides a minimal address space management facility for AIX5. + It is not as comprehensive, robust or efficient as its Linux + counterpart. + + It does implement the advise/notify concept described in + aspacemgr-linux.c, but minimally. It only keeps track of the + mappings belonging to Valgrind; the client can do what it likes so + long as it doesn't trash Valgrind's mappings. + + This is unfortunate, but the root problem is that it is impossible + to find out on AIX what the complete set of mappings for a process + is. Sure, AIX does have /proc/pid/map, but it's weak compared to + Linux's: it just shows some small subset of the mappings, not all + of them. So it is not very useful: it can't be used to discover + the true initial process mapping state, and it can't be used to + cross-check Valgrind's internal mapping table, as is done at + --sanity-level=3 and above on Linux. +*/ + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- The Address Space Manager's state. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Describes AIX5-specific segment kinds */ +typedef + enum { + ASkFree=1, // free space + ASkMText, // module text (code) mapping + ASkMData, // module data (& bss) mapping + ASkFileV, // file mapping belonging to valgrind + ASkAnonC, // anonymous mapping belonging to the client + ASkAnonV, // anonymous mapping belonging to valgrind + ASkShmemC, // shm mapping belonging to the client + ASkPreAlloc // area preallocated from sbrk + } + AixSegKind; + +/* Segment table entries, in summary: + + ASkFree start end + ASkMText start end r w x sibling ismainexe fname mname + ASkMData start end r w x sibling + FileV start end r w x fname offset + AnonC start end r w x fromP isCH + AnonV start end r w x fromP + ShmemC start end r w x + PreAlloc start end + + Entries are non-overlapping and cover the entire address space + exactly (as in the Linux aspacem). Unlike Linux there are no + alignment constraints, since we're just recording what's going on, + rather than controlling it. + + MText/MData are XCOFF mapped modules, as determined by looking at + /proc/../map. MText is the primary entry and contains the text + range. MData contains the data range, if the module has a data + mapping (usually but not always). MText also holds the avma of the + corresponding data segment start, if any, (sibling field) so it can + be found and the two added/removed together. Similarly MData + contains the address of the corresponding MText (also sibling). + + fname/mname only apply to MText. To find the fname/mname for MData + you have to look at the corresponding MText entry, which is + guaranteed to exist. MText may exist without a corresponding MData + but not vice versa. Kludge: in fact fname/mname have to be + allowed in MData, else read_procselfmap doesn't work. + + MText may have a zero sibling pointer, indicating that there is no + corresponding MData. But MData must have a nonzero sibling pointer + since MData without MText is not allowed. Implication is that + neither MText nor MData may be mapped at zero as this would mess up + the representation, but I don't think that will ever happen since + AIX uses page zero as a readonly const-zero area. + + For MData entries, the data section size acquired from /proc/../map + appears to also include the bss, so there is no need for any + further handling of that. + + isCH indicates whether an AnonC area is part of the client heap + or not. May not be set for any other kind of area. + + File and member names are entries into the string table. + + fromP, for AnonC/AnonV, if True, indicates that the segment was + allocated from a PreAlloc area, and so should be returned to that + state upon deallocation. If False, indicates that the segment + should be unmapped on deallocation. +*/ +typedef + struct { + AixSegKind kind; + + /* ALL: extent */ + /* Note: zero-length segments are not allowed. That guarantees + that start <= end. */ + Addr start; // lowest addr in range (ALL) + Addr end; // highest addr in range (ALL) + + /* ALL except Free */ + Bool hasR; + Bool hasW; + Bool hasX; + + /* misc */ + Addr sibling; // MText, MData only: addr of MData/MText + Bool isMainExe; // MText only: is this the main executable? + Bool isCH; // AnonC only: is this part of the client's heap? + Bool fromP; // AnonC, AnonV only: originated from PreAlloc? + UChar* fname; // MText, FileV only: filename + UChar* mname; // MText only: member name if present + Off64T offset; // FileV only: file offset + } + AixSegment; + + +#define VG_N_ASEGMENTS 5000 + +typedef + struct { + AixSegment seg[VG_N_ASEGMENTS]; + Int used; + } + AixSegments; + + +/* ------ start of STATE for the address-space manager ------ */ + +/* A table of zero-terminated strings (file names etc). This + is only ever added to. */ + +#define VG_N_ASTRTAB 200000 +static Int strtab_used = 0; +static UChar strtab[VG_N_ASTRTAB]; + +#define Addr_MIN ((Addr)0) +#define Addr_MAX ((Addr)(-1ULL)) + +/* The main array of AixSegments, in order as required. */ + +static AixSegments asegs_pri; + +/* and two auxiliary arrays. */ + +static AixSegments asegs_tnew; +static AixSegments asegs_told; + +/* The assumed size of the main thread's stack, so that we can add a + segment for it at startup. */ + +#define N_FAKE_STACK_PAGES_MIN 4096 /* 16M fake stack */ /* default size */ +#define N_FAKE_STACK_PAGES_MAX 32768 /* 128M fake stack */ /* max size? */ + + +/* Hacks which are probably for AIX 'millicode'. Note: ensure + these stay page aligned. */ + +#define MAGIC_PAGES_1_BASE 0x3000 +#define MAGIC_PAGES_1_SIZE (2*0x1000) + +#define MAGIC_PAGES_2_BASE 0xC000 +#define MAGIC_PAGES_2_SIZE (4*0x1000) + + +#define AM_SANITY_CHECK(_who) \ + do { \ + if (VG_(clo_sanity_level >= 3)) { \ + Bool ok = sane_AixSegments(&asegs_pri); \ + if (!ok) \ + VG_(debugLog)(0,"aspace", "sanity check failed, " \ + "who = %s\n", _who); \ + aspacem_assert(ok); \ + } \ + } while (0) + +/* When preallocating a block from sbrk-world, how much extra + should we pre-emptively acquire? */ + +//#define AM_PREALLOC_EXTRA (512 * 1024) +//#define AM_PREALLOC_EXTRA 0x0800000 /* 8 M */ +#define AM_PREALLOC_EXTRA 0x4000000 /* 64 M */ + +/* The AIX5 aspacem implementation needs to be told when it is and + isn't allowed to use sbrk to allocate memory. Hence: */ +Bool VG_(am_aix5_sbrk_allowed) = True; + +/* ------ end of STATE for the address-space manager ------ */ + +/* ------ Forwards decls ------ */ +static void parse_procselfmap ( /*OUT*/ AixSegments* ); + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Stuff for 4K (small-page-size) rounding. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +#define AM_4K_PAGESZ 4096 + +static Bool AM_IS_4K_ALIGNED ( UWord w ) +{ + UWord m = AM_4K_PAGESZ-1; + return toBool( (w & m) == 0 ); +} + +static UWord AM_4K_ROUNDUP ( UWord w ) +{ + UWord m = AM_4K_PAGESZ-1; + return (w+m) & (~m); +} + +static UWord AM_64K_ROUNDUP ( UWord w ) +{ + UWord m = 0x10000-1; + return (w+m) & (~m); +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- String table management. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Add the given string into the string table (or find an existing + copy of it) and return a pointer to the in-table version. The + pointer will be valid for the entire rest of the run. */ + +static UChar* add_to_strtab ( UChar* str ) +{ + Int off, len; + /* First, look for the string. */ + off = 0; + while (off < strtab_used) { + if (0 == VG_(strcmp)(str, &strtab[off])) + return &strtab[off]; + off += VG_(strlen)(&strtab[off]) + 1; + } + /* not present? we'll have to copy it then. */ + len = VG_(strlen)(str); + if (len + 1 + strtab_used > VG_N_ASTRTAB) + ML_(am_barf_toolow)("VG_N_ASTRTAB"); + off = strtab_used; + for (; *str; str++) + strtab[strtab_used++] = *str; + strtab[strtab_used++] = 0; + aspacem_assert(strtab_used <= VG_N_ASTRTAB); + return &strtab[off]; +} + + +static Bool is_in_strtab ( UChar* str ) +{ + if (str < &strtab[0]) + return False; + if (str >= &strtab[strtab_used]) + return False; + if (str > &strtab[0] && str[-1] != 0) + return False; + return True; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Low level AixSegment stuff. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +static void init_AixSegment ( AixSegment* s ) +{ + s->kind = 0; /* invalid */ + s->start = 0; + s->end = 0; + s->hasR = False; + s->hasW = False; + s->hasX = False; + s->sibling = 0; + s->isMainExe = False; + s->isCH = False; + s->fromP = False; + s->fname = NULL; + s->mname = NULL; + s->offset = 0; +} + + +static HChar* name_of_AixSegKind ( AixSegKind sk ) +{ + switch (sk) { + case ASkFree: return "Free "; + case ASkMText: return "MText"; + case ASkMData: return "MData"; + case ASkAnonV: return "AnonV"; + case ASkAnonC: return "AnonC"; + case ASkFileV: return "FileV"; + case ASkShmemC: return "ShmC "; + case ASkPreAlloc: return "PreAl"; + default: ML_(am_barf)("name_of_AixSegKind"); + /*NOTREACHED*/ + return NULL; + } +} + + +static +void show_AixSegment ( Int logLevel, Int segNo, AixSegment* seg ) +{ + HChar* segName = name_of_AixSegKind( seg->kind ); + switch (seg->kind) { + case ASkFree: + VG_(debugLog)(logLevel, "aspacem", + "%3d: %s %010llx-%010llx\n", + segNo, /*segName*/" ", + (ULong)seg->start, (ULong)seg->end + ); + break; + case ASkMText: + VG_(debugLog)(logLevel, "aspacem", + "%3d: %s %010llx-%010llx %c%c%c-- (d %010llx) %s%s%s%s\n", + segNo, seg->isMainExe ? "MTEXT" : "MText", + (ULong)seg->start, (ULong)seg->end, + seg->hasR ? 'r' : '-', + seg->hasW ? 'w' : '-', + seg->hasX ? 'x' : '-', + (ULong)seg->sibling, + seg->fname, + seg->mname ? "(" : "", + seg->mname ? (HChar*)seg->mname : "", + seg->mname ? ")" : "" + ); + break; + case ASkMData: + VG_(debugLog)(logLevel, "aspacem", + "%3d: %s %010llx-%010llx %c%c%c-- (t %010llx)\n", + segNo, "MData", + (ULong)seg->start, (ULong)seg->end, + seg->hasR ? 'r' : '-', + seg->hasW ? 'w' : '-', + seg->hasX ? 'x' : '-', + (ULong)seg->sibling + ); + break; + case ASkFileV: + VG_(debugLog)(logLevel, "aspacem", + "%3d: %s %010llx-%010llx %c%c%c-- %6lld %s\n", + segNo, segName, + (ULong)seg->start, (ULong)seg->end, + seg->hasR ? 'r' : '-', + seg->hasW ? 'w' : '-', + seg->hasX ? 'x' : '-', + seg->offset, + seg->fname + ); + break; + case ASkAnonV: + case ASkAnonC: + case ASkShmemC: + VG_(debugLog)(logLevel, "aspacem", + "%3d: %s %010llx-%010llx %c%c%c%c%c\n", + segNo, segName, + (ULong)seg->start, (ULong)seg->end, + seg->hasR ? 'r' : '-', + seg->hasW ? 'w' : '-', + seg->hasX ? 'x' : '-', + seg->kind==ASkAnonC && seg->isCH ? 'H' : '-', + seg->fromP ? 'P' : '-' + ); + break; + case ASkPreAlloc: + VG_(debugLog)(logLevel, "aspacem", + "%3d: %s %010llx-%010llx %c%c%c-- (size %llu)\n", + segNo, segName, + (ULong)seg->start, (ULong)seg->end, + seg->hasR ? 'r' : '-', + seg->hasW ? 'w' : '-', + seg->hasX ? 'x' : '-', + (ULong)seg->end - (ULong)seg->start + 1 + ); + break; + default: + VG_(debugLog)(logLevel, "aspacem", + "%3d: show_AixSegment: unknown segment\n", + segNo); + break; + } +} + + +static void init_AixSegments ( AixSegments* segs ) +{ + segs->used = 1; + init_AixSegment( &segs->seg[0] ); + segs->seg[0].kind = ASkFree; + segs->seg[0].start = Addr_MIN; + segs->seg[0].end = Addr_MAX; +} + + +static +void show_AixSegments ( Int logLevel, HChar* who, AixSegments* segs ) +{ + Int i; + VG_(debugLog)(logLevel, "aspacem", "<<< %s\n", who); + for (i = 0; i < segs->used; i++) + show_AixSegment( logLevel, i, &segs->seg[i] ); + VG_(debugLog)(logLevel, "aspacem", ">>>\n"); +} + + +static Bool sane_AixSegment ( AixSegment* seg ) +{ + /* disallow zero and negative length segments */ + if (seg->end < seg->start) + return False; + + switch (seg->kind) { + case ASkFree: + if (seg->hasR || seg->hasW || seg->hasX) + return False; + if (seg->isMainExe || seg->sibling != 0 || seg->offset != 0) + return False; + if (seg->fname || seg->mname) + return False; + if (seg->isCH || seg->fromP) + return False; + break; + case ASkMText: + if (!is_in_strtab(seg->fname)) + return False; + if (seg->mname && !is_in_strtab(seg->mname)) + return False; + if (seg->offset != 0) + return False; + if (seg->isCH || seg->fromP) + return False; + break; + case ASkMData: + if (seg->isMainExe || seg->sibling == 0 || seg->offset != 0) + return False; + /* fname/mname have to be allowed in MData, else + read_procselfmap doesn't work. Unfortunately. */ + /* + if (seg->fname || seg->mname) + return False; + */ + if (seg->isCH || seg->fromP) + return False; + break; + case ASkFileV: + if (!is_in_strtab(seg->fname)) + return False; + if (seg->mname != NULL) + return False; + if (seg->isMainExe || seg->sibling != 0) + return False; + if (seg->isCH || seg->fromP) + return False; + break; + case ASkShmemC: + case ASkAnonV: + case ASkAnonC: + if (seg->fname || seg->mname) + return False; + if (seg->isMainExe || seg->sibling != 0) + return False; + if (seg->offset != 0) + return False; + if (seg->kind != ASkAnonC && seg->isCH) + return False; + if ( (!(seg->kind == ASkAnonV || seg->kind == ASkAnonC)) + && seg->fromP) + return False; + break; + case ASkPreAlloc: + if (seg->fname || seg->mname) + return False; + if (seg->isMainExe || seg->sibling != 0) + return False; + if (seg->offset != 0) + return False; + if (seg->kind != ASkAnonC && seg->isCH) + return False; + if (seg->fromP) + return False; + if (!AM_IS_4K_ALIGNED(seg->start)) + return False; + if (!AM_IS_4K_ALIGNED(seg->end + 1)) + return False; + if (!(seg->hasR && seg->hasW && seg->hasX)) + return False; + break; + default: + return False; + } + return True; +} + + +/* Binary search the interval array for a given address. Since the + array covers the entire address space the search cannot fail. */ +static Int find_asegment_idx ( AixSegments* segs, Addr a ) +{ + Addr a_mid_lo, a_mid_hi; + Int mid, + lo = 0, + hi = segs->used-1; + aspacem_assert(lo <= hi); + while (True) { + /* current unsearched space is from lo to hi, inclusive. */ + if (lo > hi) { + /* Not found. This can't happen. */ + ML_(am_barf)("find_nsegment_idx: not found"); + } + mid = (lo + hi) / 2; + a_mid_lo = segs->seg[mid].start; + a_mid_hi = segs->seg[mid].end; + + if (a < a_mid_lo) { hi = mid-1; continue; } + if (a > a_mid_hi) { lo = mid+1; continue; } + aspacem_assert(a >= a_mid_lo && a <= a_mid_hi); + aspacem_assert(0 <= mid && mid < segs->used); + return mid; + } +} + + +static Bool sane_AixSegments ( AixSegments* segs ) +{ + Int i; + + /* Check endpoints */ + if (segs->used < 1 || segs->used > VG_N_ASEGMENTS) { + VG_(debugLog)(0, "aspacem", "sane_AixSegments: bad ->used"); + return False; + } + if (segs->seg[0].start != Addr_MIN + || segs->seg[segs->used-1].end != Addr_MAX) { + VG_(debugLog)(0, "aspacem", "sane_AixSegments: bad endpoints"); + return False; + } + + /* Check each segment, and check entire range is covered. */ + for (i = 0; i < segs->used; i++) { + if (!sane_AixSegment( &segs->seg[i] )) { + VG_(debugLog)(0, "aspacem", + "sane_AixSegments: bad segment %d\n", i); + return False; + } + } + for (i = 1; i < segs->used; i++) { + if (segs->seg[i-1].end + 1 != segs->seg[i].start) { + VG_(debugLog)(0, "aspacem", + "sane_AixSegments: bad transition at %d/%d\n", i-1,i); + return False; + } + } + + /* Now we know 'seg' is safe for use in find_asegment_idx(). + Check the sibling pointers for MText/MData. + + Also check that the segment starting at address zero is neither + MText nor MData (since this would mess up the sibling pointer + representation; see comments above.) Failure of this is not per + se a logic failure, but it does indicate that the kernel + unexpectedly placed MText or MData at zero, and our + representation is therefore inadequate. + */ + if (segs->seg[0].kind == ASkMText || segs->seg[0].kind == ASkMData) { + VG_(debugLog)(0, "aspacem", + "sane_AixSegments: ASkMText/ASkMData at address zero\n"); + return False; + } + + for (i = 0; i < segs->used-1; i++) { + + AixSegment *s1, *s2; + + s1 = &segs->seg[i]; + + if (s1->kind == ASkMData) { + s2 = &segs->seg[ find_asegment_idx(segs, s1->sibling) ]; + if (s2->kind != ASkMText + || find_asegment_idx(segs, s2->sibling) != i) { + VG_(debugLog)(0, "aspacem", "sane_AixSegments: bad sibling " + "link(s) for ASkData\n"); + return False; + } + } + + if (s1->kind == ASkMText && s1->sibling != 0) { + s2 = &segs->seg[ find_asegment_idx(segs, s1->sibling) ]; + if (s2->kind != ASkMData + || find_asegment_idx(segs, s2->sibling) != i) { + VG_(debugLog)(0, "aspacem", "sane_AixSegments: bad sibling " + "link(s) for ASkText\n"); + return False; + } + } + + } + + return True; +} + + +/* Try merging s2 into s1, if possible. If successful, s1 is + modified, and True is returned. Otherwise s1 is unchanged and + False is returned. */ + +static Bool maybe_merge_asegments ( AixSegment* s1, AixSegment* s2 ) +{ + if (s1->kind != s2->kind) + return False; + + if (s1->end+1 != s2->start) + return False; + + switch (s1->kind) { + + case ASkFree: + s1->end = s2->end; + return True; + + case ASkAnonC: + case ASkAnonV: + if (s1->hasR == s2->hasR && s1->hasW == s2->hasW + && s1->hasX == s2->hasX && s1->isCH == s2->isCH + && s1->fromP == s2->fromP) { + s1->end = s2->end; + return True; + } + break; + + /* not really necessary, but .. */ + case SkFileV: + if (s1->hasR == s2->hasR + && s1->hasW == s2->hasW && s1->hasX == s2->hasX + && s1->fname == s2->fname + && s2->offset == s1->offset + + ((ULong)s2->start) - ((ULong)s1->start) ) { + s1->end = s2->end; + return True; + } + break; + + /* it's important to merge PreAlloc's back together to avoid + fragmenting PreAlloc'd space unnecessarily */ + case ASkPreAlloc: + s1->end = s2->end; + return True; + + default: + break; + } + + return False; +} + + +/* Merge mergable segments in SEGS. */ + +static void preen_asegments ( AixSegments* segs ) +{ + Int r, w; + + aspacem_assert(segs->used >= 1); + if (segs->used == 1) + return; + + w = 0; + for (r = 1; r < segs->used; r++) { + if (maybe_merge_asegments(&segs->seg[w], &segs->seg[r])) { + /* nothing */ + } else { + w++; + if (w != r) + segs->seg[w] = segs->seg[r]; + } + } + w++; + aspacem_assert(w > 0 && w <= segs->used); + segs->used = w; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Modifying a segment array, and constructing segments. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Split the segment containing 'a' into two, so that 'a' is + guaranteed to be the start of a new segment. If 'a' is already the + start of a segment, do nothing. */ + +static void split_asegment_at ( AixSegments* segs, Addr a ) +{ + Int i, j; + + aspacem_assert(a > 0); + aspacem_assert(segs->used >= 1); + + i = find_asegment_idx(segs, a); + aspacem_assert(i >= 0 && i < segs->used); + + if (segs->seg[i].start == a) + /* 'a' is already the start point of a segment, so nothing to be + done. */ + return; + + /* else we have to slide the segments upwards to make a hole */ + if (segs->used >= VG_N_ASEGMENTS) + ML_(am_barf_toolow)("VG_N_ASEGMENTS"); + for (j = segs->used-1; j > i; j--) + segs->seg[j+1] = segs->seg[j]; + segs->used++; + + segs->seg[i+1] = segs->seg[i]; + segs->seg[i+1].start = a; + segs->seg[i].end = a-1; + + if (segs->seg[i].kind == ASkFileV /* || segs->seg[i].kind == ASkFileC*/) + segs->seg[i+1].offset + += ((ULong)segs->seg[i+1].start) - ((ULong)segs->seg[i].start); + + aspacem_assert(sane_AixSegment(&segs->seg[i])); + aspacem_assert(sane_AixSegment(&segs->seg[i+1])); +} + + +/* Do the minimum amount of segment splitting necessary to ensure that + sLo is the first address denoted by some segment and sHi is the + highest address denoted by some other segment. Returns the indices + of the lowest and highest segments in the range. */ + +static +void split_asegments_lo_and_hi ( AixSegments* segs, + Addr sLo, Addr sHi, + /*OUT*/Int* iLo, + /*OUT*/Int* iHi ) +{ + aspacem_assert(sLo < sHi); + + if (sLo > 0) + split_asegment_at(segs, sLo); + if (sHi < Addr_MAX) + split_asegment_at(segs, sHi+1); + + *iLo = find_asegment_idx(segs,sLo); + *iHi = find_asegment_idx(segs,sHi); + aspacem_assert(0 <= *iLo && *iLo < segs->used); + aspacem_assert(0 <= *iHi && *iHi < segs->used); + aspacem_assert(*iLo <= *iHi); + aspacem_assert(segs->seg[*iLo].start == sLo); + aspacem_assert(segs->seg[*iHi].end == sHi); + /* Not that I'm overly paranoid or anything, definitely not :-) */ +} + + +/* Add SEG to the collection, deleting/truncating any it overlaps. + This deals with all the tricky cases of splitting up segments as + needed. Contents of SEG are copied. */ + +static void add_asegment ( AixSegments* segs, AixSegment* seg ) +{ + Int i, iLo, iHi, delta; + Bool segment_is_sane; + + Addr sStart = seg->start; + Addr sEnd = seg->end; + + aspacem_assert(sStart <= sEnd); + + segment_is_sane = sane_AixSegment(seg); + if (!segment_is_sane) show_AixSegment(0,0,seg); + aspacem_assert(segment_is_sane); + + split_asegments_lo_and_hi( segs, sStart, sEnd, &iLo, &iHi ); + + /* Now iLo .. iHi inclusive is the range of segment indices which + seg will replace. If we're replacing more than one segment, + slide those above the range down to fill the hole. */ + delta = iHi - iLo; + aspacem_assert(delta >= 0); + if (delta > 0) { + for (i = iLo; i < segs->used-delta; i++) + segs->seg[i] = segs->seg[i+delta]; + segs->used -= delta; + } + aspacem_assert(segs->used >= 1); + + segs->seg[iLo] = *seg; + + preen_asegments(segs); + if (0) VG_(am_show_nsegments)(0,"AFTER preen (add_segment)"); +} + + +/* Convert everything in SEG except MData and MText into Free, + then preen, so as to retain normalised form. */ + +static void knockout_non_module_segs ( AixSegments* segs ) +{ + Int i; + Addr s, e; + for (i = 0; i < segs->used; i++) { + if (segs->seg[i].kind == ASkFree + || segs->seg[i].kind == ASkMText + || segs->seg[i].kind == ASkMData) + continue; + s = segs->seg[i].start; + e = segs->seg[i].end; + init_AixSegment( &segs->seg[i] ); + segs->seg[i].start = s; + segs->seg[i].end = e; + segs->seg[i].kind = ASkFree; + } + preen_asegments(segs); + aspacem_assert( sane_AixSegments(segs) ); +} + + +/* Copy a segment array. */ + +static void copy_asegments_d_s ( AixSegments* dst, AixSegments* src ) +{ + Int i; + aspacem_assert(src->used >= 1 && src->used < VG_N_ASEGMENTS); + dst->used = src->used; + for (i = 0; i < src->used; i++) + dst->seg[i] = src->seg[i]; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Re-reading /proc/../map and updating MText/MData segments ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Find out the size of the AixCodeSegChange that must be + presented to VG_(am_aix5_reread_procmap). */ + +Int VG_(am_aix5_reread_procmap_howmany_directives)(void) +{ + /* In the worst imaginable case, all the tracked modules could have + disappeared and been replaced with different ones. Hence: */ + return 2 * VG_N_ASEGMENTS; +} + + +static +void add_pri_text_and_data_segs ( AixSegment* tnew, AixSegment* dnew ) +{ + Bool dExists = (dnew->end - dnew->start + 1) != 0; + aspacem_assert(tnew->kind == ASkMText); + aspacem_assert(dnew->kind == ASkMData); + if (dExists) { + aspacem_assert(tnew->sibling == dnew->start); + aspacem_assert(dnew->sibling == tnew->start); + add_asegment(&asegs_pri, tnew); + add_asegment(&asegs_pri, dnew); + } else { + aspacem_assert(tnew->sibling == 0); + add_asegment(&asegs_pri, tnew); + } +} + +static +void del_pri_text_and_data_segs ( AixSegment* told, AixSegment* dold ) +{ + AixSegment fre; + Bool dExists = (dold->end - dold->start + 1) != 0; + aspacem_assert(told->kind == ASkMText); + aspacem_assert(dold->kind == ASkMData); + init_AixSegment( &fre ); + fre.kind = ASkFree; + if (dExists) { + aspacem_assert(told->sibling == dold->start); + aspacem_assert(dold->sibling == told->start); + fre.start = told->start; + fre.end = told->end; + add_asegment(&asegs_pri, &fre); + fre.start = dold->start; + fre.end = dold->end; + add_asegment(&asegs_pri, &fre); + } else { + aspacem_assert(told->sibling == 0); + fre.start = told->start; + fre.end = told->end; + add_asegment(&asegs_pri, &fre); + } +} + + +/* Tell aspacem that /proc/<pid>/map may have changed (eg following + __loadx) and so it should be re-read, and the code/data segment + list updated accordingly. The resulting array of AixCodeChangeSeg + directives are written to 'directives', and the number of entries + to *ndirectives. */ + +void VG_(am_aix5_reread_procmap) + ( /*OUT*/AixCodeSegChange* directives, /*OUT*/Int* ndirectives ) +{ + Int ixold, ixnew; + Bool done_old, done_new; + AixSegment *olds, *news; + + /* First, read /proc/../map into asegs_tnew. Copy asegs_pri into + asegs_told, and remove everything except MData and MText, so as + to generate something we can sanely compare with asegs_tnew. + Walk asegs_told and asegs_tnew together, writing the differences + to 'directives', and modifying asegs_pri accordingly. */ + parse_procselfmap( &asegs_tnew ); + copy_asegments_d_s( &asegs_told, &asegs_pri ); + knockout_non_module_segs( &asegs_told ); + + *ndirectives = 0; + +# define MODIFY_PRI(_dir, _asegs, _ixt, _acquire) \ + do { \ + Int _ixd; \ + AixSegment *_segt, *_segd; \ + AixSegment _segd_dummy; \ + aspacem_assert(_ixt >= 0 && _ixt < _asegs.used); \ + _segt = &_asegs.seg[_ixt]; \ + aspacem_assert(_segt->kind == ASkMText); \ + if (_segt->sibling) { \ + _ixd = find_asegment_idx( &_asegs, _segt->sibling ); \ + _segd = &_asegs.seg[_ixd]; \ + aspacem_assert(_segd->kind == ASkMData); \ + aspacem_assert(_segt->sibling == _segd->start); \ + } else { \ + init_AixSegment( &_segd_dummy ); \ + _segd_dummy.kind = ASkMData; \ + _segd_dummy.start = 1; \ + _segd_dummy.end = 0; \ + _segd = &_segd_dummy; \ + } \ + if (_segd != &_segd_dummy) \ + aspacem_assert(_segd->sibling == _segt->start); \ + \ + (_dir).code_start = (_segt)->start; \ + (_dir).code_len = (_segt)->end - (_segt)->start + 1; \ + (_dir).data_start = (_segd)->start; \ + (_dir).data_len = (_segd)->end - (_segd)->start + 1; \ + (_dir).file_name = (_segt)->fname; \ + (_dir).mem_name = (_segt)->mname; \ + (_dir).is_mainexe = (_acquire) ? (_segt)->isMainExe : False; \ + (_dir).acquire = (_acquire); \ + \ + if (_acquire) { \ + add_pri_text_and_data_segs( _segt, _segd ); \ + } else { \ + del_pri_text_and_data_segs( _segt, _segd ); \ + } \ + } while (0) + + ixold = 0; /* indexes asegs_told */ + ixnew = 0; /* indexes asegs_tnew */ + + while (True) { + + aspacem_assert(ixold >= 0 && ixold < asegs_told.used); + aspacem_assert(ixnew >= 0 && ixnew < asegs_tnew.used); + + /* Advance ixold and ixnew to the next MText in their + respective arrays. */ + while (ixold < asegs_told.used + && asegs_told.seg[ixold].kind != ASkMText) { + aspacem_assert(asegs_told.seg[ixold].kind == ASkFree + || asegs_told.seg[ixold].kind == ASkMData); + ixold++; + } + while (ixnew < asegs_tnew.used + && asegs_tnew.seg[ixnew].kind != ASkMText) { + aspacem_assert(asegs_tnew.seg[ixnew].kind == ASkFree + || asegs_tnew.seg[ixnew].kind == ASkMData); + ixnew++; + } + + aspacem_assert(ixold >= 0 && ixold <= asegs_told.used); + aspacem_assert(ixnew >= 0 && ixnew <= asegs_tnew.used); + + done_old = ixold == asegs_told.used; + done_new = ixnew == asegs_tnew.used; + + if (done_old && done_new) + goto both_done; + if (done_old && !done_new) + goto finishup_new; + if (done_new && !done_old) + goto finishup_old; + + olds = &asegs_told.seg[ixold]; + news = &asegs_tnew.seg[ixnew]; + + aspacem_assert(olds->kind == ASkMText); + aspacem_assert(news->kind == ASkMText); + + if (0) { + show_AixSegment(0,ixold,&asegs_told.seg[ixold]); + show_AixSegment(0,ixnew,&asegs_tnew.seg[ixnew]); + VG_(debugLog)(0, "aspacem", "\n"); + } + + /* Here, if olds->start < news->start, then the old sequence has + an entry which the new one doesn't, so a module has been + unloaded. If news->start < olds->start then the new sequence + has a module the old one doesn't, so a module has been + loaded. If news->start ==olds->start then the module is + unchanged. Except, we should check a bit more carefully in + the zero case. */ + if (olds->start == news->start) { + if (olds->start == news->start + && olds->end == news->end + && olds->fname == news->fname + && olds->mname == news->mname + && olds->sibling == news->sibling + && olds->isMainExe == news->isMainExe) { + /* really identical, do nothing */ + } else { + /* Dubious; mark it as an unload of old and load of + new. */ + MODIFY_PRI(directives[*ndirectives], asegs_told, ixold, False); + (*ndirectives)++; + aspacem_assert(*ndirectives <= 2 * VG_N_ASEGMENTS); + MODIFY_PRI(directives[*ndirectives], asegs_tnew, ixnew, True); + (*ndirectives)++; + aspacem_assert(*ndirectives <= 2 * VG_N_ASEGMENTS); + } + ixold++; + ixnew++; + continue; + } + + if (olds->start < news->start) { + /* discard olds */ + MODIFY_PRI(directives[*ndirectives], asegs_told, ixold, False); + (*ndirectives)++; + aspacem_assert(*ndirectives <= 2 * VG_N_ASEGMENTS); + ixold++; + continue; + } + + if (news->start < olds->start) { + /* acquire news */ + MODIFY_PRI(directives[*ndirectives], asegs_tnew, ixnew, True); + (*ndirectives)++; + aspacem_assert(*ndirectives <= 2 * VG_N_ASEGMENTS); + ixnew++; + continue; + } + /* NOTREACHED */ + aspacem_assert(0); + } + + finishup_new: + olds = NULL; + aspacem_assert(ixold == asegs_told.used); + aspacem_assert(ixnew < asegs_tnew.used); + while (ixnew < asegs_tnew.used) { + news = &asegs_tnew.seg[ixnew]; + aspacem_assert(news->kind == ASkMText || news->kind == ASkMData + || news->kind == ASkFree); + if (news->kind == ASkMText) { + MODIFY_PRI(directives[*ndirectives], asegs_tnew, ixnew, True); + (*ndirectives)++; + aspacem_assert(*ndirectives <= 2 * VG_N_ASEGMENTS); + } + ixnew++; + } + goto both_done; + + finishup_old: + news = NULL; + aspacem_assert(ixnew == asegs_tnew.used); + aspacem_assert(ixold < asegs_told.used); + while (ixold < asegs_told.used) { + olds = &asegs_told.seg[ixold]; + aspacem_assert(olds->kind == ASkMText || olds->kind == ASkMData + || olds->kind == ASkFree); + if (olds->kind == ASkMText) { + MODIFY_PRI(directives[*ndirectives], asegs_told, ixold, False); + (*ndirectives)++; + aspacem_assert(*ndirectives <= 2 * VG_N_ASEGMENTS); + } + ixold++; + } + goto both_done; + + both_done: + aspacem_assert(ixold == asegs_told.used); + aspacem_assert(ixnew == asegs_tnew.used); + + asegs_tnew.used = 0; + asegs_told.used = 0; + + aspacem_assert( sane_AixSegments(&asegs_pri) ); + +# undef MODIFY_PRI +} + + +/* Set the initial stack segment. Contains kludgery. Also take the + opportunity to create fake segs for the millicode areas. */ + +void VG_(am_aix5_set_initial_client_sp)( Addr sp ) +{ + static Bool done = False; + AixSegment seg; + Word n_fake_stack_pages; + Word m1 = 1048576; + + aspacem_assert(!done); + done = True; + + /* We are given the initial client SP (that of the root thread). + Already on the stack are argv and env. How far up does it + extend? We assume to the next 64k boundary. How far down does + it extend? We assume N_FAKE_STACK_PAGES small pages - by + default 16M. Establish those limits and add an AnonC rwx + segment. */ + + /* The 64k boundary is "justified" as follows. On 32-bit AIX 5.3, + a typical initial SP is 0x2FF22xxx, but the accessible (rw) area + beyond that extends up to 0x2FF2FFFF - the next 64k boundary. + In 64-bit mode, a typical initial SP might be + 0xFFF'FFFF'FFFF'E920, and the accessible area extends to + 0xFFF'FFFF'FFFF'FFFF. So in both cases, (64k roundup of sp) - 1 + gives the end of the accessible area. */ + VG_(debugLog)(1,"aspacem", "aix5_set_initial_client_sp( %p )\n", + (void*)sp); + + init_AixSegment( &seg ); + seg.kind = ASkAnonC; + seg.hasR = seg.hasW = seg.hasX = True; + + if (sizeof(void*) == 4 + && ((sp & 0xFFFF0000) == 0x2FF20000 + || (sp & 0xFFFF0000) == 0x2FF10000)) { + /* Gaaah. Special-case 32-bit mode. */ + seg.end = 0x2FF2FFFF; + } else { + seg.end = AM_64K_ROUNDUP(sp) - 1; + } + + n_fake_stack_pages = N_FAKE_STACK_PAGES_MIN; + if (VG_(clo_main_stacksize) > 0 + && ((m1+VG_(clo_main_stacksize)) / VKI_PAGE_SIZE) > n_fake_stack_pages) { + n_fake_stack_pages = (m1+VG_(clo_main_stacksize)) / VKI_PAGE_SIZE; + } + if (n_fake_stack_pages > N_FAKE_STACK_PAGES_MAX) { + /* Allocation of the stack failed. We have to stop. */ + VG_(debugLog)( + 0, "aspacem", + "valgrind: " + "I failed to allocate space for the application's stack.\n"); + VG_(debugLog)( + 0, "aspacem", + "valgrind: " + "This may be the result of a very large --max-stackframe=\n"); + VG_(debugLog)( + 0, "aspacem", + "valgrind: " + "setting. Cannot continue. Sorry.\n\n"); + ML_(am_exit)(0); + } + + seg.start = seg.end+1 - n_fake_stack_pages * VKI_PAGE_SIZE; + + VG_(debugLog)(1,"aspacem", "aix5_set_initial_client_sp: stack seg:\n"); + show_AixSegment(1,0, &seg); + add_asegment( &asegs_pri, &seg ); + + init_AixSegment( &seg ); + seg.kind = ASkAnonC; + seg.hasR = seg.hasX = True; + seg.start = MAGIC_PAGES_1_BASE; + seg.end = MAGIC_PAGES_1_BASE + MAGIC_PAGES_1_SIZE - 1; + VG_(debugLog)(1,"aspacem", "am_aix5_set_initial_client_sp: FAKE1 seg:\n"); + show_AixSegment(1,0, &seg); + add_asegment( &asegs_pri, &seg ); + + init_AixSegment( &seg ); + seg.kind = ASkAnonC; + seg.hasR = seg.hasX = True; + seg.start = MAGIC_PAGES_2_BASE; + seg.end = MAGIC_PAGES_2_BASE + MAGIC_PAGES_2_SIZE - 1; + VG_(debugLog)(1,"aspacem", "am_aix5_set_initial_client_sp: FAKE2 seg:\n"); + show_AixSegment(1,0, &seg); + add_asegment( &asegs_pri, &seg ); +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Getting segment-starts. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Print out the segment array (debugging only!). */ +void VG_(am_show_nsegments) ( Int logLevel, HChar* who ) +{ + show_AixSegments( logLevel, who, &asegs_pri ); +} + +/* Get the filename corresponding to this segment, if known and if it + has one. The returned name's storage cannot be assumed to be + persistent, so the caller should immediately copy the name + elsewhere. On AIX5, we don't know what this is (in general) + so just return NULL. */ +HChar* VG_(am_get_filename)( NSegment const* seg ) +{ + return NULL; +} + +/* Collect up the start addresses of all non-free, non-resvn segments. + The interface is a bit strange in order to avoid potential + segment-creation races caused by dynamic allocation of the result + buffer *starts. + + The function first computes how many entries in the result + buffer *starts will be needed. If this number <= nStarts, + they are placed in starts[0..], and the number is returned. + If nStarts is not large enough, nothing is written to + starts[0..], and the negation of the size is returned. + + Correct use of this function may mean calling it multiple times in + order to establish a suitably-sized buffer. */ + +Int VG_(am_get_segment_starts)( Addr* starts, Int nStarts ) +{ + Int i, j, nSegs; + + /* don't pass dumbass arguments */ + aspacem_assert(nStarts >= 0); + + nSegs = 0; + for (i = 0; i < asegs_pri.used; i++) { + if (asegs_pri.seg[i].kind == ASkFree + || asegs_pri.seg[i].kind == ASkPreAlloc) + continue; + nSegs++; + } + + if (nSegs > nStarts) { + /* The buffer isn't big enough. Tell the caller how big it needs + to be. */ + return -nSegs; + } + + /* There's enough space. So write into the result buffer. */ + aspacem_assert(nSegs <= nStarts); + + j = 0; + for (i = 0; i < asegs_pri.used; i++) { + if (asegs_pri.seg[i].kind == ASkFree + || asegs_pri.seg[i].kind == ASkPreAlloc) + continue; + starts[j++] = asegs_pri.seg[i].start; + } + + aspacem_assert(j == nSegs); /* this should not fail */ + return nSegs; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Sanity checking and preening of the segment array. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +Bool VG_(am_do_sync_check) ( const HChar* fn, + const HChar* file, Int line ) +{ + /* There's nothing we can do here; just return a dummy value. */ + return False; /* placate gcc */ +} + +/* Hook to allow sanity checks to be done from aspacemgr-common.c. */ +void ML_(am_do_sanity_check)( void ) +{ + Bool ok = sane_AixSegments( &asegs_pri ); + aspacem_assert(ok); +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Finding segments. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Finds the segment containing 'a'. Only returns file/anon/resvn + segments. On AIX5 this is pretty bogus; we fake up an entry as + best we can by snooping round for useful information in + asegs_pri. */ + +NSegment const* VG_(am_find_nsegment) ( Addr a ) +{ + Int i; + AixSegment* aseg; + static NSegment bogus; + + /* Fill in default info. */ + bogus.kind = SkAnonC; + bogus.start = 0; + bogus.end = 0; + bogus.smode = SmFixed; + bogus.dev = 0; + bogus.ino = 0; + bogus.mode = 0; + bogus.offset = 0; + bogus.fnIdx = -1; + bogus.hasR = bogus.hasW = bogus.hasX = False; + bogus.hasT = False; + bogus.isCH = False; + bogus.mark = False; + + /* Go look for it in the segment table. */ + i = find_asegment_idx( &asegs_pri, a ); + aspacem_assert(i >= 0 && i <= asegs_pri.used); + + aseg = &asegs_pri.seg[i]; + if (aseg->kind == ASkFree || aseg->kind == ASkPreAlloc) + return NULL; + + bogus.start = aseg->start; + bogus.end = aseg->end; + + /* Refine */ + switch (aseg->kind) { + case ASkMText: + bogus.kind = SkAnonC; /* hmm, pretty darn bogus */ + bogus.hasR = bogus.hasX = True; + break; + case ASkMData: + bogus.kind = SkAnonC; /* hmm, pretty darn bogus */ + bogus.hasR = bogus.hasW = True; + break; + case ASkShmemC: + bogus.kind = SkShmC; + bogus.hasR = aseg->hasR; + bogus.hasW = aseg->hasW; + bogus.hasX = aseg->hasX; + break; + case ASkAnonC: + bogus.kind = SkAnonC; + bogus.hasR = aseg->hasR; + bogus.hasW = aseg->hasW; + bogus.hasX = aseg->hasX; + bogus.isCH = aseg->isCH; + break; + case ASkAnonV: + bogus.kind = SkAnonV; + bogus.hasR = aseg->hasR; + bogus.hasW = aseg->hasW; + bogus.hasX = aseg->hasX; + break; + case ASkFileV: + bogus.kind = SkFileV; + bogus.hasR = aseg->hasR; + bogus.hasW = aseg->hasW; + bogus.hasX = aseg->hasX; + bogus.offset = aseg->offset; + break; + default: + aspacem_assert(0); + } + + return &bogus; +} + + +/* Find the next segment along from 'here', if it is a file/anon/resvn + segment. */ +NSegment const* VG_(am_next_nsegment) ( NSegment* here, Bool fwds ) +{ + ML_(am_barf)("unimplemented: VG_(am_next_nsegment)"); + return NULL; /* placate gcc */ +} + + +/* Trivial fn: return the total amount of space in anonymous mappings, + both for V and the client. Is used for printing stats in + out-of-memory messages. */ +ULong VG_(am_get_anonsize_total)( void ) +{ + Int i; + ULong total = 0; + for (i = 0; i < asegs_pri.used; i++) { + if (asegs_pri.seg[i].kind == ASkAnonC + || asegs_pri.seg[i].kind == ASkAnonV) { + total += (ULong)asegs_pri.seg[i].end + - (ULong)asegs_pri.seg[i].start + 1ULL; + } + } + return total; +} + + +/* Test if a piece of memory is addressable by the client with at + least the "prot" protection permissions by examining the underlying + segments. */ +Bool VG_(am_is_valid_for_client)( Addr start, SizeT len, + UInt prot ) +{ + NSegment const * const fake = VG_(am_find_nsegment)(start); + if (!fake) + return False; + aspacem_assert(fake->start <= start); + aspacem_assert(start + len - 1 <= fake->end); + if (fake->kind == SkAnonV || fake->kind == SkFileV) + return False; + if ((prot & VKI_PROT_READ) && !fake->hasR) + return False; + if ((prot & VKI_PROT_WRITE) && !fake->hasW) + return False; + if ((prot & VKI_PROT_EXEC) && !fake->hasX) + return False; + return True; +} + +/* Variant of VG_(am_is_valid_for_client) which allows free areas to + be considered part of the client's addressable space. It also + considers reservations to be allowable, since from the client's + point of view they don't exist. */ +Bool VG_(am_is_valid_for_client_or_free_or_resvn) + ( Addr start, SizeT len, UInt prot ) +{ + ML_(am_barf)("unimplemented: " + "VG_(am_is_valid_for_client_or_free_or_resvn)"); + /*NOTREACHED*/ + return False; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Startup, including reading /proc/self/maps. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Initialise the address space manager, setting up the initial + segment list, and reading /proc/self/maps into it. This must + be called before any other function. + + Takes a pointer to the SP at the time V gained control. This is + taken to be the highest usable address (more or less). Based on + that (and general consultation of tea leaves, etc) return a + suggested end address for the client's stack. */ + +Addr VG_(am_startup) ( Addr sp_at_startup ) +{ + aspacem_assert(sizeof(Word) == sizeof(void*)); + aspacem_assert(sizeof(Addr) == sizeof(void*)); + aspacem_assert(sizeof(SizeT) == sizeof(void*)); + aspacem_assert(sizeof(SSizeT) == sizeof(void*)); + + asegs_tnew.used = 0; + asegs_told.used = 0; + + asegs_pri.used = 1; + init_AixSegments( &asegs_pri ); + aspacem_assert( sane_AixSegments(&asegs_pri) ); + + if (0) + VG_(am_show_nsegments)(0,"AFTER VG_(am_startup)"); + + /* We do not make an initial read of /proc/../map since doing so + would leave us without a way to communicate the results to a + caller. Hence we expect that the caller (m_main) will call + VG_(am_aix5_reread_procmap) soon after this call so as to get + the initial code/data segments recorded. */ + + /* Return value is irrelevant since we don't lay out the + client's stack; it is already done. */ + return 0; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Preallocation (acquiring space from sbrk). ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +static +SysRes local_do_sbrk_NO_NOTIFY( Word delta ) +{ + SysRes res; + aspacem_assert(__NR_AIX5_sbrk != __NR_AIX5_UNKNOWN); + res = VG_(do_syscall1)(__NR_AIX5_sbrk, (UWord)delta); + /* kernel produces (-1, VKI_ENOMEM) on failure. I think that's + ok. */ + return res; +} + + +/* Find the ix of a prealloc section containing at least req_sz bytes, + or -1 if not found. Uses best-fit. */ + +static Int find_prealloc_idx ( SizeT req_sz ) +{ + SizeT best_sz, this_sz; + Int best_ix, i; + aspacem_assert(sizeof(SizeT) == sizeof(Addr)); + aspacem_assert(req_sz > 0); + aspacem_assert(AM_IS_4K_ALIGNED(req_sz)); + + best_sz = Addr_MAX; + best_ix = -1; + + for (i = 0; i < asegs_pri.used; i++) { + AixSegment* s = &asegs_pri.seg[i]; + if (s->kind != ASkPreAlloc) + continue; + this_sz + = s->end + 1 - s->start; + aspacem_assert(this_sz > 0); + aspacem_assert(AM_IS_4K_ALIGNED(this_sz)); + if (this_sz >= req_sz && this_sz < best_sz) { + best_sz = this_sz; + best_ix = i; + } + } + + return best_ix; +} + + +/* Create a new prealloc section containing req_sz bytes. Returns + False if failed, True on success. */ + +static Bool new_prealloc ( SizeT req_sz ) +{ + SysRes sres; + AixSegment seg; + Addr start; + SSizeT delta; + HChar* why = NULL; + + aspacem_assert(req_sz > 0); + aspacem_assert(AM_IS_4K_ALIGNED(req_sz)); + + /* m_syswrap may have decided that it's not currently safe to allow + allocations from sbrk-world. If so, we have to fail. */ + if (0 && !VG_(am_aix5_sbrk_allowed)) { + why = "sbrk disallowed"; + goto fail; + } + + /* Get the current limit. */ + sres = local_do_sbrk_NO_NOTIFY(0); + if (sres.isError) { + why = "initial sbrk failed"; + goto fail; + } + + /* Get it page aligned */ + delta = AM_4K_ROUNDUP(sres.res) - sres.res; + aspacem_assert(delta >= 0 && delta < AM_4K_PAGESZ); + if (delta > 0) { + sres = local_do_sbrk_NO_NOTIFY(delta); + if (sres.isError) { + why = "aligning sbrk failed"; + goto fail; + } + } + + /* Now the brk is aligned. Try to acquire the block. */ + sres = local_do_sbrk_NO_NOTIFY(0); + if (sres.isError) + return False; + start = sres.res; + aspacem_assert( AM_IS_4K_ALIGNED( start )); + + sres = local_do_sbrk_NO_NOTIFY( req_sz ); + if (sres.isError) { + why = "main sbrk failed"; + goto fail; + } + + /* If this fails, the kernel is acting strange. */ + aspacem_assert( sres.res == start ); + + init_AixSegment( &seg ); + seg.start = start; + seg.end = start + req_sz - 1; + seg.kind = ASkPreAlloc; + seg.hasR = seg.hasW = seg.hasX = True; /* presumably */ + add_asegment( &asegs_pri, &seg ); + + VG_(debugLog)( + 1, "aspacem", "new_prealloc: SUCCESS at 0x%llx size %lld\n", + (ULong)start, (ULong)req_sz + ); + return True; + + fail: + VG_(debugLog)(1, "aspacem", "new_prealloc: FAILED: %s\n", why); + return False; +} + + +/* Find the ix of a prealloc section capable of holding a block of + size req_sz. If none exists, try to create one first. Returns -1 + on failure. */ + +static Int find_or_create_prealloc_idx ( SizeT req_sz ) +{ + Int ix; + SizeT req_szX; + Bool alloc_ok; + + if (0) + VG_(debugLog)(0, "zz", " find_or_create_prealloc_idx ( %lu )\n", + req_sz); + + aspacem_assert(sizeof(SizeT) == sizeof(Addr)); + aspacem_assert(req_sz > 0); + aspacem_assert(AM_IS_4K_ALIGNED(req_sz)); + + ix = find_prealloc_idx ( req_sz ); + if (ix >= 0 && ix < asegs_pri.used) + return ix; + + /* Not found. We'll have to allocate one. Allocate some extra at + the same time, so as to give a reservoir from which to satisfy + future requests. */ + aspacem_assert(ix == -1); + + req_szX = req_sz + AM_PREALLOC_EXTRA; + aspacem_assert(req_szX > 0); + aspacem_assert(AM_IS_4K_ALIGNED(req_szX)); + + alloc_ok = new_prealloc( req_szX ); + if (!alloc_ok) + return -1; /* failed */ + + /* We should now be able to find it in the segment table. */ + ix = find_prealloc_idx( req_sz ); + aspacem_assert(ix >= 0 && ix < asegs_pri.used); + return ix; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- The core query-notify mechanism. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* Query aspacem to ask where a mapping should go. */ + +Addr VG_(am_get_advisory) ( MapRequest* req, + Bool forClient, + /*OUT*/Bool* ok ) +{ + ML_(am_barf)("unimplemented: VG_(am_get_advisory)"); + /*NOTREACHED*/ + return 0; /* placate gcc -Wall */ +} + + +/* Convenience wrapper for VG_(am_get_advisory) for client floating or + fixed requests. If start is zero, a floating request is issued; if + nonzero, a fixed request at that address is issued. Same comments + about return values apply. */ + +Addr VG_(am_get_advisory_client_simple) ( Addr start, SizeT len, + /*OUT*/Bool* ok ) +{ + ML_(am_barf)("unimplemented: VG_(am_get_advisory_client_simple)"); + /*NOTREACHED*/ + return 0; /* placate gcc -Wall */ +} + + +/* Notifies aspacem that the client completed an mmap successfully. + The segment array is updated accordingly. If the returned Bool is + True, the caller should immediately discard translations from the + specified address range. */ + +Bool +VG_(am_notify_client_mmap)( Addr a, SizeT len, UInt prot, UInt flags, + Int fd, Off64T offset ) +{ + AixSegment seg; + Bool needDiscard; + + if (len == 0) + return False; + + /* Discard is needed if any of the just-trashed range had T. */ + needDiscard = True; /* conservative but safe */ + + init_AixSegment( &seg ); + seg.kind = ASkAnonC; /* XXX bogus: could be a file */ + seg.start = a; + seg.end = a + len - 1; + seg.hasR = toBool(prot & VKI_PROT_READ); + seg.hasW = toBool(prot & VKI_PROT_WRITE); + seg.hasX = toBool(prot & VKI_PROT_EXEC); + + if (0) + VG_(debugLog)(0,"aspacem","notify mmap ( %p, %ld, %ld, %ld )\n", + (void*)a, len, (UWord)prot, (UWord)flags); + + add_asegment( &asegs_pri, &seg ); + AM_SANITY_CHECK("am_notify_client_mmap"); + return needDiscard; +} + + +/* Notifies aspacem that the client completed a shmat successfully. + The segment array is updated accordingly. If the returned Bool is + True, the caller should immediately discard translations from the + specified address range. */ + +Bool +VG_(am_notify_client_shmat)( Addr a, SizeT len, UInt prot ) +{ + AixSegment seg; + init_AixSegment( &seg ); + seg.kind = ASkShmemC; + seg.start = a; + seg.end = seg.start + len - 1; + seg.hasR = (prot & VKI_PROT_READ) ? True : False; + seg.hasW = (prot & VKI_PROT_WRITE) ? True : False; + seg.hasX = (prot & VKI_PROT_EXEC) ? True : False; + add_asegment( &asegs_pri, &seg ); + AM_SANITY_CHECK("am_notify_client_shmat"); + if (0) VG_(am_show_nsegments)(0, "after shmat"); + return True; /* be paranoid */ +} + + +/* Notifies aspacem that an mprotect was completed successfully. The + segment array is updated accordingly. Note, as with + VG_(am_notify_munmap), it is not the job of this function to reject + stupid mprotects, for example the client doing mprotect of + non-client areas. Such requests should be intercepted earlier, by + the syscall wrapper for mprotect. This function merely records + whatever it is told. If the returned Bool is True, the caller + should immediately discard translations from the specified address + range. */ + +Bool VG_(am_notify_mprotect)( Addr start, SizeT len, UInt prot ) +{ + Int i, iLo, iHi; + Bool newR, newW, newX, needDiscard; + + if (len == 0) + return False; + + newR = toBool(prot & VKI_PROT_READ); + newW = toBool(prot & VKI_PROT_WRITE); + newX = toBool(prot & VKI_PROT_EXEC); + + /* Discard is needed if we're dumping X permission */ + needDiscard = True; /* conservative but correct */ + + split_asegments_lo_and_hi( &asegs_pri, start, start+len-1, &iLo, &iHi ); + + iLo = find_asegment_idx(&asegs_pri, start); + iHi = find_asegment_idx(&asegs_pri, start + len - 1); + + for (i = iLo; i <= iHi; i++) { + aspacem_assert(i >= 0 && i < asegs_pri.used); + /* Apply the permissions to all relevant segments. */ + if (asegs_pri.seg[i].kind != ASkFree) { + asegs_pri.seg[i].hasR = newR; + asegs_pri.seg[i].hasW = newW; + asegs_pri.seg[i].hasX = newX; + aspacem_assert(sane_AixSegment(&asegs_pri.seg[i])); + } + } + if (0) + VG_(debugLog)(0,"aspacem","notify mprotect ( %p, %ld, %ld )\n", + (void*)start, len, (UWord)prot); + /* Changing permissions could have made previously un-mergable + segments mergeable. Therefore have to re-preen them. */ + preen_asegments(&asegs_pri); + AM_SANITY_CHECK("am_notify_mprotect"); + return needDiscard; +} + + +/* Notifies aspacem that an munmap completed successfully. The + segment array is updated accordingly. As with + VG_(am_notify_munmap), we merely record the given info, and don't + check it for sensibleness. If the returned Bool is True, the + caller should immediately discard translations from the specified + address range. */ + +Bool VG_(am_notify_munmap)( Addr start, SizeT len ) +{ + Bool needDiscard = True; /* conservative but safe */ + AixSegment seg; + + if (len == 0) + return False; + + init_AixSegment( &seg ); + seg.kind = ASkFree; + seg.start = start; + seg.end = start + len - 1; + add_asegment( &asegs_pri, &seg ); + AM_SANITY_CHECK("am_notify_munmap"); + + return needDiscard; +} + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- Handling mappings which do not arise directly from the ---*/ +/*--- simulation of the client. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* --- --- --- map, unmap, protect --- --- --- */ + +/* Map a file at a fixed address for the client, and update the + segment array accordingly. */ + +SysRes VG_(am_mmap_file_fixed_client) + ( Addr start, SizeT length, UInt prot, Int fd, Off64T offset ) +{ + SysRes r = {0,0}; + ML_(am_barf)("unimplemented: VG_(am_mmap_file_fixed_client)"); + /*NOTREACHED*/ + return r; +} + + +/* Map anonymously at a fixed address for the client, and update + the segment array accordingly. */ + +SysRes VG_(am_mmap_anon_fixed_client) ( Addr start, SizeT length, UInt prot ) +{ + SysRes r = {0,0}; + ML_(am_barf)("unimplemented: VG_(am_mmap_anon_fixed_client)"); + /*NOTREACHED*/ + return r; +} + + +/* Map anonymously at an unconstrained address for the client, and + update the segment array accordingly. */ + +SysRes VG_(am_mmap_anon_float_client) ( SizeT length, Int prot ) +{ + SysRes sres; + AixSegment seg; + + /* Not allowable. */ + if (length == 0) + return VG_(mk_SysRes_Error)( VKI_EINVAL ); + + /* AIX seems to demand fd == -1 in anonymous mappings. hence: */ + sres = VG_(am_do_mmap_NO_NOTIFY)( + 0, length, + prot, + VKI_MAP_PRIVATE|VKI_MAP_ANONYMOUS, + -1, 0 + ); + + if (!sres.isError) { + init_AixSegment( &seg ); + seg.kind = ASkAnonC; + seg.start = sres.res; + seg.end = seg.start + length - 1; + seg.hasR = toBool((prot & VKI_PROT_READ) > 0); + seg.hasW = toBool((prot & VKI_PROT_WRITE) > 0); + seg.hasX = toBool((prot & VKI_PROT_EXEC) > 0); + seg.fromP = False; + add_asegment( &asegs_pri, &seg ); + VG_(debugLog)(2, "aspacem", "new AnonC from mmap, size %lu\n", + length ); + } + + return sres; +} + + +/* Similarly, acquire new address space for the client but with + considerable restrictions on what can be done with it: (1) the + actual protections may exceed those stated in 'prot', (2) the + area's protections cannot be later changed using any form of + mprotect, and (3) the area cannot be freed using any form of + munmap. On Linux this behaves the same as + VG_(am_mmap_anon_float_client). On AIX5 this *may* allocate memory + by using sbrk, so as to make use of large pages on AIX. */ + +SysRes VG_(am_sbrk_anon_float_client) ( SizeT length, Int prot ) +{ + Int ix; + SysRes sres; + AixSegment seg; + SizeT lenX = AM_4K_ROUNDUP(length); + + /* Not allowable. */ + if (length == 0) + return VG_(mk_SysRes_Error)( VKI_EINVAL ); + + /* First see if we can get space from sbrk-world. */ + ix = find_or_create_prealloc_idx ( lenX ); + if (ix >= 0 && ix < asegs_pri.used) { + init_AixSegment( &seg ); + seg.kind = ASkAnonC; + seg.start = asegs_pri.seg[ix].start; + seg.end = seg.start + lenX - 1; + seg.hasR = toBool((prot & VKI_PROT_READ) > 0); + seg.hasW = toBool((prot & VKI_PROT_WRITE) > 0); + seg.hasX = toBool((prot & VKI_PROT_EXEC) > 0); + seg.fromP = True; + add_asegment( &asegs_pri, &seg ); + sres = VG_(mk_SysRes_Success)( seg.start ); + VG_(debugLog)(2, "aspacem", "new AnonC from prealloc, size %lu\n", + length ); + return sres; + } + + /* That didn't work out. Try mmap-world instead. */ + aspacem_assert(ix == -1); + return VG_(am_mmap_anon_float_client)( length, prot ); +} + + +/* Map anonymously at an unconstrained address for V, and update the + segment array accordingly. This is fundamentally how V allocates + itself more address space when needed. */ + +SysRes VG_(am_mmap_anon_float_valgrind)( SizeT length ) +{ + SysRes sres; + AixSegment seg; + + /* Not allowable. */ + if (length == 0) + return VG_(mk_SysRes_Error)( VKI_EINVAL ); + + /* AIX seems to demand fd == -1 in anonymous mappings. hence: */ + sres = VG_(am_do_mmap_NO_NOTIFY)( + 0, length, + VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC, + VKI_MAP_PRIVATE|VKI_MAP_ANONYMOUS, + -1, 0 + ); + + if (!sres.isError) { + init_AixSegment( &seg ); + seg.kind = ASkAnonV; + seg.start = sres.res; + seg.end = seg.start + length - 1; + seg.hasR = seg.hasW = seg.hasX = True; + seg.fromP = False; + add_asegment( &asegs_pri, &seg ); + VG_(debugLog)(2, "aspacem", "new AnonV from mmap, size %lu\n", + length ); + } + + return sres; +} + + +/* Same comments apply as per VG_(am_sbrk_anon_float_client). On + Linux this behaves the same as VG_(am_mmap_anon_float_valgrind). */ +SysRes VG_(am_sbrk_anon_float_valgrind)( SizeT length ) +{ + Int ix; + SysRes sres; + AixSegment seg; + SizeT lenX = AM_4K_ROUNDUP(length); + + /* Not allowable. */ + if (length == 0) + return VG_(mk_SysRes_Error)( VKI_EINVAL ); + + /* First see if we can get space from sbrk-world. */ + ix = find_or_create_prealloc_idx ( lenX ); + if (ix >= 0 && ix < asegs_pri.used) { + init_AixSegment( &seg ); + seg.kind = ASkAnonV; + seg.start = asegs_pri.seg[ix].start; + seg.end = seg.start + lenX - 1; + seg.hasR = True; + seg.hasW = True; + seg.hasX = True; + seg.fromP = True; + add_asegment( &asegs_pri, &seg ); + sres = VG_(mk_SysRes_Success)( seg.start ); + VG_(debugLog)(2, "aspacem", "new AnonV from prealloc, size %lu\n", + length ); + return sres; + } + + /* That didn't work out. Try mmap-world instead. */ + aspacem_assert(ix == -1); + return VG_(am_mmap_anon_float_valgrind)( length ); +} + + +/* Really just a wrapper around VG_(am_sbrk_anon_float_valgrind). */ + +void* VG_(am_shadow_alloc)(SizeT size) +{ + SysRes sres = VG_(am_sbrk_anon_float_valgrind)( size ); + return sres.isError ? NULL : (void*)sres.res; +} + + +/* Map a file at an unconstrained address for V, and update the + segment array accordingly. This is used by V for transiently + mapping in object files to read their debug info. */ + +SysRes VG_(am_mmap_file_float_valgrind) ( SizeT length, UInt prot, + Int fd, Off64T offset ) +{ + SysRes sres; + + /* Not allowable. */ + if (length == 0 || !VG_IS_PAGE_ALIGNED(offset)) + return VG_(mk_SysRes_Error)( VKI_EINVAL ); + + sres = VG_(am_do_mmap_NO_NOTIFY)( + 0, length, + prot, VKI_MAP_PRIVATE, + fd, offset + ); + if (!sres.isError) { + AixSegment seg; + init_AixSegment( &seg ); + seg.kind = SkFileV; + seg.start = sres.res; + seg.end = seg.start + length - 1; + seg.hasR = toBool(prot & VKI_PROT_READ); + seg.hasW = toBool(prot & VKI_PROT_WRITE); + seg.hasX = toBool(prot & VKI_PROT_EXEC); + seg.fname = add_to_strtab("(FileV-float, unknown name)"); + add_asegment( &asegs_pri, &seg ); + aspacem_assert( sane_AixSegments( &asegs_pri )); + } + return sres; +} + + +/* Unmap the given address range and update the segment array + accordingly. This fails if the range isn't valid for the client. + If *need_discard is True after a successful return, the caller + should immediately discard translations from the specified address + range. */ + +SysRes VG_(am_munmap_client)( /*OUT*/Bool* need_discard, + Addr start, SizeT len ) +{ + SysRes r = {0,0}; + ML_(am_barf)("unimplemented: VG_(am_munmap_client)"); + /*NOTREACHED*/ + return r; +} + + +/* Unmap the given address range and update the segment array + accordingly. This fails if the range isn't valid for valgrind. */ +/* Also, if the specified range doesn't fall within a single segment, + it barfs. This simplifies the implementation; we shouldn't need to + deal with anything but the simplest cases. */ + +SysRes VG_(am_munmap_valgrind)( Addr start, SizeT len ) +{ + AixSegment* seg; + AixSegment seg2; + Addr end; + SysRes sres; + Int ixS, ixE; + Bool debug = False; + + if (debug) + VG_(debugLog)(0,"aspacem", + "am_munmap_valgrind(%p, %lu)\n", (void*)start, len); + + if (len == 0) + return VG_(mk_SysRes_Success)(0); + + /* We have to be a bit careful here. If the area being unmapped is + AnonV which originated from a preallocated area (hence from + sbrk-land) then we will have to return it to the preallocated + state, rather than unmapping it. */ + end = start + len - 1; + aspacem_assert(start <= end); // else have wraparound?! + + ixS = find_asegment_idx( &asegs_pri, start ); + ixE = find_asegment_idx( &asegs_pri, end ); + + aspacem_assert(ixS >= 0 && ixS < asegs_pri.used); + aspacem_assert(ixE >= 0 && ixE < asegs_pri.used); + + /* Preconditions: See comment at start of fn */ + aspacem_assert(ixS == ixE); + + /* For the segment S denoted by ixS: + + - if S is AnonV from prealloc and S entirely within start .. end, + return it to prealloc + + - if S is AnonV not from prealloc and S entirely within start .. end, + munmap it + + - if S is FileV and S entirely within start .. end, munmap it + + Otherwise, leave it alone (too complex to handle). In theory + this could cause a leak; in practice I don't think it will. + */ + seg = &asegs_pri.seg[ixS]; + + if (debug) + show_AixSegment( 0, ixS, seg ); + + /* Invariants */ + aspacem_assert(seg->start <= start); + aspacem_assert(end <= seg->end); + + if (seg->kind == ASkFileV + || (seg->kind == ASkAnonV && (!seg->fromP))) { + if (debug) + VG_(debugLog)(0,"aspacem", "am_munmap_valgrind: !fromP: %p-%p\n", + (void*)start, (void*)end); + sres = ML_(am_do_munmap_NO_NOTIFY)( start, len ); + if (sres.isError) + goto bad; + init_AixSegment( &seg2 ); + seg2.start = start; + seg2.end = end; + seg2.kind = ASkFree; + add_asegment( &asegs_pri, &seg2 ); + } + else + if (seg->kind == ASkAnonV && seg->fromP) { + if (debug) + VG_(debugLog)(0,"aspacem", "am_munmap_valgrind: fromP: %p-%p\n", + (void*)start, (void*)end); + init_AixSegment( &seg2 ); + seg2.start = start; + seg2.end = end; + seg2.kind = ASkPreAlloc; + seg2.hasR = seg2.hasW = seg2.hasX = True; + add_asegment( &asegs_pri, &seg2 ); + } + else { + /* shouldn't be asked to handle any other cases */ + aspacem_assert(0); + } + + aspacem_assert( sane_AixSegments( &asegs_pri )); + return VG_(mk_SysRes_Success)(0); + + bad: + aspacem_assert( sane_AixSegments( &asegs_pri )); + return VG_(mk_SysRes_Error)(VKI_EINVAL); +} + + +/* Let (start,len) denote an area within a single Valgrind-owned + segment (anon or file). Change the ownership of [start, start+len) + to the client instead. Fails if (start,len) does not denote a + suitable segment. */ + +Bool VG_(am_change_ownership_v_to_c)( Addr start, SizeT len ) +{ + return True; +} + + +/* 'seg' must be NULL or have been obtained from + VG_(am_find_nsegment), and still valid. If non-NULL, and if it + denotes a SkAnonC (anonymous client mapping) area, set the .isCH + (is-client-heap) flag for that area. Otherwise do nothing. + (Bizarre interface so that the same code works for both Linux and + AIX and does not impose inefficiencies on the Linux version.) */ +/* AIX: presumably this is a faked-up segment our VG_(am_find_segment) + came up with. So we have to find the corresponding AixSegment. */ + +void VG_(am_set_segment_isCH_if_SkAnonC)( NSegment* seg ) +{ + Int i; + if (seg == NULL) + return; + i = find_asegment_idx( &asegs_pri, seg->start ); + aspacem_assert(i >= 0 && i < asegs_pri.used ); + if (asegs_pri.seg[i].kind == ASkAnonC) { + asegs_pri.seg[i].isCH = True; + if (0) + VG_(debugLog)(0,"aspacem","set isCH for %p\n", (void*)seg->start ); + } else { + aspacem_assert(asegs_pri.seg[i].isCH == False); + } +} + + +/* Same idea as VG_(am_set_segment_isCH_if_SkAnonC), except set the + segment's hasT bit (has-cached-code) if this is SkFileC or SkAnonC + segment. */ +/* AIX: we ignore these complexities by conservatively assuming that + all segments had translations taken from them. Hence we can safely + ignore this. */ +void VG_(am_set_segment_hasT_if_SkFileC_or_SkAnonC)( NSegment* seg ) +{ +} + + +/* --- --- --- reservations --- --- --- */ + +/* Create a reservation from START .. START+LENGTH-1, with the given + ShrinkMode. When checking whether the reservation can be created, + also ensure that at least abs(EXTRA) extra free bytes will remain + above (> 0) or below (< 0) the reservation. + + The reservation will only be created if it, plus the extra-zone, + falls entirely within a single free segment. The returned Bool + indicates whether the creation succeeded. */ + +Bool VG_(am_create_reservation) ( Addr start, SizeT length, + ShrinkMode smode, SSizeT extra ) +{ + ML_(am_barf)("unimplemented: VG_(am_create_reservation)"); + /*NOTREACHED*/ + return False; +} + + +/* Let SEG be an anonymous client mapping. This fn extends the + mapping by DELTA bytes, taking the space from a reservation section + which must be adjacent. If DELTA is positive, the segment is + extended forwards in the address space, and the reservation must be + the next one along. If DELTA is negative, the segment is extended + backwards in the address space and the reservation must be the + previous one. DELTA must be page aligned. abs(DELTA) must not + exceed the size of the reservation segment minus one page, that is, + the reservation segment after the operation must be at least one + page long. */ + +Bool VG_(am_extend_into_adjacent_reservation_client) ( NSegment* seg, + SSizeT delta ) +{ + ML_(am_barf)("unimplemented: " + "VG_(am_extend_into_adjacent_reservation_client)"); + /*NOTREACHED*/ + return False; +} + + +/* --- --- --- resizing/move a mapping --- --- --- */ + +/* Let SEG be a client mapping (anonymous or file). This fn extends + the mapping forwards only by DELTA bytes, and trashes whatever was + in the new area. Fails if SEG is not a single client mapping or if + the new area is not accessible to the client. Fails if DELTA is + not page aligned. *seg is invalid after a successful return. If + *need_discard is True after a successful return, the caller should + immediately discard translations from the new area. */ + +Bool VG_(am_extend_map_client)( /*OUT*/Bool* need_discard, + NSegment* seg, SizeT delta ) +{ + ML_(am_barf)("unimplemented: VG_(am_extend_map_client)"); + /*NOTREACHED*/ + return False; +} + + +/* Remap the old address range to the new address range. Fails if any + parameter is not page aligned, if the either size is zero, if any + wraparound is implied, if the old address range does not fall + entirely within a single segment, if the new address range overlaps + with the old one, or if the old address range is not a valid client + mapping. If *need_discard is True after a successful return, the + caller should immediately discard translations from both specified + address ranges. */ + +Bool VG_(am_relocate_nooverlap_client)( /*OUT*/Bool* need_discard, + Addr old_addr, SizeT old_len, + Addr new_addr, SizeT new_len ) +{ + ML_(am_barf)("unimplemented: VG_(am_relocate_nooverlap_client)"); + /*NOTREACHED*/ + return False; +} + + + +/*-----------------------------------------------------------------*/ +/*--- ---*/ +/*--- A simple parser for /proc/<pid>/map on AIX5. ---*/ +/*--- Almost completely independent of the stuff above. The ---*/ +/*--- only function it 'exports' to the code above this comment ---*/ +/*--- is parse_procselfmaps. ---*/ +/*--- ---*/ +/*-----------------------------------------------------------------*/ + +/* --- !!! --- EXTERNAL HEADERS start --- !!! --- */ +#include <sys/procfs.h> +/* --- !!! --- EXTERNAL HEADERS end --- !!! --- */ + + +/* Size of a smallish table used to read /proc/<pid>/map entries. */ +#define M_APROCMAP_BUF 100000 + +/* static ... to keep it out of the stack frame. */ +static HChar procmap_buf[M_APROCMAP_BUF]; + +/* Records length of /proc/<pid>/map read into procmap_buf. */ +static Int buf_n_tot; + +/* Helper fns. */ + +/* Get the contents of /proc/<pid>/map into a static buffer. If + there's a syntax error, it won't fit, or other failure, just + abort. */ + +static void read_procselfmap_into_buf ( void ) +{ + Char fname[50]; + Int n_chunk; + SysRes fd; + + ML_(am_sprintf)( fname, "/proc/%d/map", ML_(am_getpid)() ); + + /* Read the initial memory mapping from the /proc filesystem. */ + fd = ML_(am_open)( fname, VKI_O_RDONLY, 0 ); + if (fd.isError) + ML_(am_barf)("can't open /proc/<pid>/map"); + + buf_n_tot = 0; + do { + n_chunk = ML_(am_read)( fd.res, &procmap_buf[buf_n_tot], + M_APROCMAP_BUF - buf_n_tot ); + buf_n_tot += n_chunk; + } while ( n_chunk > 0 && buf_n_tot < M_APROCMAP_BUF ); + + ML_(am_close)(fd.res); + + if (buf_n_tot >= M_APROCMAP_BUF-5) + ML_(am_barf_toolow)("M_APROCMAP_BUF"); + if (buf_n_tot == 0) + ML_(am_barf)("I/O error on /proc/<pid>/map"); + + procmap_buf[buf_n_tot] = 0; +} + + +/* /proc/<pid>/map appears to give out a non-absolute path name for + the main executable. Fortunately we can reliably identify the main + executable via the MA_MAINEXEC bit, and if we find the path is + non-absolute, replace it with /proc/<pid>/object/a.out instead. + AIX guarantees the latter is another name for the main + executable. */ + +static HChar* kludge_exe_file_name ( HChar* file_name, prmap_t* map ) +{ + static Int my_pid = -1; + static HChar a_out_name[64]; + if (file_name == NULL) + return NULL; + if (file_name[0] != '/' && (map->pr_mflags & MA_MAINEXEC)) { + if (my_pid == -1) + my_pid = ML_(am_getpid)(); + ML_(am_sprintf)(a_out_name, "/proc/%d/object/a.out", my_pid); + file_name = a_out_name; + } + return file_name; +} + + + +/* Parse /proc/<pid>/map, copying the entries in it into an + AixSegments structure. Returns a properly formed AixSegments, with + ASkMText/ASkMData entries, with sibling pointers set up, and + ASkFree everywhere else. +*/ +static void parse_procselfmap ( /*OUT*/AixSegments* segs ) +{ + UChar rr, ww, xx, mm, ss; + prmap_t* map; + UChar* file_name; + UChar* member_name; + Bool show_map; + Int off, i, j; + AixSegment s; + + const UInt valid_pr_mflags + = MA_MAINEXEC | MA_KERNTEXT | MA_READ | MA_WRITE + | MA_EXEC | MA_SHARED | MA_BREAK | MA_STACK; + + segs->used = 1; + init_AixSegments(segs); + aspacem_assert( sane_AixSegments(segs) ); + + read_procselfmap_into_buf(); + + if (0) + VG_(debugLog)(0, "procselfmaps", "got %d bytes\n", buf_n_tot); + + off = 0; + while (True) { + + /* stay sane .. */ + if (off + sizeof(prmap_t) > buf_n_tot) + break; + + map = (prmap_t*)&procmap_buf[off]; + off += sizeof(prmap_t); + + /* When should we stop reading the array? + /usr/include/sys/procfs.h says that "Array entries continue + until an entry with a pr_size field of 0 and invalid + pr_mflags occurs." It unhelpfully fails to define what + "invalid" means here. However, the following test _seems_ to + work. */ + if (map->pr_size == 0 + && (map->pr_mflags & valid_pr_mflags) == 0) + break; + + /* Ok, keep going, but ignore any zero-sized mappings: */ + if (map->pr_size == 0) + continue; + + mm = (map->pr_mflags & MA_MAINEXEC) > 0; + rr = (map->pr_mflags & MA_READ) > 0; + ww = (map->pr_mflags & MA_WRITE) > 0; + xx = (map->pr_mflags & MA_EXEC) > 0; + ss = (map->pr_mflags & MA_SHARED) > 0; + + if (map->pr_pathoff > 0) { + file_name = &procmap_buf[map->pr_pathoff]; + member_name = file_name + VG_(strlen)(file_name) + 1; + if (*member_name == 0) + member_name = NULL; + } else { + file_name = member_name = NULL; + } + file_name = kludge_exe_file_name( file_name, map ); + + /* Now file_name and member_name are NULL or ordinary strings. + Convert them to string-table resident strings. */ + if (file_name) + file_name = add_to_strtab(file_name); + if (member_name) + member_name = add_to_strtab(member_name); + + /* Create a suitable kind of segment. Initially we will start + with bogus sibling pointers, and allow ASkMData entries to + have file names, since we cannot assume anything about the + ordering of entries in the procmap file. In a second pass, + we will set up the sibling pointers based on those file + names, then remove the MData file names. */ + init_AixSegment(&s); + show_map = False; + if (rr && (!ww) && xx) { + if (map->pr_size > 0) { + /* r-x segment; add bounds for a text area. */ + s.kind = ASkMText; + s.start = (Addr)map->pr_vaddr; + s.end = (Addr)map->pr_vaddr + (Addr)map->pr_size - 1; + s.isMainExe = mm; + s.sibling = 0; + s.fname = file_name; + s.mname = member_name; + s.hasR = rr; + s.hasW = ww; + s.hasX = xx; + add_asegment(segs, &s); + } + } + else + if (rr && ww && (!xx)) { + if (map->pr_size > 0) { + /* rw- segment; add bounds for a data area. */ + s.kind = ASkMData; + s.start = (Addr)map->pr_vaddr; + s.end = (Addr)map->pr_vaddr + (Addr)map->pr_size - 1; + /* Set a bogus non-zero sibling pointer, since sanity + checking will reject zero sibling pointers on MData. + It doesn't matter since the loops following this one + below fix up the sibling pointers. */ + s.sibling = 1; + s.fname = file_name; + s.mname = member_name; + s.hasR = rr; + s.hasW = ww; + s.hasX = xx; + add_asegment(segs, &s); + } + } + else { + /* unclassifiable; we better complain. */ + show_map = True; + VG_(debugLog)(0, "aspacem", "parse_procselfmap: unclassifiable:\n"); + } + + if (show_map) + VG_(debugLog)(1,"aspacem", + " %010llx-%010llx %c%c%c%c%c %s%s%s%s\n", + (ULong)map->pr_vaddr, + (ULong)map->pr_vaddr + (ULong)map->pr_size, + mm ? 'M' : '-', + rr ? 'r' : '-', + ww ? 'w' : '-', + xx ? 'x' : '-', + ss ? 'S' : '-', + file_name ? file_name : (UChar*)"(none)", + member_name ? "(" : "", + member_name ? member_name : (UChar*)"", + member_name ? ")" : "" + ); + + } + + /* Set up sibling pointers. For each MData, find an MText with the + same file/member names, or complain. This is really ugly in + that it makes the process quadratic in the number of modules + mapped in, but I can't think of a (simple) better way. */ + + for (i = 0; i < segs->used; i++) { + if (segs->seg[i].kind != ASkMData) + continue; + for (j = 0; j < segs->used; j++) { + if (segs->seg[j].kind == ASkMText + && segs->seg[j].fname == segs->seg[i].fname + && segs->seg[j].mname == segs->seg[i].mname) + break; + } + if (j == segs->used) { + VG_(debugLog)(0, "aspacem", "parse_procselfmap: " + "data segment with no associated text segment:\n"); + VG_(debugLog)(0, "aspacem", "module = %s(%s)\n", + segs->seg[i].fname, + segs->seg[i].mname ? segs->seg[i].mname + : (UChar*)"(none)"); + aspacem_assert(0); + } + aspacem_assert(j >= 0 && j < segs->used && j != i); + segs->seg[i].sibling = segs->seg[j].start; + } + + /* (Almost) dually, for each MText, find an MData with same + file/member names, but don't complain if not present. */ + + for (i = 0; i < segs->used; i++) { + if (segs->seg[i].kind != ASkMText) + continue; + for (j = 0; j < segs->used; j++) { + if (segs->seg[j].kind == ASkMData + && segs->seg[j].fname == segs->seg[i].fname + && segs->seg[j].mname == segs->seg[i].mname) + break; + } + if (j == segs->used) { + /* no corresponding MData found; harmless. */ + } else { + aspacem_assert(j >= 0 && j < segs->used && j != i); + segs->seg[i].sibling = segs->seg[j].start; + } + } + + /* Finally, get rid of fname/mname pointers on MDatas, so as to + adhere to the necessary representational invariants. */ + for (i = 0; i < segs->used; i++) { + if (segs->seg[i].kind == ASkMData){ + segs->seg[i].fname = segs->seg[i].mname = NULL; + } + } + + aspacem_assert( sane_AixSegments(segs) ); + if (0) + show_AixSegments(0, "as read from procmap", segs); +} + + +/*--------------------------------------------------------------------*/ +/*--- end ---*/ +/*--------------------------------------------------------------------*/ |