Merge pull request #761 from Mutated1994/patch-7

feat: Add some code snippets

Booting/linux-bootstrap-3.md

@@ -515,13 +515,31 @@ It takes two parameters:
 
 Let's look inside `protected_mode_jump`. As I wrote above, you can find it in `arch/x86/boot/pmjump.S`. The first parameter will be in the `eax` register and the second one is in `edx`.
 
-First of all, we put the address of `boot_params` in the `esi` register and the address of the code segment register `cs` in `bx`. After this, we shift `bx` by 4 bits and add it to the memory location labeled `2` (which is `(cs << 4) + in_pm32`, the physical address to jump after transitioned to 32-bit mode) and jump to label `1`. So after this `in_pm32` in label `2` will be overwritten with `(cs << 4) + in_pm32`.
+First of all, we put the address of `boot_params` in the `esi` register and the address of the code segment register `cs` in `bx`. 
+
+```assembly
+GLOBAL(protected_mode_jump)
+	movl	%edx, %esi	# Pointer to boot_params table
+
+	xorl	%ebx, %ebx
+	movw	%cs, %bx
+```
+
+After this, we shift `bx` by 4 bits and add it to the memory location labeled `2` (which is `(cs << 4) + in_pm32`, the physical address to jump after transitioned to 32-bit mode) and jump to label `1`. 
+
+```assembly
+	shll	$4, %ebx
+	addl	%ebx, 2f 	# Add %ebx to the value stored at label 2
+	jmp	1f		# Short jump to serialize on 386/486
+```
+
+So after this `in_pm32` in label `2` will be overwritten with `(cs << 4) + in_pm32`.
 
 Next we put the data segment and the task state segment in the `cx` and `di` registers with:
 
 ```assembly
-movw	$__BOOT_DS, %cx
-movw	$__BOOT_TSS, %di
+	movw	$__BOOT_DS, %cx
+	movw	$__BOOT_TSS, %di
 ```
 
 As you can read above `GDT_ENTRY_BOOT_CS` has index 2 and every GDT entry is 8 byte, so `CS` will be `2 * 8 = 16`, `__BOOT_DS` is 24 etc.
@@ -529,9 +547,9 @@ As you can read above `GDT_ENTRY_BOOT_CS` has index 2 and every GDT entry is 8 b
 Next, we set the `PE` (Protection Enable) bit in the `CR0` control register:
 
 ```assembly
-movl	%cr0, %edx
-orb	$X86_CR0_PE, %dl
-movl	%edx, %cr0
+	movl	%cr0, %edx
+	orb	$X86_CR0_PE, %dl
+	movl	%edx, %cr0
 ```
 
 and make a long jump to protected mode:

Booting/linux-bootstrap-4.md

@@ -336,9 +336,7 @@ ENTRY(startup_32)
 #define __HEAD		.section	".head.text","ax"
 ```
 
-Here, `.head.text` is the name of the section and `ax` is a set of flags. In our case, these flags show us that this section is [executable](https://en.wikipedia.org/wiki/Executable
-
-In simple terms, this means that a Linux kernel with this option set can be booted from different addresses. Technically, this is done by compiling the decompressor as [position independent code](https://en.wikipedia.org/wiki/Position-independent_code). If we look at [arch/x86/boot/compressed/Makefile](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/compressed/Makefile), we can see that the decompressor is indeed compiled with the `-fPIC` flag:
+Here, `.head.text` is the name of the section and `ax` is a set of flags. In our case, these flags show us that this section is [executable](https://en.wikipedia.org/wiki/Executable). In simple terms, this means that a Linux kernel with this option set can be booted from different addresses. Technically, this is done by compiling the decompressor as [position independent code](https://en.wikipedia.org/wiki/Position-independent_code). If we look at [arch/x86/boot/compressed/Makefile](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/compressed/Makefile), we can see that the decompressor is indeed compiled with the `-fPIC` flag:
 
 ```Makefile
 KBUILD_CFLAGS += -fno-strict-aliasing -fPIC

DataStructures/linux-datastructures-2.md

@@ -61,11 +61,11 @@ This structure presents the root of a radix tree and contains three fields:
 
 The first field we will discuss is `gfp_mask`:
 
-Low-level kernel memory allocation functions take a set of flags as - `gfp_mask`, which describes how that allocation is to be performed. These `GFP_` flags which control the allocation process can have following values: (`GFP_NOIO` flag) means sleep and wait for memory, (`__GFP_HIGHMEM` flag) means high memory can be used, (`GFP_ATOMIC` flag) means the allocation process has high-priority and can't sleep etc.
+Low-level kernel memory allocation functions take a set of flags as - `gfp_mask`, which describes how that allocation is to be performed. These `GFP_` flags which control the allocation process can have following values: (`GFP_NOIO` flag) means allocation can block but must not initiate disk I/O; (`__GFP_HIGHMEM` flag) means either ZONE_HIGHMEM or ZONE_NORMAL memory can be used; (`GFP_ATOMIC` flag) means the allocation is high-priority and must not sleep, etc.
 
-* `GFP_NOIO` - can sleep and wait for memory;
-* `__GFP_HIGHMEM` - high memory can be used;
-* `GFP_ATOMIC` - allocation process is high-priority and can't sleep;
+* `GFP_NOIO` - allcation can block but must not initiate disk I/O;
+* `__GFP_HIGHMEM` - either ZONE_HIGHMEM or ZONE_NORMAL can be used;
+* `GFP_ATOMIC` - allocation process is high-priority and must not sleep;
 
 etc.