1  /*
  2   * testOOM.c: Test out-of-memory handling
  3   *
  4   * See Copyright for the status of this software.
  5   *
  6   * Copyright 2003 Red Hat, Inc.
  7   * Written by: hp@redhat.com
  8   */
  9  
 10  #include "testOOMlib.h"
 11  
 12  #ifdef HAVE_STDLIB_H
 13  #include <stdlib.h>
 14  #endif
 15  
 16  #include <string.h>
 17  
 18  #define _TEST_INT_MAX 2147483647
 19  #ifndef TRUE
 20  #define TRUE (1)
 21  #endif
 22  #ifndef FALSE
 23  #define FALSE (0)
 24  #endif
 25  #ifndef NULL
 26  #define NULL ((void*)0)
 27  #endif
 28  
 29  #include <libxml/xmlmemory.h>
 30  
 31  static int fail_alloc_counter = _TEST_INT_MAX;
 32  static int n_failures_per_failure = 1;
 33  static int n_failures_this_failure = 0;
 34  static int n_blocks_outstanding = 0;
 35  
 36  /**
 37   * set_fail_alloc_counter:
 38   * @until_next_fail: number of successful allocs before one fails
 39   *
 40   * Sets the number of allocations until we simulate a failed
 41   * allocation. If set to 0, the next allocation to run
 42   * fails; if set to 1, one succeeds then the next fails; etc.
 43   * Set to _TEST_INT_MAX to not fail anything.
 44   */
 45  static void
 46  set_fail_alloc_counter (int until_next_fail)
 47  {
 48    fail_alloc_counter = until_next_fail;
 49  }
 50  
 51  /**
 52   * get_fail_alloc_counter:
 53   *
 54   * Returns the number of successful allocs until we'll simulate
 55   * a failed alloc.
 56   */
 57  static int
 58  get_fail_alloc_counter (void)
 59  {
 60    return fail_alloc_counter;
 61  }
 62  
 63  /**
 64   * set_fail_alloc_failures:
 65   * @failures_per_failure: number to fail
 66   *
 67   * Sets how many mallocs to fail when the fail alloc counter reaches
 68   * 0.
 69   *
 70   */
 71  static void
 72  set_fail_alloc_failures (int failures_per_failure)
 73  {
 74    n_failures_per_failure = failures_per_failure;
 75  }
 76  
 77  /**
 78   * decrement_fail_alloc_counter:
 79   *
 80   * Called when about to alloc some memory; if
 81   * it returns #TRUE, then the allocation should
 82   * fail. If it returns #FALSE, then the allocation
 83   * should not fail.
 84   *
 85   * returns #TRUE if this alloc should fail
 86   */
 87  static int
 88  decrement_fail_alloc_counter (void)
 89  {
 90    if (fail_alloc_counter <= 0)
 91      {
 92        n_failures_this_failure += 1;
 93        if (n_failures_this_failure >= n_failures_per_failure)
 94          {
 95            fail_alloc_counter = _TEST_INT_MAX;
 96  
 97            n_failures_this_failure = 0;
 98          }
 99  
100        return TRUE;
101      }
102    else
103      {
104        fail_alloc_counter -= 1;
105        return FALSE;
106      }
107  }
108  
109  /**
110   * test_get_malloc_blocks_outstanding:
111   *
112   * Get the number of outstanding malloc()'d blocks.
113   *
114   * Returns number of blocks
115   */
116  int
117  test_get_malloc_blocks_outstanding (void)
118  {
119    return n_blocks_outstanding;
120  }
121  
122  void*
123  test_malloc (size_t bytes)
124  {
125    if (decrement_fail_alloc_counter ())
126      {
127        /* FAIL the malloc */
128        return NULL;
129      }
130  
131    if (bytes == 0) /* some system mallocs handle this, some don't */
132      return NULL;
133    else
134      {
135        void *mem;
136        mem = xmlMemMalloc (bytes);
137  
138        if (mem)
139          n_blocks_outstanding += 1;
140  
141        return mem;
142      }
143  }
144  
145  void*
146  test_realloc (void  *memory,
147                size_t bytes)
148  {
149    if (decrement_fail_alloc_counter ())
150      {
151        /* FAIL */
152        return NULL;
153      }
154  
155    if (bytes == 0) /* guarantee this is safe */
156      {
157        test_free (memory);
158        return NULL;
159      }
160    else
161      {
162        void *mem;
163        mem = xmlMemRealloc (memory, bytes);
164  
165        if (memory == NULL && mem != NULL)
166          n_blocks_outstanding += 1;
167  
168        return mem;
169      }
170  }
171  
172  void
173  test_free (void  *memory)
174  {
175    if (memory) /* we guarantee it's safe to free (NULL) */
176      {
177        n_blocks_outstanding -= 1;
178  
179        xmlMemFree (memory);
180      }
181  }
182  
183  char*
184  test_strdup (const char *str)
185  {
186    int len;
187    char *copy;
188  
189    if (str == NULL)
190      return NULL;
191  
192    len = strlen (str);
193  
194    copy = test_malloc (len + 1);
195    if (copy == NULL)
196      return NULL;
197  
198    memcpy (copy, str, len + 1);
199  
200    return copy;
201  }
202  
203  static int
204  run_failing_each_malloc (int                n_mallocs,
205                           TestMemoryFunction func,
206                           void              *data)
207  {
208    n_mallocs += 10; /* fudge factor to ensure reallocs etc. are covered */
209  
210    while (n_mallocs >= 0)
211      {
212        set_fail_alloc_counter (n_mallocs);
213  
214        if (!(* func) (data))
215          return FALSE;
216  
217        n_mallocs -= 1;
218      }
219  
220    set_fail_alloc_counter (_TEST_INT_MAX);
221  
222    return TRUE;
223  }
224  
225  /**
226   * test_oom_handling:
227   * @func: function to call
228   * @data: data to pass to function
229   *
230   * Tests how well the given function responds to out-of-memory
231   * situations. Calls the function repeatedly, failing a different
232   * call to malloc() each time. If the function ever returns #FALSE,
233   * the test fails. The function should return #TRUE whenever something
234   * valid (such as returning an error, or succeeding) occurs, and #FALSE
235   * if it gets confused in some way.
236   *
237   * Returns #TRUE if the function never returns FALSE
238   */
239  int
240  test_oom_handling (TestMemoryFunction  func,
241                     void               *data)
242  {
243    int approx_mallocs;
244  
245    /* Run once to see about how many mallocs are involved */
246  
247    set_fail_alloc_counter (_TEST_INT_MAX);
248  
249    if (!(* func) (data))
250      return FALSE;
251  
252    approx_mallocs = _TEST_INT_MAX - get_fail_alloc_counter ();
253  
254    set_fail_alloc_failures (1);
255    if (!run_failing_each_malloc (approx_mallocs, func, data))
256      return FALSE;
257  
258    set_fail_alloc_failures (2);
259    if (!run_failing_each_malloc (approx_mallocs, func, data))
260      return FALSE;
261  
262    set_fail_alloc_failures (3);
263    if (!run_failing_each_malloc (approx_mallocs, func, data))
264      return FALSE;
265  
266    set_fail_alloc_counter (_TEST_INT_MAX);
267  
268    return TRUE;
269  }