Fixed latent SEGVs from malloc() returning NULL.

brixen · brixen · commit 47ac1f85ff38 · 2015-06-18T20:56:26.000-07:00
diff --git a/vm/builtin/encoding.cpp b/vm/builtin/encoding.cpp
@@ -544,6 +544,7 @@ namespace rubinius {
 
     if(len > STACK_BUF_SZ) {
       malloc_buf = (uint8_t*)malloc(len);
+      if(!malloc_buf) rubinius::abort();
       buf = malloc_buf;
     }
 
diff --git a/vm/builtin/ffi_pointer.cpp b/vm/builtin/ffi_pointer.cpp
@@ -88,6 +88,10 @@ namespace rubinius {
   Pointer* Pointer::allocate_memory(STATE, Object* self, Fixnum* size) {
     Pointer* obj = state->vm()->new_object<Pointer>(as<Class>(self));
     obj->pointer = malloc(size->to_native());;
+    if(!obj->pointer) {
+      Exception::memory_error(state);
+      return NULL;
+    }
     obj->autorelease = false;
     obj->set_finalizer = false;
     return obj;
diff --git a/vm/builtin/io.cpp b/vm/builtin/io.cpp
@@ -661,6 +661,10 @@ namespace rubinius {
 
     if(count > STACK_BUF_SZ) {
       malloc_buf = (char*)malloc(count);
+      if(!malloc_buf) {
+        Exception::memory_error(state);
+        return NULL;
+      }
       buf = malloc_buf;
     }
 
diff --git a/vm/builtin/string.cpp b/vm/builtin/string.cpp
@@ -1054,6 +1054,11 @@ namespace rubinius {
     native_int out_size = out_chunk;
     uint8_t* output = (uint8_t*)malloc(out_size);
 
+    if(!output) {
+      Exception::memory_error(state);
+      return NULL;
+    }
+
     uint8_t* out_p = output;
     uint8_t* out_end = out_p + out_size;
 
diff --git a/vm/builtin/time.cpp b/vm/builtin/time.cpp
@@ -300,6 +300,11 @@ namespace rubinius {
       buf_size *= 2;
       char* malloc_str = (char*)malloc(buf_size);
 
+      if(!malloc_str) {
+        Exception::memory_error(state);
+        return NULL;
+      }
+
       chars = ::strftime_extended(malloc_str, buf_size,
                   format->c_str(state), &tm, &ts, CBOOL(is_gmt_) ? 1 : 0,
                   off);
diff --git a/vm/capi/string.cpp b/vm/capi/string.cpp
@@ -461,6 +461,10 @@ extern "C" {
     String* str = c_as<String>(env->get_object(self));
 
     char* data = (char*)malloc(sizeof(char) * str->byte_size() + 1);
+    if(!data) {
+      rb_raise(rb_eSystemCallError, "unable to allocate memory");
+    }
+
     memcpy(data, str->c_str(env->state()), str->byte_size());
     data[str->byte_size()] = 0;
 
diff --git a/vm/fiber_data.cpp b/vm/fiber_data.cpp
@@ -142,6 +142,7 @@ namespace rubinius {
 
       if(heap_) free(heap_);
       heap_ = malloc(heap_capacity_);
+      if(!heap_) rubinius::abort();
     }
 
     memcpy(heap_, stack_bottom(), heap_size_);
diff --git a/vm/fiber_stack.cpp b/vm/fiber_stack.cpp
@@ -28,6 +28,8 @@ namespace rubinius {
   void FiberStack::allocate() {
     assert(!address_);
     address_ = malloc(size_);
+    if(!address_) rubinius::abort();
+
 #ifdef HAVE_VALGRIND_H
     valgrind_id_ = VALGRIND_STACK_REGISTER(address_, (char *)address_ + size_);
 #endif
@@ -150,6 +152,7 @@ namespace rubinius {
   void* FiberStacks::trampoline() {
     if(trampoline_ == 0) {
       trampoline_ = malloc(cTrampolineSize);
+      if(!trampoline_) rubinius::abort();
     }
 
     return trampoline_;
diff --git a/vm/gc/mark_sweep.cpp b/vm/gc/mark_sweep.cpp
@@ -41,7 +41,10 @@ namespace rubinius {
   }
 
   Object* MarkSweepGC::allocate(size_t bytes, bool *collect_now) {
-    Object* obj = reinterpret_cast<Object*>(malloc(bytes));
+    void* mem = malloc(bytes);
+    if(!mem) rubinius::abort();
+
+    Object* obj = reinterpret_cast<Object*>(mem);
 
     // If the allocation failed, we return a NULL pointer
     if(unlikely(!obj)) {
diff --git a/vm/marshal.cpp b/vm/marshal.cpp
@@ -44,6 +44,7 @@ namespace rubinius {
 
     if(count >= STACK_BUF_SZ) {
       malloc_data = (char*)malloc(count + 1);
+      if(!malloc_data) rubinius::abort();
       data = malloc_data;
     }
 
@@ -69,6 +70,7 @@ namespace rubinius {
 
     if(count >= STACK_BUF_SZ) {
       malloc_data = (char*)malloc(count + 1);
+      if(!malloc_data) rubinius::abort();
       data = malloc_data;
     }
 
@@ -160,6 +162,7 @@ namespace rubinius {
 
     if(count >= STACK_BUF_SZ) {
       malloc_data = (char*)malloc(count + 1);
+      if(!malloc_data) rubinius::abort();
       data = malloc_data;
     }
 
diff --git a/vm/missing/setproctitle.c b/vm/missing/setproctitle.c
@@ -118,6 +118,7 @@ ruby_init_setproctitle(int argc, char *argv[])
     size_t len = strlen(envp[i]) + 1;
 
     tmp = malloc(len);
+    if(!tmp) abort();
     memcpy(tmp, envp[i], len);
 
     environ[i] = tmp;
diff --git a/vm/util/local_buffer.hpp b/vm/util/local_buffer.hpp
@@ -7,6 +7,7 @@ namespace rubinius {
 
     LocalBuffer(size_t size) {
       buffer = malloc(size);
+      if(!buffer) ::abort();
     }
 
     ~LocalBuffer() {

Original file line number	Diff line number	Diff line change
`@@ -544,6 +544,7 @@ namespace rubinius {`
`544`	`544`
`545`	`545`	`if(len > STACK_BUF_SZ) {`
`546`	`546`	`malloc_buf = (uint8_t*)malloc(len);`
	`547`	`+ if(!malloc_buf) rubinius::abort();`
`547`	`548`	`buf = malloc_buf;`
`548`	`549`	`}`
`549`	`550`
Original file line number	Diff line number	Diff line change
`@@ -661,6 +661,10 @@ namespace rubinius {`
`661`	`661`
`662`	`662`	`if(count > STACK_BUF_SZ) {`
`663`	`663`	`malloc_buf = (char*)malloc(count);`
	`664`	`+ if(!malloc_buf) {`
	`665`	`+ Exception::memory_error(state);`
	`666`	`+ return NULL;`
	`667`	`+ }`
`664`	`668`	`buf = malloc_buf;`
`665`	`669`	`}`
`666`	`670`
Original file line number	Diff line number	Diff line change
`@@ -142,6 +142,7 @@ namespace rubinius {`
`142`	`142`
`143`	`143`	`if(heap_) free(heap_);`
`144`	`144`	`heap_ = malloc(heap_capacity_);`
	`145`	`+ if(!heap_) rubinius::abort();`
`145`	`146`	`}`
`146`	`147`
`147`	`148`	`memcpy(heap_, stack_bottom(), heap_size_);`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ namespace rubinius {`
`44`	`44`
`45`	`45`	`if(count >= STACK_BUF_SZ) {`
`46`	`46`	`malloc_data = (char*)malloc(count + 1);`
	`47`	`+ if(!malloc_data) rubinius::abort();`
`47`	`48`	`data = malloc_data;`
`48`	`49`	`}`
`49`	`50`
`@@ -69,6 +70,7 @@ namespace rubinius {`
`69`	`70`
`70`	`71`	`if(count >= STACK_BUF_SZ) {`
`71`	`72`	`malloc_data = (char*)malloc(count + 1);`
	`73`	`+ if(!malloc_data) rubinius::abort();`
`72`	`74`	`data = malloc_data;`
`73`	`75`	`}`
`74`	`76`
`@@ -160,6 +162,7 @@ namespace rubinius {`
`160`	`162`
`161`	`163`	`if(count >= STACK_BUF_SZ) {`
`162`	`164`	`malloc_data = (char*)malloc(count + 1);`
	`165`	`+ if(!malloc_data) rubinius::abort();`
`163`	`166`	`data = malloc_data;`
`164`	`167`	`}`
`165`	`168`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ namespace rubinius {`
`7`	`7`
`8`	`8`	`LocalBuffer(size_t size) {`
`9`	`9`	`buffer = malloc(size);`
	`10`	`+ if(!buffer) ::abort();`
`10`	`11`	`}`
`11`	`12`
`12`	`13`	`~LocalBuffer() {`