kernel: Implement realloc_etc and make use of it.

kernel: Do not invoke memalign with 0 as the alignment argument.

The memalign() function has special semantics for its arguments
even when -fno-builtin is enabled, it seems (that may be a problem
on Clang's part, however.) The alloc_align attribute, which we apply
to the memalign_etc function, does not seem to have the same problems;
at least its documentation at GCC gives no indication that 0 is not a
legal value to pass.

Change-Id: Ie5ba090b924ac3577775165d20f11f9696be97f3

kernel/guarded_heap: Add stack traces to allocations command.

This allows dumping the allocation stack traces in the more powerful
allocations command with the optional "trace" argument. The stack trace
could previously only be dumped manually by inspecting individual
guarded heap pages.

kernel guarded heap: Implement allocations debugger command.

It can be used to dump the current heap allocations with their details
and stack traces if enabled.

kernel guarded heap: Also store team id for allocations.

guarded_heap: fix build (volatile + atomic ops)

Unfortunately, the package manager uses more kernel memory and it's not
possible to boot to the desktop with the guarded heap anymore.

Fix the page need calculation, it was possibly off by one.

Add more debugger commands to closer inspect the guarded heap.

Try smaller sizes if creating an area failed.

Depending on the use case the grow size may be too large to fit into
address space holes. Instead of failing try with smaller sizes until
it either worked or doesn't make sense anymore (< 1MB).

Use a free list to make the guarded heap perform less horribly.

Pages that are freed are added to the tail of the list while allocation
candidates are taken from the head. Therefore pages that have been free
the longest are preferred, making immediate re-use less likely.

Also avoid looking for pages if the free count already tells that the
allocation can't be fulfilled.

Allow replacing the object cache with the guarded heap.

This allows to use the debug features of the guarded heap also on
allocations made through the object cache API. This is obivously
horrible for performance and uses up huge amounts of memory, so the
initial and grow sizes are adjusted accordingly.

Note that this is a rather simple hack, using the object_cache pointer
to transport the allocation size. The alignment is neglected completely.

Add support for optional inline stack traces in guarded heap.

Add heap with guard pages to detect out of bound reads/writes.

This is a very simple heap implementation that allocates memory so that
the end of each allocation always coincides with a page end and is
followed by a guard page which is marked non-present. Out of bounds
access (both read and write) therefore cause a crash (unhandled page
fault).

Note that this allocator is neither speed nor space efficient, indeed it
wastes huge amounts of pages and address space so it is quite easy to
hit limits. It is intended as a pure debug feature.

kernel guarded heap: Implement allocations debugger command.

It can be used to dump the current heap allocations with their details
and stack traces if enabled.

kernel guarded heap: Also store team id for allocations.

guarded_heap: fix build (volatile + atomic ops)

Unfortunately, the package manager uses more kernel memory and it's not
possible to boot to the desktop with the guarded heap anymore.

Fix the page need calculation, it was possibly off by one.

Add more debugger commands to closer inspect the guarded heap.

Try smaller sizes if creating an area failed.

Depending on the use case the grow size may be too large to fit into
address space holes. Instead of failing try with smaller sizes until
it either worked or doesn't make sense anymore (< 1MB).

Use a free list to make the guarded heap perform less horribly.

Pages that are freed are added to the tail of the list while allocation
candidates are taken from the head. Therefore pages that have been free
the longest are preferred, making immediate re-use less likely.

Also avoid looking for pages if the free count already tells that the
allocation can't be fulfilled.

Allow replacing the object cache with the guarded heap.

This allows to use the debug features of the guarded heap also on
allocations made through the object cache API. This is obivously
horrible for performance and uses up huge amounts of memory, so the
initial and grow sizes are adjusted accordingly.

Note that this is a rather simple hack, using the object_cache pointer
to transport the allocation size. The alignment is neglected completely.

Add support for optional inline stack traces in guarded heap.

Add heap with guard pages to detect out of bound reads/writes.

This is a very simple heap implementation that allocates memory so that
the end of each allocation always coincides with a page end and is
followed by a guard page which is marked non-present. Out of bounds
access (both read and write) therefore cause a crash (unhandled page
fault).

Note that this allocator is neither speed nor space efficient, indeed it
wastes huge amounts of pages and address space so it is quite easy to
hit limits. It is intended as a pure debug feature.