1 /* 2 * Copyright 2015 Simon South, ssouth@simonsouth.com 3 * All rights reserved. Distributed under the terms of the MIT License. 4 */ 5 6 7 /*! 8 * \file brk.c 9 * 10 * This module provides \c brk and \c sbrk, functions that adjust the program 11 * break of their calling process. 12 * 13 * A process' program break is the first memory location past the end of its 14 * data segment. Moving the program break has the effect of increasing or 15 * decreasing the amount of memory allocated to the process for its data and 16 * can be used to achieve a simple form of memory management. 17 * 18 * An ELF executable may contain multiple writable segments that make up a 19 * program's data segment, each of which may be placed by Haiku's \c 20 * runtime_loader in either one or two areas in memory. Additionally, nothing 21 * stops a program from adding onto its data segment directly using \c 22 * create_area. For these reasons this implementation avoids making 23 * assumptions about the process' data segment except that it is contiguous. 24 * \c brk and \c sbrk will function correctly regardless of the number of 25 * (adjacent) areas used to hold the process' data. 26 * 27 * Note this implementation never creates new areas; its operation is limited 28 * to expanding, contracting or deleting areas as necessary. 29 */ 30 31 32 #include <errno.h> 33 #include <stdint.h> 34 #include <sys/resource.h> 35 #include <unistd.h> 36 37 #include <image.h> 38 #include <OS.h> 39 40 #include <errno_private.h> 41 42 43 /*! 44 * Locates and returns information about the base (lowest in memory) area of 45 * the contiguous set of areas that hold the calling process' data segment. 46 * 47 * \param base_area_info A pointer to an \c area_info structure to receive 48 * information about the area. 49 * \return \c B_OK on success; \c B_BAD_VALUE otherwise. 50 */ 51 static status_t 52 get_data_segment_base_area_info(area_info *base_area_info) 53 { 54 status_t result = B_ERROR; 55 bool app_image_found = false; 56 57 image_info i_info; 58 int32 image_cookie = 0; 59 60 /* Locate our app image and output information for the area that holds the 61 * start of its data segment */ 62 while (!app_image_found 63 && get_next_image_info(0, &image_cookie, &i_info) == B_OK) { 64 if (i_info.type == B_APP_IMAGE) { 65 app_image_found = true; 66 67 result = get_area_info(area_for(i_info.data), base_area_info); 68 } 69 } 70 71 return result; 72 } 73 74 75 /*! 76 * Checks whether a proposed new program break would be valid given the 77 * resource limits imposed on the calling process. 78 * 79 * \param program_break The proposed new program break. 80 * \param base_address The base (start) address of the process' data segment. 81 * \return \c true if the program break would be valid given this process' 82 * resource limits; \c false otherwise. 83 */ 84 static bool 85 program_break_within_resource_limits(void *program_break, void *base_address) 86 { 87 bool result = false; 88 89 struct rlimit rlim; 90 91 if (getrlimit(RLIMIT_AS, &rlim) == 0 92 && (rlim.rlim_cur == RLIM_INFINITY 93 || program_break < (void *)rlim.rlim_cur) 94 && getrlimit(RLIMIT_DATA, &rlim) == 0 95 && (rlim.rlim_cur == RLIM_INFINITY 96 || ((rlim_t)((uint8_t *)program_break - (uint8_t *)(base_address)) 97 < rlim.rlim_cur))) 98 result = true; 99 100 return result; 101 } 102 103 104 /*! 105 * Resizes an area, up or down as necessary, so it ends at the specified 106 * address (rounded up to the nearest page boundary). 107 * 108 * \param a_info An \c area_info structure corresponding to the area on which 109 * to operate. 110 * \param address The new address at which the area should end. This address 111 * will be rounded up to the nearest page boundary. 112 * \return \c B_OK on success; \c B_BAD_VALUE, \c B_NO_MEMORY or \c B_ERROR 113 * otherwise (refer to the documentation for \c resize_area). 114 */ 115 static status_t 116 resize_area_to_address(area_info *a_info, void *address) 117 { 118 size_t new_size = (uint8_t *)address - (uint8_t *)(a_info->address); 119 size_t new_size_aligned = (new_size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1); 120 121 return resize_area(a_info->area, new_size_aligned); 122 } 123 124 125 /*! 126 * An internal method that sets the program break of the calling process to the 127 * specified address. 128 * 129 * \param addr The requested new program break. This address will be rounded up 130 * as necessary to align the program break on a page boundary. 131 * \param base_area_info An \c area_info structure corresponding to the base 132 * (lowest in memory) area of the contiguous set of areas 133 * that hold the calling process' data segment. 134 * \return 0 on success; -1 otherwise. 135 */ 136 static int 137 brk_internal(void *addr, area_info *base_area_info) 138 { 139 int result = 0; 140 141 void *next_area_address; 142 area_id next_area; 143 area_info next_area_info; 144 145 /* First, recursively process the next (higher) adjacent area, if any */ 146 next_area_address = (uint8_t *)base_area_info->address 147 + base_area_info->size; 148 next_area = area_for(next_area_address); 149 if (next_area != B_ERROR) { 150 result = get_area_info(next_area, &next_area_info) == B_OK ? 151 brk_internal(addr, &next_area_info) : -1; 152 } else { 153 /* This is the highest ("last") area in the data segment, so any 154 * increase in size needs to occur on this area */ 155 if (addr > next_area_address) { 156 result = resize_area_to_address(base_area_info, addr) == B_OK ? 0 157 : -1; 158 } 159 } 160 161 if (result == 0) { 162 if (addr <= base_area_info->address) { 163 /* This area starts at or above the program break the caller has 164 * requested, so the entire area can be deleted */ 165 result = delete_area(base_area_info->area) == B_OK ? 0 : -1; 166 } else if (addr < next_area_address) { 167 /* The requested program break lies within this area, so this area 168 * must be contracted */ 169 result = resize_area_to_address(base_area_info, addr) == B_OK ? 0 170 : -1; 171 } 172 } 173 174 return result; 175 } 176 177 178 /*! 179 * Sets the calling process' program break to the specified address, if valid 180 * and within the limits of available resources, expanding or contracting the 181 * process' data segment as necessary. 182 * 183 * \param addr The requested new program break. 184 * \return 0 on success; -1 on error (in which case \c errno will be set to 185 * \c ENOMEM). 186 */ 187 int 188 brk(void *addr) 189 { 190 int result = -1; 191 192 area_info base_area_info; 193 194 if (get_data_segment_base_area_info(&base_area_info) == B_OK 195 && addr > base_area_info.address 196 && program_break_within_resource_limits(addr, base_area_info.address)) 197 result = brk_internal(addr, &base_area_info); 198 199 if (result == -1) 200 __set_errno(ENOMEM); 201 202 return result; 203 } 204 205 206 /*! 207 * Adjusts the calling process' program break up or down by the requested 208 * number of bytes, if valid and within the limits of available resources, 209 * expanding or contracting the process' data segment as necessary. 210 * 211 * \param increment The amount, positive or negative, in bytes by which to 212 * adjust the program break. This value will be rounded up as 213 * necessary to align the program break on a page boundary. 214 * \return The previous program break on success; (void *)-1 on error (in which 215 * case \c errno will be set to \c ENOMEM). 216 */ 217 void * 218 sbrk(intptr_t increment) 219 { 220 void *result = NULL; 221 222 area_info base_area_info; 223 224 area_id next_area; 225 area_info next_area_info; 226 227 uint8_t *program_break; 228 uint8_t *new_program_break; 229 230 if (get_data_segment_base_area_info(&base_area_info) == B_OK) { 231 /* Find the current program break, which will be the memory address 232 * just past the end of the highest ("last") of the areas that hold the 233 * data segment */ 234 next_area = base_area_info.area; 235 do { 236 if (get_area_info(next_area, &next_area_info) == B_OK) { 237 next_area = area_for((uint8_t *)(next_area_info.address) 238 + next_area_info.size); 239 } else { 240 result = (void *)-1; 241 } 242 } while (next_area != B_ERROR && result == NULL); 243 244 if (result == NULL) { 245 program_break = (uint8_t *)(next_area_info.address) 246 + next_area_info.size; 247 new_program_break = program_break + increment; 248 249 /* If the requested increment is zero, just return the address of 250 * the current program break; otherwise, set a new program break 251 * and return the address of the old one */ 252 if (increment == 0 253 || (program_break_within_resource_limits(new_program_break, 254 base_area_info.address) 255 && brk_internal(new_program_break, &base_area_info) == 0)) 256 result = program_break; 257 else 258 result = (void *)-1; 259 } 260 } else { 261 result = (void *)-1; 262 } 263 264 if (result == (void *)-1) 265 __set_errno(ENOMEM); 266 267 return result; 268 } 269