When inserting, look through the full hash chain before adding a new
entry, this fixes double insertion of the same key when there were a
hash collision
Instead of storing used and removed bits, store 2 bit state. This makes
the code cleaner and easier to not make mistakes
Initial step of paging now just prepares fast page for heap, actual page
table initialization happens after heap is initialized which allows
x86_64 to never depend on kmalloc for pages.
Processor's stacks are now also spawned with PMM/VMM allocated stacks
instead of kmalloc identity mapped.
ca-certificates:
- update to 2026.03.19
- install to /etc/cacert
- extract individual ceritificates from the bundle
openssl:
- depend on ca-certificates
- install hashed symlinks to individual certs
curl:
- don't depend on ca-certificates; openssl handles this
- set both ca-bundle and ca-path
There is no need for them to be uncached. Having them as uncached killed
the networking performance, over 90% time was spent in kernel out of
which 80% was in checksum calculation and memcpy, half each (measured in
qemu with e1000e)
Add a concept for HashMapFindable instead of manually specifying the
requries expression everywhere.
Allow HashMapFindable also for `remove`, `contains`, `operator[]`, `at`
Make Entry have a const Key. This allows iterator's operator* and
operator-> return values have const keys.
Add a concept for HashSetFindable instead of manually specifying the
requries expression everywhere.
Allow HashSetFindable also for `remove` and `contains`.
Remove non-const return values from iterator; you should never modify
the hashed value in place.
Don't require key to be move assignable, move construction is enough.
There is really no need to have two implementation of the same thing.
Only difference now is that HashMap's value type has to be movable but
this wasn't an issue
Instead of representing the map as vector or linked lists which required
an allocation for every insertion and deallocation for removal, we now
store a single big contiguous block of memory and use hash chains to
handle collisions. This intuitively feels much better although I did not
run any benchmarks.
I don't know why I though the block chain had to be stored fully in the
ThreadBlocker, that did not even fix the problem I was trying to fix
when I last rewrote it. Roll back to doubly linked list of block chain
and now just check that the node is contained within the ThreadBlocker
before removing and after acquiring the ThreadBlocker's lock. Also there
is no need to have a separate lock the node's blocker field. We can just
perform an atomic reads and writes to it. We can still get a blocker
that the node is no longer part of, but this can be resolved with a
simple check. This patch reduces ThreadBlocker's size from over 200
bytes to just 12 bytes +4 bytes padding
This generates much nicer assembly as it does not have to read thread
pointer for every access to TCB (errno, cancel_state, cancelled) and
instead it can read it once and use the same value for all accesses
