I am learning about operating systems and there are two things I would like to know.
Assuming that the address space division is 1/3 gb (1gb for the kernel and 3gb for the process).
I would be very grateful if the answer is detailed, but explained so that someone (me) who is in his first year of computer science can understand it. Thanks!
The kernel does not need to use a lot of memory, but it needs to have a mapping from virtual addresses to physical memory. When paging is enabled on the processor, the only way to access memory is through the paging mechanism, i.e. the addresses the CPU instructions use are virtual addresses, not physical addresses. The kernel mapping is needed for the the kernel to be able to access any part of physical memory, for example to zero pages before mapping them into the process's address space.
When Linux was designed in the early 1990s, it was targeted to run on the 80386, which offered a 32-bit virtual address space. However, the typical PC at that time didn't have more than 8 megabytes of physical memory. The kernel was designed to create a 1:1 mapping where the virtual address 0xC0000000 points to physical address 0, the virtual address 0xC0001000 points to physical address 0x1000, and so on, until the end of physical memory. The kernel's code and data use part of this address space, but most of the memory are "free" pages that can be allocated to processes.
The process address space in this model is mapped to the address space below 3 GB. Several mappings to the same physical memory pages can coexist. A memory page allocated to a running process has at least two mappings, the "kernel view" described above, and the "process view", which uses addresses below the 3 GB mark.
When PCs were shipped with increasing amounts of RAM, the (originally luxurious) 1 GB kernel space got cramped, so all kinds of stopgap solutions were introduced. For example, we got the 2 GB + 2 GB split, which allowed for 2 GB of RAM, but at the same time limited the process address space to 2 GB. The "final" solution was of course moving to 64-bit processors, which has solved the problem for the time being.
Assuming that the address space division is 1/3 gb (1gb for the kernel and 3gb for the process).
But that's not the case. There's no static address space division like that on a machine that can run Linux – quite the contrary, the virtual address spaces that processes and that the kernel uses can be (relatively) arbitrary.
Notice that I said "virtual address spaces", plural: different processes and the kernel all have a different "view" on physical address space, which itself isn't linear. So, I'm not sure where that boundary would come from.
What happens if the kernel needs to use more than 1gb?
Allocate more than 1 GB.
At boot time, if there is no process, how is the kernel mapped?
At boot time, it's the kernel that enables (depending on the CPU architecture you're using) memory protection, and starts mapping its own memory space. It actively randomizes that mapping – KASLR.
I'm not sure why you think anything is special about 1 GB. It isn't! The kernel maps its memory as needed.
Are you perhaps referring to a limitation of the nearly-died out 32 bit i386 architecture? In earlier versions of Linux, there was, in the kernel address space, a constant mapping below PAGE_OFFSET (which IIRC was indeed at 1 GB?), above which userspace memory spaces might have been "mapped in".
So, whatever material you're learning this from: Needs to be updated, and is definitely predating https://en.wikipedia.org/wiki/Kernel_page-table_isolation .
