We forgot to delete the object from the debugger interface when removing it
from the program.

* 'master' of github.com:cloudius-systems/osv:
  romfs: fix romfs_read() use uninitialized variable
  bsd: fix ratecheck()
  mempool: switch spinlocks to mutexes
  smp: drop debug message on smp bringup
  libc: make assert friendlier to panic conditions

I can not see the packets yet, probably the header needs to
be configured

found by mode=release

found by mode=release

Now working.

boost::format allocates, and we're not quite ready to schedule at this
state; drop the debug message (unneeded anyhow).

Don't go though the stdio/vfs layer.

* 'master' of github.com:cloudius-systems/osv:
  interrupt manager: simplify msi registration

Conflicts:
	drivers/virtio-net.cc

it both when there is only 1-2 available discriptors and also to
detect whether we have < half ring and should call re-fill

This reverts commit 8af0d5ee.

Conflicts:
	bootfs.manifest

Instead of requiring the user to construct an msix entry -> thread binding
map, they can now pass it directly:

  _msi.easy_register({ { 0, isr0 },  { 1, isr1 } });

IDT vectors are an extra level of indirection on the way to the
msix_vector, which is what we really want.  Convert assigned_vectors to
be std::vector<msix_vector*>; this leads to a considerable simplification
of the code.

Since the interrupt manager is now local to a device, we can initialize
the device pointer once and remember it.  This simplifies the API.

There's no reason for it.

There are actually no interactions between msix registrations of different
drivers, so it doesn't help to use a global instance.  We can simplify the
interface by making it local, and also remove locking considerations.

These are subsumed into the driver constructor/destrutor.

Driver enumeration requires instantiating a driver even for devices which
are not present; and if a device is present multiple times, we need to
pre-create multiple driver instances, which is awkward.  Further, driver
life-cycle is complicated, with separation between instantiation and binding
to a device.

Switch (back) to the traditional device-driven model, where we iterate over
all devices, try to find a matching driver factory, and when found, call it
to instantiate the driver and bind to the device.

Don't do this in header files.

The main thread has a bogus wait_for_interrupts() which consumed wakeups,
so the scheduler on the cpu running it could not schedule stuff.  This
manifested itself in lots of zombies from bsd callouts not getting reaped.

Drop.

If the user forgot to do this, do them a favour.

We also make the deleter configurable so we can use munmap() or similar
to destroy the stack of payload threads.

Mutex is much better now and should be sufficient.

To avoid overflowing sem_t, we have to use a pointer instead of embedding
the mutex.

This reverts commit e917ab25.

If we have an assert, it can break badly, as printf() inside the assert
allocates.

Will reinstate after adding emergency allocators.

Mutexes are now allocation free and thus safe for use within the allocator.

wait_until(mutex, ...) must be called with the mutex held.

Use the new wait_until() variant that supports dropping a mutex
while sleeping.

We need to make them a little more complicated.

Previously, we performed idle processing in the scheduler, in the context
of the thread that is being scheudled out.  This makes preemption more
complicated, since every thread can potentially be in the idle loop
simultaneously, having been preempted there some time in the past.  Obviously
we can't disable interrupts in the idle loop.

Move idle processing to its own thread to fix this problem.  This is currently
sub-optimal since we don't have priority classes yet (or even just priorities),
so the idle thread can be scheduled before workload threads.  If that happens
it will examine the runqueue and yield if there's anything there.