wind: Move more fallible operations before window creation

Classic "keeping a pointer to an element inside a vector after the vector is updated" bug, ah yes.

kernel/src/arch/x86_64/disk/ATA.cpp

@@ -503,17 +503,11 @@ namespace ATA
         }
         else
         {
-            u8 buf[8];
-            memcpy(buf, &m_identify_words[100], 8);
+            if (m_identify_data.big_lba) m_is_lba48 = true;
 
-            m_block_count = *reinterpret_cast<u64*>(buf);
-
-            if (!m_block_count)
-            {
-                memcpy(buf, &m_identify_words[60], 4);
-                m_block_count = *reinterpret_cast<u32*>(buf);
-            }
-            else { m_is_lba48 = true; }
+            if (m_is_lba48) m_block_count = m_identify_data.sectors_48;
+            else
+                m_block_count = m_identify_data.sectors_28;
 
             // FIXME: Should we check for CHS?
 

kernel/src/fs/ext2/Inode.cpp

@@ -7,13 +7,6 @@ namespace Ext2
     {
     }
 
-    Result<void> Inode::prepare_buffer() const
-    {
-        if (!m_block_buffer.is_empty()) return {};
-        return m_block_buffer.try_resize(m_fs->m_block_size);
-    }
-
-    // FIXME: This code seems awfully similar to BlockDevice::read(). Can this be merged with it in some way?
     Result<usize> Inode::read(u8* buf, usize offset, usize length) const
     {
         if (length == 0) return 0;
@@ -73,47 +66,22 @@ namespace Ext2
     {
         if (index < 12) return m_raw_inode.direct_pointers[index];
 
-        const usize block_size = m_fs->m_block_size;
-        const usize blocks_per_indirect_block = block_size / sizeof(u32);
-
-        index -= 12;
-
-        TRY(prepare_buffer());
-
-        // Singly indirect block
-        if (index < blocks_per_indirect_block)
+        usize block_index = (index - 12) * sizeof(u32);
+        if (block_index >= m_fs->m_block_size)
         {
-            TRY(m_fs->m_host_device->read(m_block_buffer.data(), m_raw_inode.singly_indirect_ptr * block_size,
-                                          block_size));
-            return ((u32*)m_block_buffer.data())[index];
+            fail("ext2: Finding blocks beyond the singly indirect pointer block is not yet supported");
         }
 
-        index -= blocks_per_indirect_block;
+        usize block_size = m_fs->m_block_size;
 
-        // Doubly indirect block
-        if (index < blocks_per_indirect_block * blocks_per_indirect_block)
+        if (m_singly_indirect_block.is_empty())
         {
-            TRY(m_fs->m_host_device->read(m_block_buffer.data(), m_raw_inode.doubly_indirect_ptr * block_size,
+            TRY(m_singly_indirect_block.try_resize(block_size));
+            TRY(m_fs->m_host_device->read(m_singly_indirect_block.data(), m_raw_inode.singly_indirect_ptr * block_size,
                                           block_size));
-            const u32 block = ((u32*)m_block_buffer.data())[index / blocks_per_indirect_block];
-
-            TRY(m_fs->m_host_device->read(m_block_buffer.data(), block * block_size, block_size));
-            return ((u32*)m_block_buffer.data())[index % blocks_per_indirect_block];
         }
 
-        index -= blocks_per_indirect_block * blocks_per_indirect_block;
-
-        check(index < blocks_per_indirect_block * blocks_per_indirect_block * blocks_per_indirect_block);
-
-        // Triply indirect block
-        TRY(m_fs->m_host_device->read(m_block_buffer.data(), m_raw_inode.triply_indirect_ptr * block_size, block_size));
-        u32 block = ((u32*)m_block_buffer.data())[index / (blocks_per_indirect_block * blocks_per_indirect_block)];
-
-        TRY(m_fs->m_host_device->read(m_block_buffer.data(), block * block_size, block_size));
-        block = ((u32*)m_block_buffer.data())[(index / blocks_per_indirect_block) % blocks_per_indirect_block];
-
-        TRY(m_fs->m_host_device->read(m_block_buffer.data(), block * block_size, block_size));
-        return ((u32*)m_block_buffer.data())[index % blocks_per_indirect_block];
+        return *reinterpret_cast<u32*>(&m_singly_indirect_block.data()[block_index]);
     }
 
     Result<void> Inode::lazy_initialize_dir() const

kernel/src/fs/ext2/Inode.h

@@ -115,7 +115,7 @@ namespace Ext2
         FileSystem* m_fs;
         ino_t m_inum;
 
-        mutable Buffer m_block_buffer;
+        mutable Buffer m_singly_indirect_block;
 
         String m_link;
 
@@ -123,7 +123,6 @@ namespace Ext2
         mutable bool m_dir_already_lazily_initialized { false };
 
         Result<usize> find_block(usize index) const;
-        Result<void> prepare_buffer() const;
 
         friend class FileSystem;
     };