system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-21 18:15:58 +00:00
Code Issues Actions 7 Packages Projects Releases Wiki Activity

AK+Kernel: Make fallible allocations compiler-agnostic

Browse source 
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.
This commit is contained in:
Daniel Bertalan 2021-06-20 09:39:20 +02:00 committed by Ali Mohammad Pur
parent d6138df490
commit 5491e0cdcc
4 changed files with 83 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
AK/kmalloc.h
View file

@ -41,34 +41,49 @@ inline size_t malloc_good_size(size_t size) { return size; }
# ifdef __serenity__
# include <AK/Assertions.h>
# include <new>
inline void* operator new(size_t size)
{
void* ptr = kmalloc(size);
VERIFY(ptr);
return ptr;
}
inline void* operator new(size_t size, const std::nothrow_t&) noexcept
{
return kmalloc(size);
}
inline void operator delete(void* ptr)
inline void operator delete(void* ptr) noexcept
{
return kfree(ptr);
}
inline void operator delete(void* ptr, size_t)
inline void operator delete(void* ptr, size_t) noexcept
{
return kfree(ptr);
}
inline void* operator new[](size_t size)
{
void* ptr = kmalloc(size);
VERIFY(ptr);
return ptr;
}
inline void* operator new[](size_t size, const std::nothrow_t&) noexcept
{
return kmalloc(size);
}
inline void operator delete[](void* ptr)
inline void operator delete[](void* ptr) noexcept
{
return kfree(ptr);
}
inline void operator delete[](void* ptr, size_t)
inline void operator delete[](void* ptr, size_t) noexcept
{
return kfree(ptr);
}
@ -76,3 +91,5 @@ inline void operator delete[](void* ptr, size_t)
# endif
#endif
using std::nothrow;

22
Kernel/Heap/SlabAllocator.h
View file

@ -19,11 +19,23 @@ void slab_dealloc(void*, size_t slab_size);
void slab_alloc_init();
void slab_alloc_stats(Function<void(size_t slab_size, size_t allocated, size_t free)>);
#define MAKE_SLAB_ALLOCATED(type) \
public: \
[[nodiscard]] void* operator new(size_t) noexcept { return slab_alloc(sizeof(type)); } \
void operator delete(void* ptr) noexcept { slab_dealloc(ptr, sizeof(type)); } \
\
#define MAKE_SLAB_ALLOCATED(type) \
public: \
[[nodiscard]] void* operator new(size_t) \
{ \
void* ptr = slab_alloc(sizeof(type)); \
VERIFY(ptr); \
return ptr; \
} \
[[nodiscard]] void* operator new(size_t, const std::nothrow_t&) noexcept \
{ \
return slab_alloc(sizeof(type)); \
} \
void operator delete(void* ptr) noexcept \
{ \
slab_dealloc(ptr, sizeof(type)); \
} \
\
private:
}

22
Kernel/Heap/kmalloc.cpp
View file

@ -29,6 +29,10 @@
#define POOL_SIZE (2 * MiB)
#define ETERNAL_RANGE_SIZE (2 * MiB)
namespace std {
const nothrow_t nothrow;
}
static RecursiveSpinLock s_lock; // needs to be recursive because of dump_backtrace()
static void kmalloc_allocate_backup_memory();
@ -300,12 +304,26 @@ size_t kmalloc_good_size(size_t size)
return size;
}
void* operator new(size_t size) noexcept
void* operator new(size_t size)
{
void* ptr = kmalloc(size);
VERIFY(ptr);
return ptr;
}
void* operator new(size_t size, const std::nothrow_t&) noexcept
{
return kmalloc(size);
}
void* operator new[](size_t size) noexcept
void* operator new[](size_t size)
{
void* ptr = kmalloc(size);
VERIFY(ptr);
return ptr;
}
void* operator new[](size_t size, const std::nothrow_t&) noexcept
{
return kmalloc(size);
}

32
Kernel/Heap/kmalloc.h
View file

@ -13,13 +13,29 @@
#define KMALLOC_SCRUB_BYTE 0xbb
#define KFREE_SCRUB_BYTE 0xaa
#define MAKE_ALIGNED_ALLOCATED(type, alignment) \
public: \
[[nodiscard]] void* operator new(size_t) noexcept { return kmalloc_aligned<alignment>(sizeof(type)); } \
void operator delete(void* ptr) noexcept { kfree_aligned(ptr); } \
\
#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);
@ -41,10 +57,12 @@ 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) noexcept;
[[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) 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;