mirror of
https://github.com/SerenityOS/serenity.git
synced 2025-01-24 10:22:05 -05:00
5491e0cdcc
In standard C++, operators `new` and `new[]` are guaranteed to return a valid (non-null) pointer and throw an exception if the allocation couldn't be performed. Based on this, compilers did not check the returned pointer before attempting to use them for object construction. To avoid this, the allocator operators were changed to be `noexcept` in PR #7026, which made GCC emit the desired null checks. Unfortunately, this is a non-standard feature which meant that Clang would not accept these function definitions, as it did not match its expected declaration. To make compiling using Clang possible, the special "nothrow" versions of `new` are implemented in this commit. These take a tag type of `std::nothrow_t` (used for disambiguating from placement new/etc.), and are allowed by the standard to return null. There is a global variable, `std::nothrow`, declared with this type, which is also exported into the global namespace. To perform fallible allocations, the following syntax should be used: ```cpp auto ptr = new (nothrow) T; ``` As we don't support exceptions in the kernel, the only way of uphold the "throwing" new's guarantee is to abort if the allocation couldn't be performed. Once we have proper OOM handling in the kernel, this should only be used for critical allocations, where we wouldn't be able to recover from allocation failures anyway.
90 lines
3.7 KiB
C++
90 lines
3.7 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/Types.h>
|
|
#include <Kernel/Debug.h>
|
|
#include <LibC/limits.h>
|
|
|
|
#define KMALLOC_SCRUB_BYTE 0xbb
|
|
#define KFREE_SCRUB_BYTE 0xaa
|
|
|
|
#define MAKE_ALIGNED_ALLOCATED(type, alignment) \
|
|
public: \
|
|
[[nodiscard]] void* operator new(size_t) \
|
|
{ \
|
|
void* ptr = kmalloc_aligned<alignment>(sizeof(type)); \
|
|
VERIFY(ptr); \
|
|
return ptr; \
|
|
} \
|
|
[[nodiscard]] void* operator new(size_t, const std::nothrow_t&) noexcept { return kmalloc_aligned<alignment>(sizeof(type)); } \
|
|
void operator delete(void* ptr) noexcept { kfree_aligned(ptr); } \
|
|
\
|
|
private:
|
|
|
|
// The C++ standard specifies that the nothrow allocation tag should live in the std namespace.
|
|
// Otherwise, `new (std::nothrow)` calls wouldn't get resolved.
|
|
namespace std {
|
|
struct nothrow_t {
|
|
explicit nothrow_t() = default;
|
|
};
|
|
|
|
extern const nothrow_t nothrow;
|
|
};
|
|
|
|
void kmalloc_init();
|
|
[[gnu::malloc, gnu::returns_nonnull, gnu::alloc_size(1)]] void* kmalloc_impl(size_t);
|
|
[[gnu::malloc, gnu::returns_nonnull, gnu::alloc_size(1)]] void* kmalloc_eternal(size_t);
|
|
|
|
void* krealloc(void*, size_t);
|
|
void kfree(void*);
|
|
|
|
struct kmalloc_stats {
|
|
size_t bytes_allocated;
|
|
size_t bytes_free;
|
|
size_t bytes_eternal;
|
|
size_t kmalloc_call_count;
|
|
size_t kfree_call_count;
|
|
};
|
|
void get_kmalloc_stats(kmalloc_stats&);
|
|
|
|
extern bool g_dump_kmalloc_stacks;
|
|
|
|
inline void* operator new(size_t, void* p) { return p; }
|
|
inline void* operator new[](size_t, void* p) { return p; }
|
|
|
|
[[nodiscard]] void* operator new(size_t size);
|
|
[[nodiscard]] void* operator new(size_t size, const std::nothrow_t&) noexcept;
|
|
void operator delete(void* ptr) noexcept;
|
|
void operator delete(void* ptr, size_t) noexcept;
|
|
[[nodiscard]] void* operator new[](size_t size);
|
|
[[nodiscard]] void* operator new[](size_t size, const std::nothrow_t&) noexcept;
|
|
void operator delete[](void* ptrs) noexcept;
|
|
void operator delete[](void* ptr, size_t) noexcept;
|
|
|
|
[[gnu::malloc, gnu::returns_nonnull, gnu::alloc_size(1)]] void* kmalloc(size_t);
|
|
|
|
template<size_t ALIGNMENT>
|
|
[[gnu::malloc, gnu::returns_nonnull, gnu::alloc_size(1)]] inline void* kmalloc_aligned(size_t size)
|
|
{
|
|
static_assert(ALIGNMENT > sizeof(ptrdiff_t));
|
|
static_assert(ALIGNMENT <= 4096);
|
|
void* ptr = kmalloc(size + ALIGNMENT + sizeof(ptrdiff_t));
|
|
size_t max_addr = (size_t)ptr + ALIGNMENT;
|
|
void* aligned_ptr = (void*)(max_addr - (max_addr % ALIGNMENT));
|
|
((ptrdiff_t*)aligned_ptr)[-1] = (ptrdiff_t)((u8*)aligned_ptr - (u8*)ptr);
|
|
return aligned_ptr;
|
|
}
|
|
|
|
inline void kfree_aligned(void* ptr)
|
|
{
|
|
kfree((u8*)ptr - ((const ptrdiff_t*)ptr)[-1]);
|
|
}
|
|
|
|
size_t kmalloc_good_size(size_t);
|
|
|
|
void kmalloc_enable_expand();
|