Fix remaining dead links

blog/content/first-edition/posts/04-printing-to-screen/index.md

@@ -89,7 +89,7 @@ pub enum Color {
 ```
 We use a [C-like enum] here to explicitly specify the number for each color. Because of the `repr(u8)` attribute each enum variant is stored as an `u8`. Actually 4 bits would be sufficient, but Rust doesn't have an `u4` type.
 
-[C-like enum]: http://rustbyexample.com/custom_types/enum/c_like.html
+[C-like enum]: https://doc.rust-lang.org/rust-by-example/custom_types/enum/c_like.html
 
 Normally the compiler would issue a warning for each unused variant. By using the `#[allow(dead_code)]` attribute we disable these warnings for the `Color` enum.
 
@@ -142,7 +142,7 @@ pub struct Writer {
 ```
 The writer will always write to the last line and shift lines up when a line is full (or on `\n`). The `column_position` field keeps track of the current position in the last row. The current foreground and background colors are specified by `color_code` and a pointer to the VGA buffer is stored in `buffer`. To make it possible to create a `static` Writer later, the `buffer` field stores an `Unique<Buffer>` instead of a plain `*mut Buffer`. [Unique] is a wrapper that implements Send/Sync and is thus usable as a `static`. Since it's unstable, you may need to add the `unique` feature to `lib.rs`:
 
-[Unique]: https://doc.rust-lang.org/nightly/core/ptr/struct.Unique.html
+[Unique]: https://doc.rust-lang.org/1.10.0/core/ptr/struct.Unique.html
 
 ```rust
 // in src/lib.rs
@@ -210,7 +210,7 @@ The reason it that Rust _moves_ values by default instead of copying them like o
 To fix it, we can implement the [Copy] trait for the `ColorCode` type. The easiest way to do this is to use the built-in [derive macro]:
 
 [Copy]: https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html
-[derive macro]: http://rustbyexample.com/trait/derive.html
+[derive macro]: https://doc.rust-lang.org/rust-by-example/custom_types/enum/c_like.html
 
 ```rust
 #[derive(Debug, Clone, Copy)]

blog/content/first-edition/posts/09-handling-exceptions/index.md

@@ -274,7 +274,7 @@ This error occurs because the `x86-interrupt` calling convention is still unstab
 ### Loading the IDT
 In order that the CPU uses our new interrupt descriptor table, we need to load it using the [`lidt`] instruction. The `Idt` struct of the `x86_64` provides a [`load`][Idt::load] method function for that. Let's try to use it:
 
-[`lidt`]: http://x86.renejeschke.de/html/file_module_x86_id_156.html
+[`lidt`]: https://www.felixcloutier.com/x86/lgdt:lidt
 [Idt::load]: https://docs.rs/x86_64/0.1.1/x86_64/structures/idt/struct.Idt.html#method.load
 
 ```rust

blog/content/first-edition/posts/10-double-faults/index.md

@@ -136,7 +136,7 @@ First Exception | Second Exception
 [Page Fault]: http://wiki.osdev.org/Exceptions#Page_Fault
 
 
-[AMD64 manual]: http://developer.amd.com/wordpress/media/2012/10/24593_APM_v21.pdf
+[AMD64 manual]: https://www.amd.com/system/files/TechDocs/24593.pdf
 
 So for example a divide-by-zero fault followed by a page fault is fine (the page fault handler is invoked), but a divide-by-zero fault followed by a general-protection fault leads to a double fault.
 
@@ -357,7 +357,7 @@ impl MemoryController {
 The `MemoryController` struct holds the three types that are required for `alloc_stack` and provides a simpler interface (only one argument). The `alloc_stack` wrapper just takes the tree types as `&mut` through [destructuring] and forwards them to the `stack_allocator`. The [ref mut]-s are needed to take the inner fields by mutable reference. Note that we're re-exporting the `Stack` type since it is returned by `alloc_stack`.
 
 [destructuring]: https://doc.rust-lang.org/1.10.0/book/patterns.html#destructuring
-[ref mut]: http://rust-lang.github.io/book/ch18-00-patterns.html#ref-and-ref-mut
+[ref mut]: https://doc.rust-lang.org/1.30.0/book/second-edition/ch18-03-pattern-syntax.html#creating-references-in-patterns-with-ref-and-ref-mut
 
 The last step is to create a `StackAllocator` and return a `MemoryController` from `memory::init`:
 
@@ -496,7 +496,7 @@ We define that the 0th IST entry is the double fault stack (any other IST index
 Now that we created a new TSS, we need a way to tell the CPU that it should use it. Unfortunately, this is a bit cumbersome, since the TSS is a Task State _Segment_ (for historical reasons). So instead of loading the table directly, we need to add a new segment descriptor to the [Global Descriptor Table] \(GDT). Then we can load our TSS invoking the [`ltr` instruction] with the respective GDT index.
 
 [Global Descriptor Table]: http://www.flingos.co.uk/docs/reference/Global-Descriptor-Table/
-[`ltr` instruction]: http://x86.renejeschke.de/html/file_module_x86_id_163.html
+[`ltr` instruction]: https://www.felixcloutier.com/x86/ltr
 
 ### The Global Descriptor Table (again)
 The Global Descriptor Table (GDT) is a relict that was used for [memory segmentation] before paging became the de facto standard. It is still needed in 64-bit mode for various things such as kernel/user mode configuration or TSS loading.