1 2 /*--------------------------------------------------------------------*/ 3 /*--- The address space manager. pub_core_aspacemgr.h ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2017 Julian Seward 11 jseward@acm.org 12 13 This program is free software; you can redistribute it and/or 14 modify it under the terms of the GNU General Public License as 15 published by the Free Software Foundation; either version 2 of the 16 License, or (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, but 19 WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 26 02111-1307, USA. 27 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 #ifndef __PUB_CORE_ASPACEMGR_H 32 #define __PUB_CORE_ASPACEMGR_H 33 34 //-------------------------------------------------------------------- 35 // PURPOSE: This module deals with management of the entire process 36 // address space. Almost everything depends upon it, including dynamic 37 // memory management. Hence this module is almost completely 38 // standalone; the only module it uses is m_debuglog. DO NOT CHANGE 39 // THIS. 40 //-------------------------------------------------------------------- 41 42 #include "pub_tool_aspacemgr.h" 43 44 //-------------------------------------------------------------- 45 // Definition of address-space segments 46 47 /* types SegKind, ShrinkMode and NSegment are described in 48 the tool-visible header file, not here. */ 49 50 51 //-------------------------------------------------------------- 52 // Initialisation 53 54 /* Initialise the address space manager, setting up the initial 55 segment list, and reading /proc/self/maps into it. This must 56 be called before any other function. 57 58 Takes a pointer to the SP at the time V gained control. This is 59 taken to be the highest usable address (more or less). Based on 60 that (and general consultation of tea leaves, etc) return a 61 suggested end address (highest addressable byte) for the client's stack. */ 62 extern Addr VG_(am_startup) ( Addr sp_at_startup ); 63 64 /* Check whether ADDR is OK to be used as aspacem_minAddr. If not, *ERRMSG 65 will be set to identify what's wrong. ERRMSG may be NULL. */ 66 extern Bool VG_(am_is_valid_for_aspacem_minAddr)( Addr addr, 67 const HChar **errmsg ); 68 69 //-------------------------------------------------------------- 70 // Querying current status 71 72 73 /* Finds an anonymous segment containing 'a'. Returned pointer is read only. */ 74 extern NSegment const *VG_(am_find_anon_segment) ( Addr a ); 75 76 /* Find the next segment along from 'here', if it is a file/anon/resvn 77 segment. */ 78 extern NSegment const* VG_(am_next_nsegment) ( const NSegment* here, 79 Bool fwds ); 80 81 /* Is the area [start .. start+len-1] validly accessible by 82 valgrind with at least the permissions 'prot' ? To find out 83 simply if said area merely belongs to valgrind, pass 84 VKI_PROT_NONE as 'prot'. Will return False if any part of the 85 area does not belong to valgrind or does not have at least 86 the stated permissions. */ 87 extern Bool VG_(am_is_valid_for_valgrind) 88 ( Addr start, SizeT len, UInt prot ); 89 90 /* Variant of VG_(am_is_valid_for_client) which allows free areas to 91 be consider part of the client's addressable space. It also 92 considers reservations to be allowable, since from the client's 93 point of view they don't exist. */ 94 extern Bool VG_(am_is_valid_for_client_or_free_or_resvn) 95 ( Addr start, SizeT len, UInt prot ); 96 97 /* Checks if a piece of memory consists of either free or reservation 98 segments. */ 99 extern Bool VG_(am_is_free_or_resvn)( Addr start, SizeT len ); 100 101 /* Check whether ADDR looks like an address or address-to-be located in an 102 extensible client stack segment. */ 103 extern Bool VG_(am_addr_is_in_extensible_client_stack)( Addr addr ); 104 105 /* Trivial fn: return the total amount of space in anonymous mappings, 106 both for V and the client. Is used for printing stats in 107 out-of-memory messages. */ 108 extern ULong VG_(am_get_anonsize_total)( void ); 109 110 /* Show the segment array on the debug log, at given loglevel. */ 111 extern void VG_(am_show_nsegments) ( Int logLevel, const HChar* who ); 112 113 /* VG_(am_get_segment_starts) is also part of this section, but its 114 prototype is tool-visible, hence not in this header file. */ 115 116 /* Sanity check: check that Valgrind and the kernel agree on the 117 address space layout. Prints offending segments and call point if 118 a discrepancy is detected, but does not abort the system. Returned 119 Bool is False if a discrepancy was found. */ 120 121 extern Bool VG_(am_do_sync_check) ( const HChar* fn, 122 const HChar* file, Int line ); 123 124 //-------------------------------------------------------------- 125 // Functions pertaining to the central query-notify mechanism 126 // used to handle mmap/munmap/mprotect resulting from client 127 // syscalls. 128 129 /* Describes a request for VG_(am_get_advisory). */ 130 typedef 131 struct { 132 /* Note: if rkind == MAlign then start specifies alignment. This is 133 Solaris specific. */ 134 enum { MFixed, MHint, MAny, MAlign } rkind; 135 Addr start; 136 Addr len; 137 } 138 MapRequest; 139 140 /* Query aspacem to ask where a mapping should go. On success, the 141 advised placement is returned, and *ok is set to True. On failure, 142 zero is returned and *ok is set to False. Note that *ok must be 143 consulted by the caller to establish success or failure; that 144 cannot be established reliably from the returned value. If *ok is 145 set to False, it means aspacem has vetoed the mapping, and so the 146 caller should not proceed with it. */ 147 extern Addr VG_(am_get_advisory) 148 ( const MapRequest* req, Bool forClient, /*OUT*/Bool* ok ); 149 150 /* Convenience wrapper for VG_(am_get_advisory) for client floating or 151 fixed requests. If start is zero, a floating request is issued; if 152 nonzero, a fixed request at that address is issued. Same comments 153 about return values apply. */ 154 extern Addr VG_(am_get_advisory_client_simple) 155 ( Addr start, SizeT len, /*OUT*/Bool* ok ); 156 157 /* Returns True if [start, start + len - 1] is covered by a single 158 free segment, otherwise returns False. 159 This allows to check the following case: 160 VG_(am_get_advisory_client_simple) (first arg == 0, meaning 161 this-or-nothing) is too lenient, and may allow us to trash 162 the next segment along. So make very sure that the proposed 163 new area really is free. This is perhaps overly 164 conservative, but it fixes #129866. */ 165 extern Bool VG_(am_covered_by_single_free_segment) 166 ( Addr start, SizeT len); 167 168 /* Notifies aspacem that the client completed an mmap successfully. 169 The segment array is updated accordingly. If the returned Bool is 170 True, the caller should immediately discard translations from the 171 specified address range. */ 172 extern Bool VG_(am_notify_client_mmap) 173 ( Addr a, SizeT len, UInt prot, UInt flags, Int fd, Off64T offset ); 174 175 /* Notifies aspacem that the client completed a shmat successfully. 176 The segment array is updated accordingly. If the returned Bool is 177 True, the caller should immediately discard translations from the 178 specified address range. */ 179 extern Bool VG_(am_notify_client_shmat)( Addr a, SizeT len, UInt prot ); 180 181 /* Notifies aspacem that an mprotect was completed successfully. The 182 segment array is updated accordingly. Note, as with 183 VG_(am_notify_munmap), it is not the job of this function to reject 184 stupid mprotects, for example the client doing mprotect of 185 non-client areas. Such requests should be intercepted earlier, by 186 the syscall wrapper for mprotect. This function merely records 187 whatever it is told. If the returned Bool is True, the caller 188 should immediately discard translations from the specified address 189 range. */ 190 extern Bool VG_(am_notify_mprotect)( Addr start, SizeT len, UInt prot ); 191 192 /* Notifies aspacem that an munmap completed successfully. The 193 segment array is updated accordingly. As with 194 VG_(am_notify_mprotect), we merely record the given info, and don't 195 check it for sensibleness. If the returned Bool is True, the 196 caller should immediately discard translations from the specified 197 address range. */ 198 extern Bool VG_(am_notify_munmap)( Addr start, SizeT len ); 199 200 /* Hand a raw mmap to the kernel, without aspacem updating the segment 201 array. THIS FUNCTION IS DANGEROUS -- it will cause aspacem's view 202 of the address space to diverge from that of the kernel. DO NOT 203 USE IT UNLESS YOU UNDERSTAND the request-notify model used by 204 aspacem. In short, DO NOT USE THIS FUNCTION. */ 205 extern SysRes VG_(am_do_mmap_NO_NOTIFY) 206 ( Addr start, SizeT length, UInt prot, UInt flags, Int fd, Off64T offset); 207 208 209 //-------------------------------------------------------------- 210 // Dealing with mappings which do not arise directly from the 211 // simulation of the client. These are typically used for 212 // loading the client and building its stack/data segment, before 213 // execution begins. Also for V's own administrative use. 214 215 /* --- --- --- map, unmap, protect --- --- --- */ 216 217 /* Map a file at a fixed address for the client, and update the 218 segment array accordingly. */ 219 extern SysRes VG_(am_mmap_file_fixed_client) 220 ( Addr start, SizeT length, UInt prot, Int fd, Off64T offset ); 221 extern SysRes VG_(am_mmap_file_fixed_client_flags) 222 ( Addr start, SizeT length, UInt prot, UInt flags, Int fd, Off64T offset ); 223 extern SysRes VG_(am_mmap_named_file_fixed_client) 224 ( Addr start, SizeT length, UInt prot, Int fd, 225 Off64T offset, const HChar *name ); 226 extern SysRes VG_(am_mmap_named_file_fixed_client_flags) 227 ( Addr start, SizeT length, UInt prot, UInt flags, Int fd, 228 Off64T offset, const HChar *name ); 229 230 /* Map anonymously at a fixed address for the client, and update 231 the segment array accordingly. */ 232 extern SysRes VG_(am_mmap_anon_fixed_client) 233 ( Addr start, SizeT length, UInt prot ); 234 235 236 /* Map anonymously at an unconstrained address for the client, and 237 update the segment array accordingly. */ 238 extern SysRes VG_(am_mmap_anon_float_client) ( SizeT length, Int prot ); 239 240 /* Map anonymously at an unconstrained address for V, and update the 241 segment array accordingly. This is fundamentally how V allocates 242 itself more address space when needed. */ 243 extern SysRes VG_(am_mmap_anon_float_valgrind)( SizeT cszB ); 244 245 /* Map privately a file at an unconstrained address for V, and update the 246 segment array accordingly. This is used by V for transiently 247 mapping in object files to read their debug info. */ 248 extern SysRes VG_(am_mmap_file_float_valgrind) 249 ( SizeT length, UInt prot, Int fd, Off64T offset ); 250 251 /* Map shared a file at an unconstrained address for V, and update the 252 segment array accordingly. This is used by V for communicating 253 with vgdb. */ 254 extern SysRes VG_(am_shared_mmap_file_float_valgrind) 255 ( SizeT length, UInt prot, Int fd, Off64T offset ); 256 257 /* Similar to VG_(am_mmap_anon_float_client) but also 258 marks the segment as containing the client heap. */ 259 extern SysRes VG_(am_mmap_client_heap) ( SizeT length, Int prot ); 260 261 /* Unmap the given address range and update the segment array 262 accordingly. This fails if the range isn't valid for the client. 263 If *need_discard is True after a successful return, the caller 264 should immediately discard translations from the specified address 265 range. */ 266 extern SysRes VG_(am_munmap_client)( /*OUT*/Bool* need_discard, 267 Addr start, SizeT length ); 268 269 /* Let (start,len) denote an area within a single Valgrind-owned 270 segment (anon or file). Change the ownership of [start, start+len) 271 to the client instead. Fails if (start,len) does not denote a 272 suitable segment. */ 273 extern Bool VG_(am_change_ownership_v_to_c)( Addr start, SizeT len ); 274 275 /* Set the 'hasT' bit on the segment containing ADDR indicating that 276 translations have or may have been taken from this segment. ADDR is 277 expected to belong to a client segment. */ 278 extern void VG_(am_set_segment_hasT)( Addr addr ); 279 280 /* --- --- --- reservations --- --- --- */ 281 282 /* Create a reservation from START .. START+LENGTH-1, with the given 283 ShrinkMode. When checking whether the reservation can be created, 284 also ensure that at least abs(EXTRA) extra free bytes will remain 285 above (> 0) or below (< 0) the reservation. 286 287 The reservation will only be created if it, plus the extra-zone, 288 falls entirely within a single free segment. The returned Bool 289 indicates whether the creation succeeded. */ 290 extern Bool VG_(am_create_reservation) 291 ( Addr start, SizeT length, ShrinkMode smode, SSizeT extra ); 292 293 /* ADDR is the start address of an anonymous client mapping. This fn extends 294 the mapping by DELTA bytes, taking the space from a reservation section 295 which must be adjacent. If DELTA is positive, the segment is 296 extended forwards in the address space, and the reservation must be 297 the next one along. If DELTA is negative, the segment is extended 298 backwards in the address space and the reservation must be the 299 previous one. DELTA must be page aligned. abs(DELTA) must not 300 exceed the size of the reservation segment minus one page, that is, 301 the reservation segment after the operation must be at least one 302 page long. The function returns a pointer to the resized segment. */ 303 extern const NSegment *VG_(am_extend_into_adjacent_reservation_client) 304 ( Addr addr, SSizeT delta, /*OUT*/Bool *overflow ); 305 306 /* --- --- --- resizing/move a mapping --- --- --- */ 307 308 /* This function grows a client mapping in place into an adjacent free segment. 309 ADDR is the client mapping's start address and DELTA, which must be page 310 aligned, is the growth amount. The function returns a pointer to the 311 resized segment. The function is used in support of mremap. */ 312 extern const NSegment *VG_(am_extend_map_client)( Addr addr, SizeT delta ); 313 314 /* Remap the old address range to the new address range. Fails if any 315 parameter is not page aligned, if the either size is zero, if any 316 wraparound is implied, if the old address range does not fall 317 entirely within a single segment, if the new address range overlaps 318 with the old one, or if the old address range is not a valid client 319 mapping. If *need_discard is True after a successful return, the 320 caller should immediately discard translations from both specified 321 address ranges. */ 322 extern Bool VG_(am_relocate_nooverlap_client)( /*OUT*/Bool* need_discard, 323 Addr old_addr, SizeT old_len, 324 Addr new_addr, SizeT new_len ); 325 326 //-------------------------------------------------------------- 327 // Valgrind (non-client) thread stacks. V itself runs on such 328 // stacks. The address space manager provides and suitably 329 // protects such stacks. 330 331 // VG_DEFAULT_STACK_ACTIVE_SZB is the default size of a Valgrind stack. 332 // The effectively used size is controlled by the command line options 333 // --valgrind-stack-size=xxxx (which must be page aligned). 334 // Note that m_main.c needs an interim stack (just to startup), before 335 // any command line option can be processed. This interim stack 336 // (declared in m_main.c) will use the size VG_DEFAULT_STACK_ACTIVE_SZB. 337 #if defined(VGP_ppc32_linux) \ 338 || defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) \ 339 || defined(VGP_mips32_linux) || defined(VGP_mips64_linux) \ 340 || defined(VGP_arm64_linux) 341 # define VG_STACK_GUARD_SZB 65536 // 1 or 16 pages 342 #else 343 # define VG_STACK_GUARD_SZB 8192 // 2 pages 344 #endif 345 # define VG_DEFAULT_STACK_ACTIVE_SZB 1048576 // (4096 * 256) = 1Mb 346 347 typedef struct _VgStack VgStack; 348 349 350 /* Allocate and initialise a VgStack (anonymous valgrind space). 351 Protect the stack active area and the guard areas appropriately. 352 Returns NULL on failure, else the address of the bottom of the 353 stack. On success, also sets *initial_sp to what the stack pointer 354 should be set to. */ 355 356 extern VgStack* VG_(am_alloc_VgStack)( /*OUT*/Addr* initial_sp ); 357 358 /* Figure out how many bytes of the stack's active area have not been 359 used. Used for estimating if we are close to overflowing it. If 360 the free area is larger than 'limit', just return 'limit'. */ 361 extern SizeT VG_(am_get_VgStack_unused_szB)( const VgStack* stack, 362 SizeT limit ); 363 364 // DDD: this is ugly 365 #if defined(VGO_darwin) 366 typedef 367 struct { 368 Bool is_added; // Added or removed seg? 369 Addr start; 370 SizeT end; 371 UInt prot; // Not used for removed segs. 372 Off64T offset; // Not used for removed segs. 373 } 374 ChangedSeg; 375 376 extern Bool VG_(get_changed_segments)( 377 const HChar* when, const HChar* where, /*OUT*/ChangedSeg* css, 378 Int css_size, /*OUT*/Int* css_used); 379 #endif 380 381 #if defined(VGO_solaris) 382 extern Bool VG_(am_search_for_new_segment)(Addr *start, SizeT *size, 383 UInt *prot); 384 #endif 385 386 #endif // __PUB_CORE_ASPACEMGR_H 387 388 /*--------------------------------------------------------------------*/ 389 /*--- end ---*/ 390 /*--------------------------------------------------------------------*/ 391