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