Paper over a race in DoubleBuffer.

I'm still somewhat okay throwing InterruptDisabler at races as they screw me.
Eventually I'm gonna have to devise a different strategy though.

Kernel/DoubleBuffer.cpp

@@ -2,9 +2,13 @@
 
 void DoubleBuffer::flip()
 {
+ InterruptDisabler disabler;
  ASSERT(m_read_buffer_index == m_read_buffer->size());
  swap(m_read_buffer, m_write_buffer);
- m_write_buffer->clear();
+ if (m_write_buffer->capacity() < 32)
+ m_write_buffer->clear_with_capacity();
+ else
+ m_write_buffer->clear();
  m_read_buffer_index = 0;
 }
 

Kernel/kmalloc.cpp

@@ -90,7 +90,7 @@ void* kmalloc_page_aligned(size_t size)
  return ptr;
 }
 
-void* kmalloc(dword size)
+void* kmalloc_impl(dword size)
 {
  InterruptDisabler disabler;
 

Kernel/kmalloc.h

@@ -1,7 +1,7 @@
 #pragma once
 
 void kmalloc_init();
-void *kmalloc(dword size) __attribute__ ((malloc));
+void* kmalloc_impl(dword size) __attribute__ ((malloc));
 void* kmalloc_eternal(size_t) __attribute__ ((malloc));
 void* kmalloc_page_aligned(size_t) __attribute__ ((malloc));
 void* kmalloc_aligned(size_t, size_t alignment) __attribute__ ((malloc));
@@ -17,3 +17,11 @@ extern volatile size_t kmalloc_sum_page_aligned;
 
 inline void* operator new(size_t, void* p) { return p; }
 inline void* operator new[](size_t, void* p) { return p; }
+
+ALWAYS_INLINE void* kmalloc(size_t size)
+{
+ // Any kernel allocation >= 32K is very suspicious, catch them.
+ if (size >= 0x8000)
+ asm volatile("cli;hlt");
+ return kmalloc_impl(size);
+}

Widgets/EventLoop.cpp

@@ -36,7 +36,11 @@ int EventLoop::exec()
  for (;;) {
  if (m_queuedEvents.is_empty())
  waitForEvent();
- auto events = move(m_queuedEvents);
+ Vector<QueuedEvent> events;
+ {
+ InterruptDisabler disabler;
+ events = move(m_queuedEvents);
+ }
  for (auto& queuedEvent : events) {
  auto* receiver = queuedEvent.receiver;
  auto& event = *queuedEvent.event;