Errata

"The bi_size field is set to the number of sectors covering the data."
But the bi_size field should be (as also pointed out in the table of fields) the number of bytes, not sectors.

The rounded box labeled "gdt or ldt" has two incoming arrows on the left. The lower arrow should be deleted.

The first box linked to index 199 of the hash table reads "PID 199". In the text on the preceding page (Page 93), it is stated that "[...] The processes having PIDs 2,890 and 29,384 hash into the 200th element of the table, [...]"

So the aforementioned box on Page 94 should read "PID 2890" instead.

The final sentence in the paragraph states "[...] while the process having PID 29,385 hashes into the 1,466th element of the table."

Looking at Figure 3-5, the process whose PID is 29,385 hashes into index 1466 in the hash table. That is actually the 1467th element. And that would make the sentence in question consistent with the description of PIDs 2,890 and 29,384 hashing into the 200th element whose index in Figure 3-5 is 199.

Text:

"The modules_which_use_me field of the module object of A is the head of a dependency list containing all modules that are used by A"

"all modules that are used by A" should be "all modules that use A".

Step 3: "If some timer interrupt has been lost (...), the function adds to usec the corresponding delay."

-> Why is this necessary? Step 2 says "Determines the number of microseconds elapsed since the last timer interrupt" and e.g., "compares the current value of the HPET counter with the value of the same counter saved in the last execution of the timer interrupt handler". If the timer interrupt was lost, the timer interrupt handler was not executed, so the time should already be inclued in the count?

Step 5: "Copies the contents of xtime into the user-space buffer specified by the system call parameter tv, adding to the microsends field the value of usec:
tv->tv_sec = xtime->tv_sec;
tv->tv_usec = xtime->tv_usec + usec;"

1) xtime is not a pointer; also step 4 uses xtime.tv_nsec, not xtime->tv_nsec.
2) xtime is of type timespec, and it has fields tv_sec and tv_nsec, there's no tv_usec in it.

-> Is this step supposed to use some 'timeval' (not 'timespec') variable instead of xtime?

Or is it supposed to be:
tv->tv_sec = xtime.tv_sec;
tv->tv_usec = usec;

(We've already added xtime.tv_nsec / 1000 to usec in step 4.)

The text says: "Then, the function checks the value of the done flag: if it's equal to zero the function terminates, otherwise, the current process is suspended again."

Isn't this the wrong way around; done > 0 means complete() has been called, so wait_for_completion() can return?

Previously in the same paragraph: "[...] and checks the value of the done flag. If it's greater than zero, wait_for_completion() terminates, becaues complete() has already been executed on another CPU."

The described algorithm sets break_lock to 1, but it never sets it back to 0. Shouldn't it be set back to 0 between steps 6 and 7 (after the wait cycle)?

"...The segment identifier is a 16-bit field called the Segment Selector (see Figure 2-2), while the offset is a 32-bit field..."

offset is a 16-bit field as well

Page Global Directory should be changed to Page Upper Directory in the following sentence:
The PUD_SIZE macro computes the size of the area mapped by a single
entry of the Page Global Directory.

Upper Air fields should also be removed from the following sentence:
The PUD_MASK macro is used to mask all the bits of the Offset, Table, Middle Air, and Upper Air fields.

The send error is already found by an anonymous guy on Jun 27, 2015 and listed in the unconfirmed errata.

The following is the origin text:

The correct form for the second statement might therefore look like:
io_mem = ioremap(0xfb000000, 0x200000);
t2 = *((unsigned char *)(io_mem + 0x100000));
The first statement creates a new 2 MB linear address interval, which maps physical addresses starting from 0xfb000000; the second one reads the memory location that has the 0xfc000000 address. To remove the mapping later, the device driver must use the iounmap( ) function.

The following is my trouble:

I think the right text is:
The correct form for the second statement might therefore look like:
io_mem = ioremap(0xfb000000, 0x2000000);
t2 = *((unsigned char *)(io_mem + 0x1000000));
The first statement creates a new 32 MB linear address interval, which maps physical addresses starting from 0xfb000000; the second one reads the memory location that has the 0xfc000000 address. To remove the mapping later, the device driver must use the iounmap( ) function.

the following is my reason:
if the second parameter of ioremap function is 0x200000,the physical address can't get to 0xfc000000 as (0xfb000000+0x200000-1)< 0xfc000000(the 0xfb000000+0x200000-1 is the last physical address). so I think you lost a zero in 0x200000,but if it is 0x2000000,the region will be too large to be wasteful, so it can be set to a number which is more than 8MB but less than 16MB . As the same ,t2 should be *((unsigned char *)(io_mem + 0x1000000));

" ... , but the kernel uses the APIC Power Management Timer ... "
should be
" ... , but the kernel uses the ACPI Power Management Timer ... "

According to earlier sections of the same chapter the PMT is part of the ACPI not the APIC.

(hlist) `the pprev field of the first element and the next field of the last element are set to NULL.'

the pprev of first element is not NULL, it is &hlist_head.

In the definition of set_trap_gate() a reference to the above set_system_intr_gate() function is made, which is a mistake as it should be referencing the set_system_gate() function instead.

Currently the definition of set_trap_gate() states that it inserts a _interrupt_ gate, while the name and source code suggest otherwise (it inserts a trap gate). Thus this function is analogous to set_system_gate(), not set_system_intr_gate().

Currently in the book the definition of PUD_MASK and PGDIR_MASK are the same.
The sentence "The PUD_MASK macro is used to mask all the
bits of the Offset, Table, Middle Air, and Upper Air fields." should be changed to "The PUD_MASK macro is used to mask all the bits of the Offset, Table and Middle Air fields."