Kernel/Storage: Introduce new boot device addressing modes

Before of this patch, we supported two methods to address a boot device:
1. Specifying root=/dev/hdXY, where X is a-z letter which corresponds to
a boot device, and Y as number from 1 to 16, to indicate the partition
number, which can be omitted to instruct the kernel to use a raw device
rather than a partition on a raw device.
2. Specifying root=PARTUUID: with a GUID string of a GUID partition. In
case of existing storage device with GPT partitions, this is most likely
the safest option to ensure booting from persistent storage.

While option 2 is more advanced and reliable, the first option has 2
caveats:
1. The string prefix "/dev/hd" doesn't mean anything beside a convention
on Linux installations, that was taken into use in Serenity. In Serenity
we don't mount DevTmpFS before we mount the boot device on /, so the
kernel doesn't really access /dev anyway, so this convention is only a
big misleading relic that can easily make the user to assume we access
/dev early on boot.
2. This convention although resemble the simple linux convention, is
quite limited in specifying a correct boot device across hardware setup
changes, so option 2 was recommended to ensure the system is always
bootable.

With these caveats in mind, this commit tries to fix the problem with
adding more addressing options as well as to remove the first option
being mentioned above of addressing.
To sum it up, there are 4 addressing options:
1. Hardware relative address - Each instance of StorageController is
assigned with a index number relative to the type of hardware it handles
which makes it possible to address storage devices with a prefix of the
commandset ("ata" for ATA, "nvme" for NVMe, "ramdisk" for Plain memory),
and then the number for the parent controller relative hardware index,
another number LUN target_id, and a third number for LUN disk_id.
2. LUN address - Similar to the previous option, but instead we rely on
the parent controller absolute index for the first number.
3. Block device major and minor numbers - by specifying the major and
minor numbers, the kernel can simply try to get the corresponding block
device and use it as the boot device.
4. GUID string, in the same fashion like before, so the user use the
"PARTUUID:" string prefix and add the GUID of the GPT partition.

For the new address modes 1 and 2, the user can choose to also specify a
partition out of the selected boot device. To do that, the user needs to
append the semicolon character and then add the string "partX" where X
is to be changed for the partition number. We start counting from 0, and
therefore the first partition number is 0 and not 1 in the kernel boot
argument.

1 files changed, 17 insertions, 7 deletions

diff --git a/Kernel/Storage/StorageDevice.h b/Kernel/Storage/StorageDevice.h
index feac7f4a06..0ac12c97ad 100644
--- a/Kernel/Storage/StorageDevice.h
+++ b/Kernel/Storage/StorageDevice.h
@@ -15,6 +15,7 @@
 
 namespace Kernel {
 
+class RamdiskDevice;
 class StorageDevice : public BlockDevice {
     friend class StorageManagement;
     friend class DeviceManagement;
@@ -46,7 +47,6 @@ public:
     // to the Primary channel as a slave device, which translates to LUN 1:0:1.
     // On NVMe, for example, connecting a second PCIe NVMe storage device as a sole NVMe namespace translates
     // to LUN 1:0:0.
-    // TODO: LUNs are also useful also when specifying the boot drive on boot. Consider doing that.
     struct LUNAddress {
         u32 controller_id;
         u32 target_id;
@@ -63,15 +63,14 @@ public:
     virtual bool can_write(OpenFileDescription const&, u64) const override;
     virtual void prepare_for_unplug() { m_partitions.clear(); }
 
-    // FIXME: Remove this method after figuring out another scheme for naming.
-    StringView early_storage_name() const;
-
     NonnullLockRefPtrVector<DiskPartition> const& partitions() const { return m_partitions; }
 
     void add_partition(NonnullLockRefPtr<DiskPartition> disk_partition) { MUST(m_partitions.try_append(disk_partition)); }
 
     LUNAddress const& logical_unit_number_address() const { return m_logical_unit_number_address; }
 
+    u32 parent_controller_hardware_relative_id() const { return m_hardware_relative_controller_id; }
+
     virtual CommandSet command_set() const = 0;
 
     StringView command_set_to_string_view() const;
@@ -80,7 +79,12 @@ public:
     virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) final;
 
 protected:
-    StorageDevice(LUNAddress, MajorNumber, MinorNumber, size_t, u64, NonnullOwnPtr<KString>);
+    StorageDevice(LUNAddress, u32 hardware_relative_controller_id, size_t sector_size, u64);
+
+    // Note: We want to be able to put distinction between Storage devices and Ramdisk-based devices.
+    // We do this because it will make selecting ramdisk devices much more easier in boot time in the kernel commandline.
+    StorageDevice(Badge<RamdiskDevice>, LUNAddress, u32 hardware_relative_controller_id, MajorNumber, MinorNumber, size_t sector_size, u64);
+
     // ^DiskDevice
     virtual StringView class_name() const override;
 
@@ -91,9 +95,15 @@ private:
     mutable IntrusiveListNode<StorageDevice, LockRefPtr<StorageDevice>> m_list_node;
     NonnullLockRefPtrVector<DiskPartition> m_partitions;
 
-    // FIXME: Remove this method after figuring out another scheme for naming.
-    NonnullOwnPtr<KString> m_early_storage_device_name;
     LUNAddress const m_logical_unit_number_address;
+
+    // Note: This data member should be used with LUNAddress target_id and disk_id.
+    // LUNs are agnostic system-wide addresses, so they are assigned without caring about the specific hardware interfaces.
+    // This class member on the other side, is meant to be assigned *per hardware type*,
+    // which means in constrast to the LUNAddress controller_id struct member, we take the index of the hardware
+    // controller among its fellow controllers of the same hardware type in the system.
+    u32 const m_hardware_relative_controller_id { 0 };
+
     u64 m_max_addressable_block { 0 };
     size_t m_blocks_per_page { 0 };
 };