diff --git a/Userland/Libraries/LibPartition/GUIDPartitionTable.cpp b/Userland/Libraries/LibPartition/GUIDPartitionTable.cpp
index 45028102ff..fb2c261b32 100644
--- a/Userland/Libraries/LibPartition/GUIDPartitionTable.cpp
+++ b/Userland/Libraries/LibPartition/GUIDPartitionTable.cpp
@@ -44,19 +44,30 @@ struct [[gnu::packed]] GUIDPartitionHeader {
     u32 crc32_entries_array;
 };
 
+#ifdef KERNEL
 ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> GUIDPartitionTable::try_to_initialize(Kernel::StorageDevice const& device)
 {
     auto table = TRY(adopt_nonnull_own_or_enomem(new (nothrow) GUIDPartitionTable(device)));
+#else
+ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> GUIDPartitionTable::try_to_initialize(NonnullRefPtr<Core::File> device_file)
+{
+    auto table = TRY(adopt_nonnull_own_or_enomem(new (nothrow) GUIDPartitionTable(move(device_file))));
+#endif
     if (!table->is_valid())
         return Error::from_errno(EINVAL);
     return table;
 }
 
+#ifdef KERNEL
 GUIDPartitionTable::GUIDPartitionTable(Kernel::StorageDevice const& device)
     : MBRPartitionTable(device)
+#else
+GUIDPartitionTable::GUIDPartitionTable(NonnullRefPtr<Core::File> device_file)
+    : MBRPartitionTable(move(device_file))
+#endif
 {
     // FIXME: Handle OOM failure here.
-    m_cached_header = ByteBuffer::create_zeroed(m_device->block_size()).release_value_but_fixme_should_propagate_errors();
+    m_cached_header = ByteBuffer::create_zeroed(m_block_size).release_value_but_fixme_should_propagate_errors();
     VERIFY(partitions_count() == 0);
     if (!initialize())
         m_valid = false;
@@ -71,12 +82,17 @@ bool GUIDPartitionTable::initialize()
 {
     VERIFY(m_cached_header.data() != nullptr);
 
-    auto first_gpt_block = (m_device->block_size() == 512) ? 1 : 0;
+    auto first_gpt_block = (m_block_size == 512) ? 1 : 0;
 
+#ifdef KERNEL
     auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_header.data());
-    if (!m_device->read_block(first_gpt_block, buffer)) {
+    if (!m_device->read_block(first_gpt_block, buffer))
         return false;
-    }
+#else
+    m_device_file->seek(first_gpt_block * m_block_size);
+    if (m_device_file->read(m_cached_header.data(), m_cached_header.size()) != (int)m_block_size)
+        return false;
+#endif
 
     dbgln_if(GPT_DEBUG, "GUIDPartitionTable: signature - {:#08x} {:#08x}", header().sig[1], header().sig[0]);
 
@@ -85,21 +101,28 @@ bool GUIDPartitionTable::initialize()
         return false;
     }
 
-    auto entries_buffer_result = ByteBuffer::create_zeroed(m_device->block_size());
+    auto entries_buffer_result = ByteBuffer::create_zeroed(m_block_size);
     if (entries_buffer_result.is_error()) {
-        dbgln("GUIPartitionTable: not enough memory for entries buffer");
+        dbgln("GUIDPartitionTable: not enough memory for entries buffer");
         return false;
     }
     auto entries_buffer = entries_buffer_result.release_value();
+#ifdef KERNEL
     auto raw_entries_buffer = UserOrKernelBuffer::for_kernel_buffer(entries_buffer.data());
-    size_t raw_byte_index = header().partition_array_start_lba * m_device->block_size();
+#endif
+    size_t raw_byte_index = header().partition_array_start_lba * m_block_size;
     for (size_t entry_index = 0; entry_index < header().entries_count; entry_index++) {
 
-        if (!m_device->read_block((raw_byte_index / m_device->block_size()), raw_entries_buffer)) {
+#ifdef KERNEL
+        if (!m_device->read_block((raw_byte_index / m_block_size), raw_entries_buffer))
             return false;
-        }
+#else
+        m_device_file->seek(raw_byte_index);
+        if (m_device_file->read(entries_buffer.data(), entries_buffer.size()) != (int)m_block_size)
+            return false;
+#endif
         auto* entries = (GPTPartitionEntry const*)entries_buffer.data();
-        auto& entry = entries[entry_index % (m_device->block_size() / (size_t)header().partition_entry_size)];
+        auto& entry = entries[entry_index % (m_block_size / (size_t)header().partition_entry_size)];
         Array<u8, 16> partition_type {};
         partition_type.span().overwrite(0, entry.partition_guid, partition_type.size());
 
diff --git a/Userland/Libraries/LibPartition/GUIDPartitionTable.h b/Userland/Libraries/LibPartition/GUIDPartitionTable.h
index eda6473933..c36110e480 100644
--- a/Userland/Libraries/LibPartition/GUIDPartitionTable.h
+++ b/Userland/Libraries/LibPartition/GUIDPartitionTable.h
@@ -15,10 +15,18 @@ class GUIDPartitionTable final : public MBRPartitionTable {
 public:
     virtual ~GUIDPartitionTable() = default;
 
+#ifdef KERNEL
     static ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> try_to_initialize(Kernel::StorageDevice const&);
     explicit GUIDPartitionTable(Kernel::StorageDevice const&);
+#else
+    static ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> try_to_initialize(NonnullRefPtr<Core::File>);
+    explicit GUIDPartitionTable(NonnullRefPtr<Core::File>);
+#endif
 
-    virtual bool is_valid() const override { return m_valid; };
+    virtual bool is_valid() const override
+    {
+        return m_valid;
+    }
 
 private:
     bool is_unused_entry(Array<u8, 16>) const;