Add internal locking to DoubleBuffer.

Kernel/DoubleBuffer.cpp

@@ -1,31 +1,40 @@
 #include "DoubleBuffer.h"
 
+inline void DoubleBuffer::compute_emptiness()
+{
+ m_empty = m_read_buffer_index >= m_read_buffer->size() && m_write_buffer->is_empty();
+}
+
 void DoubleBuffer::flip()
 {
- InterruptDisabler disabler;
  ASSERT(m_read_buffer_index == m_read_buffer->size());
  swap(m_read_buffer, m_write_buffer);
  if (m_write_buffer->capacity() < 32)
  m_write_buffer->clear_with_capacity();
  else
  m_write_buffer->clear();
  m_read_buffer_index = 0;
+ compute_emptiness();
 }
 
 ssize_t DoubleBuffer::write(const byte* data, size_t size)
 {
+ LOCKER(m_lock);
  m_write_buffer->append(data, size);
+ compute_emptiness();
  return size;
 }
 
 ssize_t DoubleBuffer::read(byte* data, size_t size)
 {
+ LOCKER(m_lock);
  if (m_read_buffer_index >= m_read_buffer->size() && !m_write_buffer->is_empty())
  flip();
  if (m_read_buffer_index >= m_read_buffer->size())
  return 0;
  ssize_t nread = min(m_read_buffer->size() - m_read_buffer_index, size);
  memcpy(data, m_read_buffer->data() + m_read_buffer_index, nread);
  m_read_buffer_index += nread;
+ compute_emptiness();
  return nread;
 }

Kernel/DoubleBuffer.h

@@ -2,6 +2,7 @@
 
 #include <AK/Types.h>
 #include <AK/Vector.h>
+#include <AK/Lock.h>
 
 class DoubleBuffer {
 public:
@@ -14,16 +15,20 @@ class DoubleBuffer {
  ssize_t write(const byte*, size_t);
  ssize_t read(byte*, size_t);
 
- bool is_empty() const { return m_read_buffer_index >= m_read_buffer->size() && m_write_buffer->is_empty(); }
+ bool is_empty() const { return m_empty; }
 
+ // FIXME: Isn't this racy? What if we get interrupted between getting the buffer pointer and dereferencing it?
  size_t bytes_in_write_buffer() const { return m_write_buffer->size(); }
 
 private:
  void flip();
+ void compute_emptiness();
 
  Vector<byte>* m_write_buffer { nullptr };
  Vector<byte>* m_read_buffer { nullptr };
  Vector<byte> m_buffer1;
  Vector<byte> m_buffer2;
  size_t m_read_buffer_index { 0 };
+ bool m_empty { true };
+ SpinLock m_lock;
 };