1/* This testcase is part of GDB, the GNU debugger. 2 3 Copyright 2004, 2007 Free Software Foundation, Inc. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program. If not, see <http://www.gnu.org/licenses/>. 17 18 Please email any bugs, comments, and/or additions to this file to: 19 bug-gdb@prep.ai.mit.edu */ 20 21/* Get 64-bit stuff if on a GNU system. */ 22#define _GNU_SOURCE 23 24#include <sys/types.h> 25#include <sys/time.h> 26#include <sys/resource.h> 27#include <sys/stat.h> 28#include <fcntl.h> 29 30#include <stdlib.h> 31#include <unistd.h> 32 33/* This test was written for >2GB core files on 32-bit systems. On 34 current 64-bit systems, generating a >4EB (2 ** 63) core file is 35 not practical, and getting as close as we can takes a lot of 36 useless CPU time. So limit ourselves to a bit bigger than 37 32-bit, which is still a useful test. */ 38#define RLIMIT_CAP (1ULL << 34) 39 40/* Print routines: 41 42 The following are so that printf et.al. can be avoided. Those 43 might try to use malloc() and that, for this code, would be a 44 disaster. */ 45 46#define printf do not use 47 48const char digit[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 49 50static void 51print_char (char c) 52{ 53 write (1, &c, sizeof (c)); 54} 55 56static void 57print_unsigned (unsigned long long u) 58{ 59 if (u >= 10) 60 print_unsigned (u / 10); 61 print_char (digit[u % 10]); 62} 63 64static void 65print_hex (unsigned long long u) 66{ 67 if (u >= 16) 68 print_hex (u / 16); 69 print_char (digit[u % 16]); 70} 71 72static void 73print_string (const char *s) 74{ 75 for (; (*s) != '\0'; s++) 76 print_char ((*s)); 77} 78 79static void 80print_address (const void *a) 81{ 82 print_string ("0x"); 83 print_hex ((unsigned long) a); 84} 85 86static void 87print_byte_count (unsigned long long u) 88{ 89 print_unsigned (u); 90 print_string (" ("); 91 print_string ("0x"); 92 print_hex (u); 93 print_string (") bytes"); 94} 95 96/* Print the current values of RESOURCE. */ 97 98static void 99print_rlimit (int resource) 100{ 101 struct rlimit rl; 102 getrlimit (resource, &rl); 103 print_string ("cur=0x"); 104 print_hex (rl.rlim_cur); 105 print_string (" max=0x"); 106 print_hex (rl.rlim_max); 107} 108 109static void 110maximize_rlimit (int resource, const char *prefix) 111{ 112 struct rlimit rl; 113 print_string (" "); 114 print_string (prefix); 115 print_string (": "); 116 print_rlimit (resource); 117 getrlimit (resource, &rl); 118 rl.rlim_cur = rl.rlim_max; 119 if (sizeof (rl.rlim_cur) >= sizeof (RLIMIT_CAP)) 120 rl.rlim_cur = (rlim_t) RLIMIT_CAP; 121 setrlimit (resource, &rl); 122 print_string (" -> "); 123 print_rlimit (resource); 124 print_string ("\n"); 125} 126 127/* Maintain a doublely linked list. */ 128struct list 129{ 130 struct list *next; 131 struct list *prev; 132 size_t size; 133}; 134 135/* Put the "heap" in the DATA section. That way it is more likely 136 that the variable will occur early in the core file (an address 137 before the heap) and hence more likely that GDB will at least get 138 its value right. 139 140 To simplify the list append logic, start the heap out with one 141 entry (that lives in the BSS section). */ 142 143static struct list dummy; 144static struct list heap = { &dummy, &dummy }; 145 146static unsigned long bytes_allocated; 147 148#ifdef O_LARGEFILE 149#define large_off_t off64_t 150#define large_lseek lseek64 151#else 152#define large_off_t off_t 153#define O_LARGEFILE 0 154#define large_lseek lseek 155#endif 156 157int 158main () 159{ 160 size_t max_chunk_size; 161 large_off_t max_core_size; 162 163 /* Try to expand all the resource limits beyond the point of sanity 164 - we're after the biggest possible core file. */ 165 166 print_string ("Maximize resource limits ...\n"); 167#ifdef RLIMIT_CORE 168 maximize_rlimit (RLIMIT_CORE, "core"); 169#endif 170#ifdef RLIMIT_DATA 171 maximize_rlimit (RLIMIT_DATA, "data"); 172#endif 173#ifdef RLIMIT_STACK 174 maximize_rlimit (RLIMIT_STACK, "stack"); 175#endif 176#ifdef RLIMIT_AS 177 maximize_rlimit (RLIMIT_AS, "stack"); 178#endif 179 180 print_string ("Maximize allocation limits ...\n"); 181 182 /* Compute the largest possible corefile size. No point in trying 183 to create a corefile larger than the largest file supported by 184 the file system. What about 64-bit lseek64? */ 185 { 186 int fd; 187 large_off_t tmp; 188 unlink ("bigcore.corefile"); 189 fd = open ("bigcore.corefile", O_RDWR | O_CREAT | O_TRUNC | O_LARGEFILE, 190 0666); 191 for (tmp = 1; tmp > 0; tmp <<= 1) 192 { 193 if (large_lseek (fd, tmp, SEEK_SET) > 0) 194 max_core_size = tmp; 195 } 196 close (fd); 197 } 198 199 /* Compute an initial chunk size. The math is dodgy but it works 200 for the moment. Perhaphs there's a constant around somewhere. 201 Limit this to max_core_size bytes - no point in trying to 202 allocate more than can be written to the corefile. */ 203 { 204 size_t tmp; 205 for (tmp = 1; tmp > 0 && tmp < max_core_size; tmp <<= 1) 206 max_chunk_size = tmp; 207 } 208 209 print_string (" core: "); 210 print_byte_count (max_core_size); 211 print_string ("\n"); 212 print_string (" chunk: "); 213 print_byte_count (max_chunk_size); 214 print_string ("\n"); 215 print_string (" large? "); 216 if (O_LARGEFILE) 217 print_string ("yes\n"); 218 else 219 print_string ("no\n"); 220 221 /* Allocate as much memory as possible creating a linked list of 222 each section. The linking ensures that some, but not all, the 223 memory is allocated. NB: Some kernels handle this efficiently - 224 only allocating and writing out referenced pages leaving holes in 225 the file for unmodified pages - while others handle this poorly - 226 writing out all pages including those that weren't modified. */ 227 228 print_string ("Alocating the entire heap ...\n"); 229 { 230 size_t chunk_size; 231 unsigned long chunks_allocated = 0; 232 /* Create a linked list of memory chunks. Start with 233 MAX_CHUNK_SIZE blocks of memory and then try allocating smaller 234 and smaller amounts until all (well at least most) memory has 235 been allocated. */ 236 for (chunk_size = max_chunk_size; 237 chunk_size >= sizeof (struct list); 238 chunk_size >>= 1) 239 { 240 unsigned long count = 0; 241 print_string (" "); 242 print_byte_count (chunk_size); 243 print_string (" ... "); 244 while (bytes_allocated + (1 + count) * chunk_size 245 < max_core_size) 246 { 247 struct list *chunk = malloc (chunk_size); 248 if (chunk == NULL) 249 break; 250 chunk->size = chunk_size; 251 /* Link it in. */ 252 chunk->next = NULL; 253 chunk->prev = heap.prev; 254 heap.prev->next = chunk; 255 heap.prev = chunk; 256 count++; 257 } 258 print_unsigned (count); 259 print_string (" chunks\n"); 260 chunks_allocated += count; 261 bytes_allocated += chunk_size * count; 262 } 263 print_string ("Total of "); 264 print_byte_count (bytes_allocated); 265 print_string (" bytes "); 266 print_unsigned (chunks_allocated); 267 print_string (" chunks\n"); 268 } 269 270 /* Push everything out to disk. */ 271 272 print_string ("Dump core ....\n"); 273 *(char*)0 = 0; 274} 275