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