Generate docs for libs, update docs build process

docs/building_kernel.md

@@ -14,31 +14,18 @@ This article describes, how to build the kernel, how the build system works and
 
 cd into root of MOP3 source tree.
 
-Build the kernel:
+Run:
 ```
-make -B all_kernel buildtype=<debug|release>
+./aux/devel.sh
 ```
 
-Build essential system applications:
+This script does everything for you - builds the kernel, userspace apps, necessary libraries and such.
+The buildsystem is quite compilcated, so it probably requires it's own article.
+
+For debugging you can do:
 ```
-make -B all_apps
+./aux/devel.sh debug
 ```
 
-Prepare the ramdisk:
-```
-make -B all_dist
-```
-
-Build ISO image:
-```
-./aux/limine_iso_amd64.sh
-```
-
-Now you have an ISO image, which can be run my QEMU or you can burn it onto a CD.
-
-For the convenience of the developer, there's a magic "do all" script located in `aux`:
-```
-./aux/devel.sh # optionally "./aux/devel.sh debug" for debugging
-```
-
-It does all the previous steps, just packed into a single script.
+This will build with `buildtype=debug` as opposed to `buildtype=release`. You now can view symbols inside
+of gdb or objdump.

docs/processes_overview.md

@@ -2,24 +2,15 @@
 
 ## What is a process?
 
-A process is a structure defined to represent an internal state of a user application's environment. This includes
-the necessary stacks, code, data and other resources. A process (usually) has it's own address, but in certain
-circumstances may share it with another process.
+A process represents a piece of executing code, has it's own stack and CPU state. Think of it as a "task". There are no
+kernel processes, only userspace processes.
 
-## Only processes vs. processes-threads model
+A process must be a member of a broader process group or procgroup for short.
 
-### Overview
+## Procgroups
 
-MOP3 doesn't have a process-thread separation. Ususally in operating systems you'd have a "process", which consists
-of multiple worker threads. For eg. a single-threaded application is a process, which consists of one worker. In MOP3
-we do things a little differently. We only have processes, but some processes may work within the same pool of (generally speaking)
-"resources", such as a shared address space, shared memory allocations, mutexes and so on. An application then consists of
-not threads, but processes, which are loosely tied together via shared data.
-
-#### Processes-threads model diagram
-![Processes-threads model](assets/images/processes-threads.png)
-#### Only processes model diagram
-![Only processes model](assets/images/only-processes.png)
+A procgroup owns things like memory, kernel resources and such. Processes work within the scope of a procgroup. Once all
+procgroup's members die, the procgroup is considered unreachable and thus cleaned up.
 
 ## Scheduling