Quote: it may require two memory accesses (one to write dirty data main memory, and another to load the new data).

I don't really get what "load the new data" is for? Thank you

"Imagine a file in the context something"
->
"Imagine a file in the context of something"

"a file is a good abstraction of either a a sink for"
->
"a file is a good abstraction of either a sink for"

"with a car that had it's bonnet welded shut"

->

"with a car that had its bonnet welded shut"

As probably not anyone is able to create environment (HW/SW constraints, time constraints, knowledge constraints) to build files for books (.pdf, .html, .epub) it would be great it they would be published as a github's release.

Commonly we call the "fast" routine the top half. For example in this article: https://www.oreilly.com/library/view/linux-device-drivers/0596000081/ch09s05.html

For example, on IA64 a function descriptor consists of two components; the address of the function (that being a 64 bit, or 8 byte value) and the address of the global pointer (gp). The ABI specifies that r1 should always contain the gp value for a function. This means that when you call a function, it is the callees job to save their gp value, set r1 to be the new value (from the function descriptor) and then call the function.

In the above paragraph, it should be written that it is the caller's job to save the gp value[source]. Continuing, I think the word call should be formatted instead of the current then.

What an amazing project! Came across it on the web and thought you might appreciate these small corrections to the part I scanned - Operating System Organisation.

- it is the operating systems job arbitrate between multiple programs
+ it is the operating system's job to arbitrate between multiple programs

- if any internal part of the operating system crashes chances are
+ if any internal part of the operating system crashes, chances are

- the whole system has the potential to comes to a halt
+ the whole system has the potential to come to a halt

- If one driver has a bug it can overwrite any memory
+ If one driver has a bug, it can overwrite any memory

- In a monolithic kernel calls between components
+ In a monolithic kernel, calls between components

- where drivers can loaded into the running kernel 
+ where drivers can be loaded into the running kernel 

- often it is useful to not thing of them as
+ often it is useful to not think of them as

? possible ?
- looks for all intents and purposes as a completely separate machine
+ looks for all intents and purposes like a completely separate machine

? possible ?
-  have the operating system aware of the underlying hypervisor
+  have the operating system be aware of the underlying hypervisor

- similar to the way early versions of the Xen system works
+ similar to the way early versions of the Xen system work

- as what was once fast operations directly on hardware
+ as what were once fast operations directly on hardware

- when that application makes requests for resources that might be shared between other guest operating systems the virtual machine monitor can be invoked
+ when that application makes requests for resources that might be shared between other guest operating systems, the virtual machine monitor can be invoked

- whilst admittedly far fetched there have been examples
+ whilst admittedly far-fetched, there have been examples

- We call the theoretical place where programs run by the user userspace.
+ We call the theoretical place where programs are run by the user userspace.

There are several places where the complete diagram isn't shown in the pdf format of the book compared to the website.

For instance:

##Figure 3.2 Abstraction

PDF

Website

There are many more like this

Consider the scientific notation representation of the value 198765. We could write this as 1.98765x10^6

This should be 1.98765 * 10^5, rather than 1.98765 * 10^6

I'd love to see an epub/mobi version of this work so I can read it on my Kindle. I had a look at the Makefile, but found that I'm not familiar at all with any of the tools used. Theoretically, you should be able to use a variation of your html publishing task and point pandoc at it to get an epub version.

double word: a a
https://github.com/ianw/bottomupcs/blob/master/input/chapter00/chapter00.xml
line 49.

My Firefox 43.0.4 browser detects the HTML pages as having Western encoding instead of Unicode. As such, on index.html there are unwanted "Â" characters that appear. After forcing the encoding in the webbrowser to Unicode the pages render correctly (the unwanted "Â" characters disappear).

I checked the HTML source code and I saw that there are hints that the document is in UTF-8 format, but they're not enough for browsers to correctly detect the encoding:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

There should be a tag to specify the encoding in the tag:

<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

"Firstly we compile or library" -> our http://www.bottomupcs.com/libraries.xhtml
"a copy in it's executable" -> its
ABI's -> ABIs http://www.bottomupcs.com/abi.xhtml (Technically you shouldn't use an apostrophe though many do).
"Thus when the program starts it can use it's stack pointer" -> its
"Looking at the disassembley of this function" -> disassembly http://www.bottomupcs.com/starting_a_process.xhtml

Consider a 64-bit address space divided into (generously large) 64 KiB pages creates 2^64/2^16 = 2^52 pages to be managed; assuming each page requires an 8-byte pointer to a physical location a total of 2^52/2^3 = 2^49 or 512 GiB of contiguous memory is required just for the page table!

If there are 2^52 page table entries and each one holds an 8-byte address, shouldn't the total memory consumed by the page table be 2^52 * 2^3 = 2^55 instead of 2^49? Sorry, if this sounds dumb, but am I missing something?

Higher nice value means lower priority.

Quote: "all stores have release semantics (that is, the result of a store is guaranteed to be seen by any later load or store) but all loads have normal semantics. "

From ARM V8 programmer guide:
"A store-release ensures that all earlier memory accesses are visible before the store-release becomes visible. "

I like this "CSBU" book but feel disappointed that the 10th chapter "I/O Fundamentals" hasn't been released yet, is it still in progress, what's the expected release date?

https://github.com/ianw/bottomupcs/blob/master/input/chapter00/chapter00.xml
line 106:
"database queries and data transfer; all of which is opaque to"

• i would change semicolon to comma;
• 'is' should be 'are'.