One of the reasons why trying to deal with randomness is hard is because a lot of it is about trust.  Did Intel backdoor RDRAND to help out the NSA?   You might have one answer if you work for the NSA, and perhaps if you are willing to assume the worst about the NSA balancing its equities between its signals intelligence mission and providing a secure infrastructure for its customers and keeping the US computing industry strong.   Etc., etc.

It is true that OS developers are trying to make their random number generators be initialized more quickly at boot time.  Part of this is because of the dynamic which we can all see at work on the discussion of this bug.  Some people care about very much about not blocking; some people want Python to be useful during the boot sequences; some people care very much about security above all else; some people don't trust application programmers.  (And if you fit in that camp; congratulations, now you know how I often feel when I worry about user space programmers doing potentially crazy things and I have no way of even knowing about them until the security researchers publish a web site such as http://www.factorable.net)

From the OS's perspective, one of the problems is that it's very hard to know when you have actually achieved a securely initialized random number generator.  Sure, we can say we've done this once we have accumulated at least 128 bits of entropy, but that begs the question of when you've collected a bit of entropy.  There's no way to know for sure.  On current systems, we assume that each interrupt gathers 1/64th of a bit of entropy on average.  This is an incredibly conservative number, and on real hardware, assuming the normal bootup activity, we achieve that within about 5 seconds (plus/minus 2 seconds) after boot.   On Intel, on real hardware, I'm comfortable cutting this to 1 bit of entropy per interrupt, which will speed up things considerably.  In an ARM SOC, or if you are on a VM and you don't trust the hypervisor so you don't use virtio-rng, is one bit of entropy per interrupt going to be good enough?  It's hard to say.

On the other hand, if we use too conservative a number, there is a risk that userspace programmers (such as some have advocated on the discussionon this bug) to simply always use GRND_NONBLOCK, or fall back to /dev/urandom, and then if there's a security exposure, they'll cast the blame on the OS developers.  The reality is that we really need to work together, because the real problem are the clueless people writing python scripts at boot time to create long-term RSA private keys for IOT devices[1].  :-)    

So when people assert that developers at FreeBSD are at work trying to speedup /dev/random initialization, folks need to understand that there's no magic here.  What's really happening is that we're all trying to figure out which defaults work the best.  In some ways the FreeBSD folks have it easier, because they support a much fewer range of platforms.  It's a lot easier to get things right on x86, where we have instructions like RDTSC and RDRAND to help us out.  It's a lot harder to be sure you have things right for ARM SOC's.   There are other techniques such as trying to carry entropy over from previous boot sessions, but (a) this requires support from the boot loaders, and on an OS with a large number of architectures, that means adding support to a large number of different ways of booting the kernel --- and it doesn't solve the "consumer device generating keys after a cold start when the device is freshly removed from the packaging".

As far as adding knobs, such as "blocking vs non-blocking", etc., keep in mind that as you add knobs, you increase the knowledge of the system that you force onto the next layer of the stack.  So this goes to the question of whether you trust application programmers will be able to get things right.

So Ted, why does Linux expose /dev/random vs /dev/urandom?  Historical reasons; some people don't believe that relying on cryptogaphic random number generators is sufficient, they *want* to use entropy which has minimal reliance on the belief that NSA ***probably*** didn't leave a back door into SHA-1, for example.  It is for that reason that /dev/random exists.  These days, the number of people who believe that to be true are very small, but I didn't want to make changes in existing interfaces.  For similar reasons I didn't want to suddenly make /dev/urandom block.   The fact that getrandom(2) blocks only until the cryptographic RNG has been initialized, and that it depends on a cryptogaphic RNG, is the consensus that *most* people have come to, and it reflects my recommendations that unless you ***really*** know what you are doing, the right thing to do is to call getrandom(2) with the flags field set to zero, and to be happy.   Of course, many people are sure they know what they need to do than there are people who really *do* know what they are doing, which is why in BSD, they simply don't give people a choice with their getentropy(2) system call.  If you assume that application/user-space programmers should never be trusted, and API's should come with a strong point of view, that's a reasonable design choice.   At some level this is the same choice which is before the Python developer community.  I'm not going to presume to tell you what the right thing to do is here, because it's filled with engineering and design tradeoffs.  Hopefully this additional perspective is useful, though.

[1]  This is a joke, folks.  We need to all work together, even the application programmers.  Some may say that means we're doomed from a security perspective, but security really has to be a collective responsibility if we don't want our "home of the future" to be completely pwned by the bad guys.....