FileSystem: Use OutputMemoryStream instead of BufferStream.

Author: https://github.com/asynts
Commit: https://github.com/SerenityOS/serenity/commit/206dcd84a6f
Pull-request: https://github.com/SerenityOS/serenity/pull/3496

Kernel/FileSystem/Ext2FileSystem.cpp

@@ -25,8 +25,8 @@
  */
 
 #include <AK/Bitmap.h>
-#include <AK/BufferStream.h>
 #include <AK/HashMap.h>
+#include <AK/MemoryStream.h>
 #include <AK/StdLibExtras.h>
 #include <AK/StringView.h>
 #include <Kernel/Devices/BlockDevice.h>
@@ -287,15 +287,18 @@ bool Ext2FS::write_block_list_for_inode(InodeIndex inode_index, ext2_inode& e2in
         output_block_index += new_shape.indirect_blocks;
     } else {
         auto block_contents = ByteBuffer::create_uninitialized(block_size());
-        BufferStream stream(block_contents);
+        OutputMemoryStream stream { block_contents };
+
         ASSERT(new_shape.indirect_blocks <= entries_per_block);
         for (unsigned i = 0; i < new_shape.indirect_blocks; ++i) {
             stream << blocks[output_block_index++];
             --remaining_blocks;
         }
+
         stream.fill_to_end(0);
-        auto buffer = UserOrKernelBuffer::for_kernel_buffer(block_contents.data());
-        int err = write_block(e2inode.i_block[EXT2_IND_BLOCK], buffer, block_size());
+
+        auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
+        int err = write_block(e2inode.i_block[EXT2_IND_BLOCK], buffer, stream.size());
         ASSERT(err >= 0);
     }
 
@@ -939,8 +942,8 @@ bool Ext2FSInode::write_directory(const Vector<Ext2FSDirectoryEntry>& entries)
 #endif
 
     auto directory_data = ByteBuffer::create_uninitialized(occupied_size);
+    OutputMemoryStream stream { directory_data };
 
-    BufferStream stream(directory_data);
     for (size_t i = 0; i < entries.size(); ++i) {
         auto& entry = entries[i];
 
@@ -960,7 +963,7 @@ bool Ext2FSInode::write_directory(const Vector<Ext2FSDirectoryEntry>& entries)
         stream << u16(record_length);
         stream << u8(entry.name.length());
         stream << u8(entry.file_type);
-        stream << entry.name;
+        stream << entry.name.bytes();
 
         int padding = record_length - entry.name.length() - 8;
         for (int j = 0; j < padding; ++j)
@@ -969,8 +972,8 @@ bool Ext2FSInode::write_directory(const Vector<Ext2FSDirectoryEntry>& entries)
 
     stream.fill_to_end(0);
 
-    auto buffer = UserOrKernelBuffer::for_kernel_buffer(directory_data.data());
-    ssize_t nwritten = write_bytes(0, directory_data.size(), buffer, nullptr);
+    auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
+    ssize_t nwritten = write_bytes(0, stream.size(), buffer, nullptr);
     if (nwritten < 0)
         return false;
     set_metadata_dirty(true);

Kernel/FileSystem/FileDescription.cpp

@@ -24,7 +24,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <AK/BufferStream.h>
+#include <AK/MemoryStream.h>
 #include <Kernel/Devices/BlockDevice.h>
 #include <Kernel/Devices/CharacterDevice.h>
 #include <Kernel/FileSystem/Custody.h>
@@ -178,26 +178,26 @@ ssize_t FileDescription::get_dir_entries(UserOrKernelBuffer& buffer, ssize_t siz
     size_t size_to_allocate = max(static_cast<size_t>(PAGE_SIZE), static_cast<size_t>(metadata.size));
 
     auto temp_buffer = ByteBuffer::create_uninitialized(size_to_allocate);
-    BufferStream stream(temp_buffer);
+    OutputMemoryStream stream { temp_buffer };
+
     KResult result = VFS::the().traverse_directory_inode(*m_inode, [&stream, this](auto& entry) {
         stream << (u32)entry.inode.index();
         stream << m_inode->fs().internal_file_type_to_directory_entry_type(entry);
         stream << (u32)entry.name.length();
-        stream << entry.name;
+        stream << entry.name.bytes();
         return true;
     });
 
     if (result.is_error())
         return result;
 
-    stream.snip();
-
-    if (static_cast<size_t>(size) < temp_buffer.size())
+    if (static_cast<size_t>(size) < stream.size())
         return -EINVAL;
 
-    if (!buffer.write(temp_buffer.data(), temp_buffer.size()))
+    if (!buffer.write(stream.bytes()))
         return -EFAULT;
-    return stream.offset();
+
+    return stream.size();
 }
 
 bool FileDescription::is_device() const

Kernel/UserOrKernelBuffer.h

@@ -80,11 +80,20 @@ public:
     {
         return write(src, 0, len);
     }
+    [[nodiscard]] bool write(ReadonlyBytes bytes)
+    {
+        return write(bytes.data(), bytes.size());
+    }
+
     [[nodiscard]] bool read(void* dest, size_t offset, size_t len) const;
     [[nodiscard]] bool read(void* dest, size_t len) const
     {
         return read(dest, 0, len);
     }
+    [[nodiscard]] bool read(Bytes bytes) const
+    {
+        return read(bytes.data(), bytes.size());
+    }
 
     [[nodiscard]] bool memset(int value, size_t offset, size_t len);
     [[nodiscard]] bool memset(int value, size_t len)