HNHacker News
TopNewBestAskShowJobs

anttiok

102 karma · joined July 3, 2013

submissionscomments
anttiok··on Rumprun Tutorial: Serve a static website as a Unikernel

  > There is only one kind of "hardware" in the universe: the supported hypervisor. No need for drivers for anything else.
An explicit goal of rumprun is to support real hardware. Defining the cloud as the only supported platform makes sense if you have to write or port hardware device drivers. For rumprun those drivers come for free as rump kernel components, so if you want to link them in (optional) and run on real hardware, it's possible. Having that possibility makes sense too: your cloud platform and IoT (+) platform can be the same thing, it's just the orchestration layer that differs.

+) given a large enough "T"

anttiok··on OCaml and Mirage now running on rumprun, including bare metal
Let's assume that a consumer device vendor does not want to pay more for hardware than what is required by their application. It's an assumption, but I think it's a fairly reasonable one to start from.

So the game boils down to "required by". For any non-trivial application (larger than x kB microcontroller) running on non-trivial hardware and using non-trivial software constructs you need non-trivial drivers. Those non-trivial drivers have to come from somewhere. That is the reason why OS's are scaled down (i.e. hacked to pieces) to fit the embedded market.

When you start looking at constructing the software stack from the perspective of the requirements of the application, not those of the OS, you can leave a huge amount of gunk out since you know precisely what you will need.

Why wouldn't you build your software stack to consume only the necessary amount of resources?

anttiok··on OCaml and Mirage now running on rumprun, including bare metal
Not only a hypervisor-generic, just generic. Whoever said that unikernels required the cloud wasn't thinking too much </friendlyjab>.

