system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-11-05 17:46:52 +00:00
Code Issues Projects Releases Packages Wiki Activity
serenity/AK/kmalloc.h

56 lines
1.1 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
AK: Add kmalloc_array() to trap multiplication overflows This pattern is no good: kmalloc(elements * sizeof(T)); Since it silently swallows any multiplication overflow. This patch adds a simple kmalloc_array() that stops the program if overflow occurs: kmalloc_array(elements, sizeof(T));
2021-08-07 20:32:45 +00:00
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
AK: Declare operators `new` and `delete` as global functions This fixes a build issue introduced in 23d66fe, where the compiler statically detected that that mismatching new and delete operators were used. Clang generates a warning for this, for the reasons described in the comment in `AK/kmalloc.cpp`, but GCC does not. Besides moving the allocator functions into a `.cpp` file, declarations in `AK/kmalloc.cpp` were reordered to have imports at the top, in order to make the code more readable.
2021-06-29 20:57:27 +00:00
* Copyright (c) 2021, Daniel Bertalan <dani@danielbertalan.dev>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*/
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
#pragma once
AK: Add kmalloc_array() to trap multiplication overflows This pattern is no good: kmalloc(elements * sizeof(T)); Since it silently swallows any multiplication overflow. This patch adds a simple kmalloc_array() that stops the program if overflow occurs: kmalloc_array(elements, sizeof(T));
2021-08-07 20:32:45 +00:00
#include <AK/Checked.h>
Everywhere: Replace uses of __serenity__ with AK_OS_SERENITY Now that we have OS macros for essentially every supported OS, let's try to use them everywhere.
2022-10-09 21:23:23 +00:00
#include <AK/Platform.h>
AK: Add kmalloc_array() to trap multiplication overflows This pattern is no good: kmalloc(elements * sizeof(T)); Since it silently swallows any multiplication overflow. This patch adds a simple kmalloc_array() that stops the program if overflow occurs: kmalloc_array(elements, sizeof(T));
2021-08-07 20:32:45 +00:00
AK: Declare operators `new` and `delete` as global functions This fixes a build issue introduced in 23d66fe, where the compiler statically detected that that mismatching new and delete operators were used. Clang generates a warning for this, for the reasons described in the comment in `AK/kmalloc.cpp`, but GCC does not. Besides moving the allocator functions into a `.cpp` file, declarations in `AK/kmalloc.cpp` were reordered to have imports at the top, in order to make the code more readable.
2021-06-29 20:57:27 +00:00
#if defined(KERNEL)
# include <Kernel/Heap/kmalloc.h>
#else
AK: Have AK/kmalloc.h #include <new> on other platforms This should make stuff like placement new work correctly when building outside of Serenity. This stuff is a bit delicate due to the weirdly staged toolchain build at the moment. Hopefully we can unify this stuff in the future.
2020-02-25 14:58:24 +00:00
# include <new>
AK: Declare operators `new` and `delete` as global functions This fixes a build issue introduced in 23d66fe, where the compiler statically detected that that mismatching new and delete operators were used. Clang generates a warning for this, for the reasons described in the comment in `AK/kmalloc.cpp`, but GCC does not. Besides moving the allocator functions into a `.cpp` file, declarations in `AK/kmalloc.cpp` were reordered to have imports at the top, in order to make the code more readable.
2021-06-29 20:57:27 +00:00
# include <stdlib.h>
AK+Kernel: Avoid double memory clearing of HashTable buckets Since the allocated memory is going to be zeroed immediately anyway, let's avoid redundantly scrubbing it with MALLOC_SCRUB_BYTE just before that. The latest versions of gcc and Clang can automatically do this malloc + memset -> calloc optimization, but I've seen a couple of places where it failed to be done. This commit also adds a naive kcalloc function to the kernel that doesn't (yet) eliminate the redundancy like the userland does.
2022-03-14 22:59:16 +00:00
# define kcalloc calloc
AK: Declare operators `new` and `delete` as global functions This fixes a build issue introduced in 23d66fe, where the compiler statically detected that that mismatching new and delete operators were used. Clang generates a warning for this, for the reasons described in the comment in `AK/kmalloc.cpp`, but GCC does not. Besides moving the allocator functions into a `.cpp` file, declarations in `AK/kmalloc.cpp` were reordered to have imports at the top, in order to make the code more readable.
2021-06-29 20:57:27 +00:00
# define kmalloc malloc
# define kmalloc_good_size malloc_good_size
AK: Make kfree_sized() forward to kfree() in non-kernel code for now
2021-07-11 11:21:38 +00:00
inline void kfree_sized(void* ptr, size_t)
{
AK: Remove `kfree` definition
2022-01-12 03:27:21 +00:00
free(ptr);
AK: Make kfree_sized() forward to kfree() in non-kernel code for now
2021-07-11 11:21:38 +00:00
}
AK: Declare operators `new` and `delete` as global functions This fixes a build issue introduced in 23d66fe, where the compiler statically detected that that mismatching new and delete operators were used. Clang generates a warning for this, for the reasons described in the comment in `AK/kmalloc.cpp`, but GCC does not. Besides moving the allocator functions into a `.cpp` file, declarations in `AK/kmalloc.cpp` were reordered to have imports at the top, in order to make the code more readable.
2021-06-29 20:57:27 +00:00
#endif
Everywhere: Replace uses of __serenity__ with AK_OS_SERENITY Now that we have OS macros for essentially every supported OS, let's try to use them everywhere.
2022-10-09 21:23:23 +00:00
#ifndef AK_OS_SERENITY
AK: Declare operators `new` and `delete` as global functions This fixes a build issue introduced in 23d66fe, where the compiler statically detected that that mismatching new and delete operators were used. Clang generates a warning for this, for the reasons described in the comment in `AK/kmalloc.cpp`, but GCC does not. Besides moving the allocator functions into a `.cpp` file, declarations in `AK/kmalloc.cpp` were reordered to have imports at the top, in order to make the code more readable.
2021-06-29 20:57:27 +00:00
# include <AK/Types.h>
AK+LibC: Implement malloc_good_size() and use it for Vector/HashTable This implements the macOS API malloc_good_size() which returns the true allocation size for a given requested allocation size. This allows us to make use of all the available memory in a malloc chunk. For example, for a malloc request of 35 bytes our malloc would internally use a chunk of size 64, however the remaining 29 bytes would be unused. Knowing the true allocation size allows us to request more usable memory that would otherwise be wasted and make that available for Vector, HashTable and potentially other callers in the future.
2021-05-15 08:06:41 +00:00
# ifndef AK_OS_MACOS
AK: Declare malloc_good_size as extern "C" This would otherwise cause an error with clang when __serenity__ wasn't defined.
2021-05-30 09:10:39 +00:00
extern "C" {
AK+LibC: Implement malloc_good_size() and use it for Vector/HashTable This implements the macOS API malloc_good_size() which returns the true allocation size for a given requested allocation size. This allows us to make use of all the available memory in a malloc chunk. For example, for a malloc request of 35 bytes our malloc would internally use a chunk of size 64, however the remaining 29 bytes would be unused. Knowing the true allocation size allows us to request more usable memory that would otherwise be wasted and make that available for Vector, HashTable and potentially other callers in the future.
2021-05-15 08:06:41 +00:00
inline size_t malloc_good_size(size_t size) { return size; }
AK: Declare malloc_good_size as extern "C" This would otherwise cause an error with clang when __serenity__ wasn't defined.
2021-05-30 09:10:39 +00:00
}
AK+LibC: Implement malloc_good_size() and use it for Vector/HashTable This implements the macOS API malloc_good_size() which returns the true allocation size for a given requested allocation size. This allows us to make use of all the available memory in a malloc chunk. For example, for a malloc request of 35 bytes our malloc would internally use a chunk of size 64, however the remaining 29 bytes would be unused. Knowing the true allocation size allows us to request more usable memory that would otherwise be wasted and make that available for Vector, HashTable and potentially other callers in the future.
2021-05-15 08:06:41 +00:00
# else
# include <malloc/malloc.h>
# endif
AK: Have AK/kmalloc.h #include <new> on other platforms This should make stuff like placement new work correctly when building outside of Serenity. This stuff is a bit delicate due to the weirdly staged toolchain build at the moment. Hopefully we can unify this stuff in the future.
2020-02-25 14:58:24 +00:00
#endif
AK+Kernel: Make fallible allocations compiler-agnostic 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.
2021-06-20 07:39:20 +00:00
using std::nothrow;
AK: Add kmalloc_array() to trap multiplication overflows This pattern is no good: kmalloc(elements * sizeof(T)); Since it silently swallows any multiplication overflow. This patch adds a simple kmalloc_array() that stops the program if overflow occurs: kmalloc_array(elements, sizeof(T));
2021-08-07 20:32:45 +00:00
AK: Fully qualify some usages of AK features outside of the AK namespace
2022-11-27 15:40:42 +00:00
inline void* kmalloc_array(AK::Checked<size_t> a, AK::Checked<size_t> b)
AK: Add kmalloc_array() to trap multiplication overflows This pattern is no good: kmalloc(elements * sizeof(T)); Since it silently swallows any multiplication overflow. This patch adds a simple kmalloc_array() that stops the program if overflow occurs: kmalloc_array(elements, sizeof(T));
2021-08-07 20:32:45 +00:00
{
auto size = a * b;
VERIFY(!size.has_overflow());
return kmalloc(size.value());
}
AK: Fully qualify some usages of AK features outside of the AK namespace
2022-11-27 15:40:42 +00:00
inline void* kmalloc_array(AK::Checked<size_t> a, AK::Checked<size_t> b, AK::Checked<size_t> c)
AK: Add kmalloc_array() to trap multiplication overflows This pattern is no good: kmalloc(elements * sizeof(T)); Since it silently swallows any multiplication overflow. This patch adds a simple kmalloc_array() that stops the program if overflow occurs: kmalloc_array(elements, sizeof(T));
2021-08-07 20:32:45 +00:00
{
auto size = a * b * c;
VERIFY(!size.has_overflow());
return kmalloc(size.value());
}
Reference in a new issue Copy permalink