Mon Jan  8 09:16:50 EST 2018

Slept from eleven to seven. Woke briefly a couple of times in the night.

Unexpectedly, a couple new inches of snow fell overnight. Slow morning commute.

High of thirty-six and cloudy today.

Work:
- Review invoices
  Done.
- Finish reading on Meldown and Spectre (https://spectreattack.com/)
  Done. Nasty.
- Finish Streamline stuff for Hazel Park
  Nearly finished.

Install the Ubuntu font on my work machine.

	$ curl https://assets.ubuntu.com/v1/fad7939b-ubuntu-font-family-0.83.zip
	$ unzip ubuntu-font-family-0.83.zip
	$ mv ubuntu-font-family-0.83/Ubuntu*ttf ~/.local/share/fonts/
	$ fc-cache -f

I had to kill all Gnome Terminal instances before it saw the new font.

Also, trying a different terminal color scheme: foreground #dfdfdf, background #2a2a2a.

https://lwn.net/SubscriberLink/742702/83606d2d267c0193/
>  A CPU is typically working on the execution of multiple instructions at once, for performance reasons. Executing instructions in parallel allows the processor to keep more of its subunits busy at once, which speeds things up. But parallel execution is also driven by the slowness of access to main memory. A cache miss requiring a fetch from RAM can stall the execution of an instruction for hundreds of processor cycles, with a clear impact on performance. To minimize the amount of time it spends waiting for data, the CPU will, to the extent it can, execute instructions after the stalled one, essentially reordering the code in the program. That reordering is often invisible, but it occasionally leads to the sort of fun that caused Documentation/memory-barriers.txt to be written.
>
> Out-of-order execution runs into a challenge whenever the code branches, though. The processor may not yet be able to tell which branch will be taken, so it doesn't know where to go to execute ahead of the stalled instruction(s). The answer here is "branch prediction". The processor will make a guess based on past experience with the branch in question and, possibly, explicit guidance from the code (the unlikely() directive used in kernel code, for example). Once the actual branch condition can be evaluated, the processor will determine whether it guessed right. If not, the "speculatively" executed instructions after the branch will be unwound, and everything will proceed as if they had never been run.
>
> A branch-prediction failure should really only lead to slower execution, with no visible side effects. That turns out to not be the case, though, leading to a set of severe information-disclosure vulnerabilities. In particular, speculative instruction execution can cause data to be loaded into the CPU memory cache; timing attacks can then be used to learn which instructions were executed. If speculative execution of kernel code can be controlled by an attacker, the contents of the cache can be used as a covert channel to get data out of the kernel.
> [...]
> One rather frightening aspect of this vulnerability is that an attacker running inside a virtualized guest can use it to leak data accessible to the hypervisor — all the data in the host system, in other words.

https://googleprojectzero.blogspot.co.at/2018/01/reading-privileged-memory-with-side.html
> It would be interesting to explore whether there are microarchitectural attacks other than measuring data cache timing that can be used for exfiltrating data out of speculative execution.
> We developed a successful variant 1 attack against the JIT engine built into the Linux kernel. It would be interesting to see whether attacks against more advanced JIT engines with less control over the system are also practical - in particular, JavaScript engines.

https://www.theregister.co.uk/2018/01/04/intel_amd_arm_cpu_vulnerability/

Twenty-five-minute walk at lunch.
Much warmer today, though gray.

Worked a little late.

Home:
- Continue reviewing Go notes
  Done.
- Work on SpinMPC
  No.

	$ ssh paulgorman.org grep -B 1 -e '--------' ~/technical/golang.txt | sed '/--*/d'

Walked up to the grocery after work.

This police procedural, Suspects, is pretty good.

http://www.post-punk.com/cinamon-hadley-the-inspiration-for-neil-gaimans-death-has-passed-away/

Lunch: coffee, chicken shawarma bowl
Dinner: popcorn