1 /*
   2  * Copyright (c) 1999, 2005, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include <new.h>
  27 #include <stdio.h>
  28 #include "awt_new.h"
  29 #include "awt_Toolkit.h"
  30 #include "Hashtable.h"
  31 
  32 // Don't want to pull in the redefined allocation functions
  33 #undef malloc
  34 #undef calloc
  35 #undef realloc
  36 #undef ExceptionOccurred
  37 
  38 #ifdef OUTOFMEM_TEST
  39   #undef safe_Malloc
  40   #undef safe_Calloc
  41   #undef safe_Realloc
  42   #undef new
  43 
  44   static CriticalSection *alloc_lock;
  45   static FILE *logfile;
  46   static DWORD thread_seeded = TLS_OUT_OF_INDEXES;
  47 #endif
  48 
  49 
  50 void
  51 NewHandler::init() {
  52     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
  53 
  54 #ifdef OUTOFMEM_TEST
  55     alloc_lock = new CriticalSection();
  56     logfile = fopen("java.awt.outofmem.txt", "w");
  57     DASSERT(logfile);
  58     thread_seeded = TlsAlloc();
  59     DASSERT(thread_seeded != TLS_OUT_OF_INDEXES);
  60 #endif
  61 
  62     // use new handler for operator new and malloc
  63     _set_new_mode(1);
  64 
  65     // set the function which will be called when operator new or
  66     // malloc runs out of memory
  67     _set_new_handler((_PNH)NewHandler::handler);
  68 }
  69 
  70 // Called when malloc or operator new runs out of memory. We try to
  71 // compact the heap by initiating a Java GC. If the amount of free
  72 // memory available after this operation increases, then we return
  73 // (1) to indicate that malloc or operator new should retry the
  74 // allocation. Returning (0) indicates that the allocation should fail.
  75 int
  76 NewHandler::handler(size_t) {
  77     fprintf(stderr, "java.lang.OutOfMemoryError\n");
  78     return FALSE;
  79 }
  80 
  81 // These three functions throw std::bad_alloc in an out of memory condition
  82 // instead of returning 0. safe_Realloc will return 0 if memblock is not
  83 // NULL and size is 0. safe_Malloc and safe_Calloc will never return 0.
  84 void *safe_Malloc(size_t size) throw (std::bad_alloc) {
  85     register void *ret_val = malloc(size);
  86     if (ret_val == NULL) {
  87         throw std::bad_alloc();
  88     }
  89 
  90     return ret_val;
  91 }
  92 
  93 void *safe_Calloc(size_t num, size_t size) throw (std::bad_alloc) {
  94     register void *ret_val = calloc(num, size);
  95     if (ret_val == NULL) {
  96         throw std::bad_alloc();
  97     }
  98 
  99     return ret_val;
 100 }
 101 
 102 void *safe_Realloc(void *memblock, size_t size) throw (std::bad_alloc) {
 103     register void *ret_val = realloc(memblock, size);
 104 
 105     // Special case for realloc.
 106     if (memblock != NULL && size == 0) {
 107         return ret_val; // even if it's NULL
 108     }
 109 
 110     if (ret_val == NULL) {
 111         throw std::bad_alloc();
 112     }
 113 
 114     return ret_val;
 115 }
 116 
 117 #if !defined(DEBUG)
 118 // This function exists because VC++ 5.0 currently does not conform to the
 119 // Standard C++ specification which requires that operator new throw
 120 // std::bad_alloc in an out of memory situation. Instead, VC++ 5.0 returns 0.
 121 //
 122 // This function can be safely removed when the problem is corrected.
 123 void * CDECL operator new(size_t size) throw (std::bad_alloc) {
 124     return safe_Malloc(size);
 125 }
 126 #endif
 127 
 128 // This function is called at the beginning of an entry point.
 129 // Entry points are functions which are declared:
 130 //   1. CALLBACK,
 131 //   2. JNIEXPORT,
 132 //   3. __declspec(dllexport), or
 133 //   4. extern "C"
 134 // A function which returns an HRESULT (an OLE function) is also an entry
 135 // point.
 136 void
 137 entry_point(void) {
 138     if (jvm != NULL) {
 139         JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 140         if (env != NULL) {
 141             env->ExceptionClear();
 142         }
 143     }
 144 }
 145 
 146 
 147 // This function is called when a std::bad_alloc exception is caught.
 148 void
 149 handle_bad_alloc(void) {
 150     if (jvm != NULL) {
 151         JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 152         if (env != NULL && !env->ExceptionCheck()) {
 153             JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
 154         }
 155     }
 156 }
 157 
 158 
 159 // This function is called instead of ExceptionOccurred. It throws
 160 // std::bad_alloc if a java.lang.OutOfMemoryError is currently pending
 161 // on the calling thread.
 162 jthrowable
 163 safe_ExceptionOccurred(JNIEnv *env) throw (std::bad_alloc) {
 164     jthrowable xcp = env->ExceptionOccurred();
 165     if (xcp != NULL) {
 166         env->ExceptionClear(); // if we don't do this, isInstanceOf will fail
 167         jint isOutofmem = JNU_IsInstanceOfByName(env, xcp, "java/lang/OutOfMemoryError");
 168         if (isOutofmem > 0) {
 169             env->DeleteLocalRef(xcp);
 170             throw std::bad_alloc();
 171         } else {
 172             env->ExceptionClear();
 173             // rethrow exception
 174             env->Throw(xcp);



 175             return xcp;
 176         }
 177     }
 178 
 179     return NULL;
 180 }
 181 
 182 #ifdef OUTOFMEM_TEST
 183 
 184 #include <time.h>
 185 #include <limits.h>
 186 
 187 static void
 188 rand_alloc_fail(const char *file, int line) throw (std::bad_alloc)
 189 {
 190     if (alloc_lock == NULL) { // Not yet initialized
 191         return;
 192     }
 193 
 194     CriticalSection::Lock l(*alloc_lock);
 195 
 196     // Each thread must be seeded individually
 197     if (!TlsGetValue(thread_seeded)) {
 198         TlsSetValue(thread_seeded, (LPVOID)1);
 199         srand((unsigned int)time(NULL));
 200     }
 201 
 202     if (rand() > (int)(RAND_MAX * .999)) { // .1% chance of alloc failure
 203         fprintf(stderr, "failing allocation at %s, %d\n", file, line);
 204         fprintf(logfile, "%s, %d\n", file, line);
 205         fflush(logfile);
 206 
 207         VERIFY(malloc(INT_MAX) == 0); // should fail
 208 
 209         throw std::bad_alloc();
 210     }
 211 }
 212 
 213 void *safe_Malloc_outofmem(size_t size, const char *file, int line)
 214     throw (std::bad_alloc)
 215 {
 216     rand_alloc_fail(file, line);
 217     return safe_Malloc(size);
 218 }
 219 
 220 void *safe_Calloc_outofmem(size_t num, size_t size, const char *file, int line)
 221     throw (std::bad_alloc)
 222 {
 223     rand_alloc_fail(file, line);
 224     return safe_Calloc(num, size);
 225 }
 226 
 227 void *safe_Realloc_outofmem(void *memblock, size_t size, const char *file,
 228                             int line)
 229     throw (std::bad_alloc)
 230 {
 231     rand_alloc_fail(file, line);
 232     return safe_Realloc(memblock, size);
 233 }
 234 
 235 void * CDECL operator new(size_t size, const char *file, int line)
 236     throw (std::bad_alloc)
 237 {
 238     rand_alloc_fail(file, line);
 239     return operator new(size);
 240 }
 241 
 242 #endif
--- EOF ---