I share avsm's excitement, and think we're on the verge of a transition away from the world where the OS is some arbitrary black box that you must have for anything to work. In the future world the components included in software stacks are determined per application need instead of the OS author('s ego). That transition is partly motivated by the cloud, but also partly by more and more smaller and smaller special-purpose devices.

anttiok··on Next-Generation Cloud: The Rise of the Unikernel
The rump kernel unikernel (rumprun) will happily work on actual hardware. It's a bit hazy if that's a unikernel or an embedded system in that case (and what's the difference anyway?), but to avoid hairsplitting, you can replace the hardware with KVM and off you go.
anttiok··on LibOS – A library operating system for Linux
For one, the microkernel would be missing ;)

More seriously though, you're absolutely right in that it's a step in the direction of an "optional" microkernel architecture. That's actually how rump kernels on NetBSD started: running the kernel file system driver as a library in userspace on top of a FUSE-like subsystem. It's pretty useful functionality, since it allows you to handle untrusted file system images safely in userspace, while not imposing performance penalty on the trusted images which can be handled by the same driver running in the kernel. Unlike with FUSE-specific drivers, you don't run into issues with unsymmetric driver support in userspace vs. kernel.

anttiok··on After Docker: Unikernels and Immutable Infrastructure
While I can't speak for anyone else, the intent is that people would follow the "Getting started" tutorial linked from the front page of http://rumpkernel.org/ : http://wiki.rumpkernel.org/Tutorial:-Getting-started

If that is lacking, please let us know!

anttiok··on After Docker: Unikernels and Immutable Infrastructure
A rump kernel is not an OS and it's not restricted to running in usermode.

see: http://wiki.rumpkernel.org/Info%3A-Comparison-of-rump-kernel...

anttiok··on Where rump kernels are heading
The idea of rump kernels is to make existing kernel driver implementations available in environments beyond the original [monolithic] kernel they were written for. The idea is not to figure out some perfect structure for an OS. There is absolutely no intention to back pedal to historic systems which lack the drivers to operate with real world of today.
anttiok··on An Internet-Ready OS From Scratch in a Week – Rump Kernels on Bare Metal
Unikernel: yes, that's what the article mostly describes.

Microkernel: yes, though strictly speaking you'd use rump kernels for the servers in a microkernel OS. (that was actually the first use case back in 2007)

There are multiple example implementations for the hypercall interface ("rumpuser") at http://repo.rumpkernel.org/

You can find full details from http://book.rumpkernel.org/ (it's a bit out of date in describing what has been built using rump kernels, but the parts describing basic functionality are accurate).

anttiok··on An Internet-Ready OS From Scratch in a Week – Rump Kernels on Bare Metal
http://www.iki.fi/pooka/private/baremetal/art.html

It doesn't contain the pretty css, and I probably fixed a tyop or two when posting, but the content should be 99.9% same.

anttiok··on An Internet-Ready OS From Scratch in a Week – Rump Kernels on Bare Metal
MirageOS, at least from my viewpoint, is trying to figure out what the cloud software stacks of tomorrow should look like. Rump kernels give you production quality building blocks for running existing code today in any environment. I wouldn't compare the two projects too much.
anttiok··on An Internet-Ready OS From Scratch in a Week – Rump Kernels on Bare Metal
Yes, works on ARM. The only architecture-specific support that a rump kernel needs is cache-coherent memory operations, and those are necessary only if you want to run on a multiprocessor system. So works on anything to which you can compile C code, really (though you might have to toy with some Makefiles a bit for new architectures).
anttiok··on An Internet-Ready OS From Scratch in a Week – Rump Kernels on Bare Metal
Heh, I suspect "the author" missed a digit when inputting the calculation. bc needs a calculate-what-i-meant mode!
anttiok··on ZeroVM: Smaller, Lighter, Faster
Based on "Why ZeroVM?" (http://zerovm.org/wiki/Why_ZeroVM), a large part of the motivation for ZeroVM is based on the premise that regular VMs require a full OS and are therefore unacceptably fat. However, there are multiple platforms for running unmodified applications directly on VMs without requiring a traditional OS, e.g. the work I've been involved with: https://github.com/anttikantee/rumpuser-xen/

Determinism, OTOH, sounds interesting at least on paper. Is there any experience from tests with real applications in real world scenarios?

anttiok··on Lua support in the NetBSD kernel
It's awesome to see this work finally hit the tree. Now, I cannot say I agree with all of the motivations. For example, I do not believe that prototyping should be done in kernel mode at all, nor do I believe that using Lua will shield from incorrect operation or crashes. However, there is already proof that device drivers can be written in Lua (https://github.com/SnabbCo/snabbswitch), and it's great to see more push in that direction.

After all, why use C if you have a working alternative? We just need real world experiments to see if Lua is a working alternative for the kernel.

anttiok··on Why does the C preprocessor interpret the word “linux” as the constant “1”?
If you're in the habit of writing "struct sockaddr_in sin;", you'll probably be tempted to write "struct sockaddr_un sun;". Just don't expect that code to compile on Solaris.
anttiok··on Rethinking the guest operating system
Someone asked me to compare the two:

http://blog.netbsd.org/tnf/entry/running_applications_on_the...

tl;dr amount of code rewritten vs. reused

anttiok··on LuaJIT on Xen
Yes, tiny resource overhead while still providing near-complete isolation is a big benefit. The current memory overhead from using file system drivers and TCP/IP networking is around 8MB, and I'm sure there's a bunch of fat in there that could be trimmed off.

It's going to be interesting to see where the exact set of supported application images converges as use cases arise. For example, I'm pretty sure fork() will never be supported -- would it fork the VM? -- but some of the other things are up for discussion.

anttiok··on LuaJIT on Xen
There is threading in the underlying framework. In fact, since there is no VM support, threading is all you have.

However, there is no pthread support which is probably what you are referring to. I don't think pthread support would be difficult to add. Most likely it's trivial in case non-preemptive run-to-block threads are ok. If someone has a use case for pthreads, I'm up for a discussion.

anttiok··on What People Like About the Plan 9 OS
It's already been done with a general purpose OS, see https://github.com/anttikantee/rumpuser-xen/

I agree, it was easy to do.

← PreviousPage 2 of 2