- Unify error handling to not check for nullptr, which can not happen.

- Assert to ensure precondition are met.
- Update length so we chcek the whole buffer.

3 files changed, 16 insertions, 19 deletions

diff --git a/vespamalloc/src/tests/test1/new_test.cpp b/vespamalloc/src/tests/test1/new_test.cpp
index bd4d4f55cc3..dfa67f2aa7c 100644
--- a/vespamalloc/src/tests/test1/new_test.cpp
+++ b/vespamalloc/src/tests/test1/new_test.cpp
@@ -171,10 +171,10 @@ detectLibrary() {
     return MallocLibrary::UNKNOWN;
 }
 
-MallocLibrary _Env = detectLibrary();
+MallocLibrary _env = detectLibrary();
 
 size_t
-cmp(const char * v, char c, size_t count) {
+count_mismatches(const char * v, char c, size_t count) {
     size_t errors = 0;
     for (size_t i(0); i < count; i++) {
         if (v[i] != c) errors++;
@@ -188,10 +188,10 @@ TEST("verify malloc_usable_size is sane") {
     constexpr size_t SZ = 33;
     std::unique_ptr<char[]> buf = std::make_unique<char[]>(SZ);
     size_t usable_size = malloc_usable_size(buf.get());
-    if (_Env == MallocLibrary::VESPA_MALLOC_D) {
+    if (_env == MallocLibrary::VESPA_MALLOC_D) {
         // Debug variants will never have more memory available as there is pre/postamble for error detection.
         EXPECT_EQUAL(SZ, usable_size);
-    } else if (_Env == MallocLibrary::VESPA_MALLOC) {
+    } else if (_env == MallocLibrary::VESPA_MALLOC) {
         // Normal production vespamalloc will round up
         EXPECT_EQUAL(64u, usable_size);
         verify_vespamalloc_usable_size();
@@ -202,14 +202,14 @@ TEST("verify malloc_usable_size is sane") {
 }
 
 TEST("verify mallopt") {
-    if (_Env == MallocLibrary::UNKNOWN) return;
+    if (_env == MallocLibrary::UNKNOWN) return;
     EXPECT_EQUAL(0, mallopt(M_MMAP_MAX, 0x1000000));
     EXPECT_EQUAL(1, mallopt(M_MMAP_THRESHOLD, 0x1000000));
     EXPECT_EQUAL(1, mallopt(M_MMAP_THRESHOLD, 1_Gi));
 }
 
 TEST("verify mmap_limit") {
-    if (_Env == MallocLibrary::UNKNOWN) return;
+    if (_env == MallocLibrary::UNKNOWN) return;
     EXPECT_EQUAL(1, mallopt(M_MMAP_THRESHOLD, 0x100000));
     auto small = std::make_unique<char[]>(16_Ki);
     auto large_1 = std::make_unique<char[]>(1200_Ki);
@@ -230,19 +230,19 @@ verifyReallocLarge(char * initial, bool expect_vespamalloc_optimization) {
     if (expect_vespamalloc_optimization) {
         ASSERT_TRUE(v == nv);
     }
-    EXPECT_EQUAL(0u, cmp(nv, 0x5b, INITIAL_SIZE));
+    EXPECT_EQUAL(0u, count_mismatches(nv, 0x5b, INITIAL_SIZE));
     memset(nv, 0xbe, SECOND_SIZE);
     v = static_cast<char *>(realloc(nv, THIRD_SIZE));
     if (expect_vespamalloc_optimization) {
         ASSERT_TRUE(v != nv);
     }
-    EXPECT_EQUAL(0u, cmp(v, 0xbe, INITIAL_SIZE));
+    EXPECT_EQUAL(0u, count_mismatches(v, 0xbe, SECOND_SIZE));
     free(v);
 }
 TEST("test realloc large buffers") {
-    verifyReallocLarge(nullptr, _Env != MallocLibrary::UNKNOWN);
-    verifyReallocLarge(static_cast<char *>(malloc(2000)), _Env != MallocLibrary::UNKNOWN);
-    if (_Env == MallocLibrary::UNKNOWN) return;
+    verifyReallocLarge(nullptr, _env != MallocLibrary::UNKNOWN);
+    verifyReallocLarge(static_cast<char *>(malloc(2000)), _env != MallocLibrary::UNKNOWN);
+    if (_env == MallocLibrary::UNKNOWN) return;
 
     EXPECT_EQUAL(1, mallopt(M_MMAP_THRESHOLD, 1_Mi));
     verifyReallocLarge(nullptr, false);
diff --git a/vespamalloc/src/vespamalloc/malloc/malloc.h b/vespamalloc/src/vespamalloc/malloc/malloc.h
index 614d140c212..24bfda0b840 100644
--- a/vespamalloc/src/vespamalloc/malloc/malloc.h
+++ b/vespamalloc/src/vespamalloc/malloc/malloc.h
@@ -247,7 +247,7 @@ void * MemoryManager<MemBlockPtrT, ThreadListT>::realloc(void *oldPtr, size_t sz
     MemBlockPtrT mem(oldPtr);
     mem.readjustAlignment(_segment);
     if (! mem.validAlloc()) {
-        fprintf(stderr, "Someone has tamper with my pre/post signatures of my memoryblock %p(%ld).\n", mem.ptr(), mem.size());
+        fprintf(stderr, "Someone has tampered with the pre/post signatures of my memoryblock %p(%ld).\n", mem.ptr(), mem.size());
         crash();
     }
 
@@ -257,19 +257,15 @@ void * MemoryManager<MemBlockPtrT, ThreadListT>::realloc(void *oldPtr, size_t sz
         size_t oldSz(_segment.getMaxSize<MemBlockPtrT>(oldPtr));
         if (sz > oldSz) {
             ptr = malloc(sz);
-            if (ptr) {
-                memcpy(ptr, oldPtr, oldSz);
-                free(oldPtr);
-            }
+            memcpy(ptr, oldPtr, oldSz);
+            free(oldPtr);
         } else {
             mem.setExact(sz);
             ptr = oldPtr;
         }
     } else {
         ptr = malloc(sz);
-        if (ptr) {
-            memcpy(ptr, oldPtr, sz);
-        }
+        memcpy(ptr, oldPtr, sz);
     }
     PARANOID_CHECK2( { MemBlockPtrT mem(ptr); mem.readjustAlignment(_segment); if (! mem.validAlloc()) { crash(); } });
     return ptr;
diff --git a/vespamalloc/src/vespamalloc/malloc/mmappool.cpp b/vespamalloc/src/vespamalloc/malloc/mmappool.cpp
index eae4b9562d6..34232018671 100644
--- a/vespamalloc/src/vespamalloc/malloc/mmappool.cpp
+++ b/vespamalloc/src/vespamalloc/malloc/mmappool.cpp
@@ -105,6 +105,7 @@ size_t
 MMapPool::get_size(void * ptr) const {
     std::lock_guard guard(_mutex);
     auto found = _mappings.find(ptr);
+    assert(found != _mappings.end());
     return found->second._sz;
 }