RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 17:28:11 +00:00
Code Issues Activity Actions

LibC: Convert dbgprintf() => dbgln()

Browse source
This commit is contained in:
Andreas Kling 2021-02-17 15:39:32 +01:00
parent 5a595ef134
commit dffab4e034
4 changed files with 13 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Userland/Libraries/LibC/assert.cpp
View file

@ -24,6 +24,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <AK/Format.h>
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -38,9 +39,9 @@ extern bool __stdio_is_initialized;
#ifdef DEBUG #ifdef DEBUG
void __assertion_failed(const char* msg) void __assertion_failed(const char* msg)
{ {
dbgprintf("USERSPACE(%d) ASSERTION FAILED: %s\n", getpid(), msg); dbgln("USERSPACE({}) ASSERTION FAILED: {}", getpid(), msg);
if (__stdio_is_initialized) if (__stdio_is_initialized)
fprintf(stderr, "ASSERTION FAILED: %s\n", msg); warnln("ASSERTION FAILED: {}", msg);
Syscall::SC_set_coredump_metadata_params params { Syscall::SC_set_coredump_metadata_params params {
{ "assertion", strlen("assertion") }, { "assertion", strlen("assertion") },

26
Userland/Libraries/LibC/malloc.cpp
View file

@ -171,7 +171,7 @@ static void* malloc_impl(size_t size)
LOCKER(malloc_lock()); LOCKER(malloc_lock());
if (s_log_malloc) if (s_log_malloc)
dbgprintf("LibC: malloc(%zu)\n", size); dbgln("LibC: malloc({})", size);
if (!size) if (!size)
return nullptr; return nullptr;
@ -259,15 +259,11 @@ static void* malloc_impl(size_t size)
block->m_freelist = block->m_freelist->next; block->m_freelist = block->m_freelist->next;
if (block->is_full()) { if (block->is_full()) {
g_malloc_stats.number_of_blocks_full++; g_malloc_stats.number_of_blocks_full++;
#if MALLOC_DEBUG dbgln_if(MALLOC_DEBUG, "Block {:p} is now full in size class {}", block, good_size);
dbgprintf("Block %p is now full in size class %zu\n", block, good_size);
#endif
allocator->usable_blocks.remove(block); allocator->usable_blocks.remove(block);
allocator->full_blocks.append(block); allocator->full_blocks.append(block);
} }
#if MALLOC_DEBUG dbgln_if(MALLOC_DEBUG, "LibC: allocated {:p} (chunk in block {:p}, size {})", ptr, block, block->bytes_per_chunk());
dbgprintf("LibC: allocated %p (chunk in block %p, size %zu)\n", ptr, block, block->bytes_per_chunk());
#endif
if (s_scrub_malloc) if (s_scrub_malloc)
memset(ptr, MALLOC_SCRUB_BYTE, block->m_size); memset(ptr, MALLOC_SCRUB_BYTE, block->m_size);
@ -318,9 +314,7 @@ static void free_impl(void* ptr)
assert(magic == MAGIC_PAGE_HEADER); assert(magic == MAGIC_PAGE_HEADER);
auto* block = (ChunkedBlock*)block_base; auto* block = (ChunkedBlock*)block_base;
#if MALLOC_DEBUG dbgln_if(MALLOC_DEBUG, "LibC: freeing {:p} in allocator {:p} (size={}, used={})", ptr, block, block->bytes_per_chunk(), block->used_chunks());
dbgprintf("LibC: freeing %p in allocator %p (size=%zu, used=%zu)\n", ptr, block, block->bytes_per_chunk(), block->used_chunks());
#endif
if (s_scrub_free) if (s_scrub_free)
memset(ptr, FREE_SCRUB_BYTE, block->bytes_per_chunk()); memset(ptr, FREE_SCRUB_BYTE, block->bytes_per_chunk());
@ -332,9 +326,7 @@ static void free_impl(void* ptr)
if (block->is_full()) { if (block->is_full()) {
size_t good_size; size_t good_size;
auto* allocator = allocator_for_size(block->m_size, good_size); auto* allocator = allocator_for_size(block->m_size, good_size);
#if MALLOC_DEBUG dbgln_if(MALLOC_DEBUG, "Block {:p} no longer full in size class {}", block, good_size);
dbgprintf("Block %p no longer full in size class %zu\n", block, good_size);
#endif
g_malloc_stats.number_of_freed_full_blocks++; g_malloc_stats.number_of_freed_full_blocks++;
allocator->full_blocks.remove(block); allocator->full_blocks.remove(block);
allocator->usable_blocks.prepend(block); allocator->usable_blocks.prepend(block);
@ -346,9 +338,7 @@ static void free_impl(void* ptr)
size_t good_size; size_t good_size;
auto* allocator = allocator_for_size(block->m_size, good_size); auto* allocator = allocator_for_size(block->m_size, good_size);
if (allocator->block_count < number_of_chunked_blocks_to_keep_around_per_size_class) { if (allocator->block_count < number_of_chunked_blocks_to_keep_around_per_size_class) {
#if MALLOC_DEBUG dbgln_if(MALLOC_DEBUG, "Keeping block {:p} around for size class {}", block, good_size);
dbgprintf("Keeping block %p around for size class %zu\n", block, good_size);
#endif
g_malloc_stats.number_of_keeps++; g_malloc_stats.number_of_keeps++;
allocator->usable_blocks.remove(block); allocator->usable_blocks.remove(block);
allocator->empty_blocks[allocator->empty_block_count++] = block; allocator->empty_blocks[allocator->empty_block_count++] = block;
@ -356,9 +346,7 @@ static void free_impl(void* ptr)
madvise(block, ChunkedBlock::block_size, MADV_SET_VOLATILE); madvise(block, ChunkedBlock::block_size, MADV_SET_VOLATILE);
return; return;
} }
#if MALLOC_DEBUG dbgln_if(MALLOC_DEBUG, "Releasing block {:p} for size class {}", block, good_size);
dbgprintf("Releasing block %p for size class %zu\n", block, good_size);
#endif
g_malloc_stats.number_of_frees++; g_malloc_stats.number_of_frees++;
allocator->usable_blocks.remove(block); allocator->usable_blocks.remove(block);
--allocator->block_count; --allocator->block_count;

4
Userland/Libraries/LibC/stdio.cpp
View file

@ -1194,12 +1194,12 @@ int vfscanf(FILE* stream, const char* fmt, va_list ap)
void flockfile([[maybe_unused]] FILE* filehandle) void flockfile([[maybe_unused]] FILE* filehandle)
{ {
dbgprintf("FIXME: Implement flockfile()\n"); dbgln("FIXME: Implement flockfile()");
} }
void funlockfile([[maybe_unused]] FILE* filehandle) void funlockfile([[maybe_unused]] FILE* filehandle)
{ {
dbgprintf("FIXME: Implement funlockfile()\n"); dbgln("FIXME: Implement funlockfile()");
} }
FILE* tmpfile() FILE* tmpfile()

2
Userland/Libraries/LibC/unistd.cpp
View file

@ -673,7 +673,7 @@ void sysbeep()
int fsync([[maybe_unused]] int fd) int fsync([[maybe_unused]] int fd)
{ {
dbgprintf("FIXME: Implement fsync()\n"); dbgln("FIXME: Implement fsync()");
return 0; return 0;
} }