storage: Detect partition tables in unsupported places

These likely belong to virtual machines and we shouldn't touch them.

See https://bugzilla.redhat.com/show_bug.cgi?id=2364699

Author: mvollmer

pkg/storaged/block/create-pages.jsx

@@ -42,7 +42,7 @@ import { new_page } from "../pages.jsx";
 /* CARD must have page_name, page_location, and page_size set.
  */
 
-export function make_block_page(parent, block, card) {
+export function make_block_page(parent, block, card, options) {
     let is_crypto = block.IdUsage == 'crypto';
     let content_block = is_crypto ? client.blocks_cleartext[block.path] : block;
     const fstab_config = get_fstab_config(content_block || block, true);
@@ -62,7 +62,7 @@ export function make_block_page(parent, block, card) {
     const single_device_volume = block_btrfs_blockdev && block_btrfs_blockdev.data.num_devices === 1;
 
     if (client.blocks_ptable[block.path]) {
-        make_partition_table_page(parent, block, card);
+        make_partition_table_page(parent, block, card, options && options.partitionable);
         return;
     }
 

pkg/storaged/block/other.jsx

@@ -49,7 +49,7 @@ export function make_other_page(parent, block) {
         actions: partitionable_block_actions(block),
     });
 
-    make_block_page(parent, block, other_card);
+    make_block_page(parent, block, other_card, { partitionable: true });
 }
 
 const OtherCard = ({ card, block }) => {

pkg/storaged/drive/drive.jsx

@@ -105,7 +105,7 @@ export function make_drive_page(parent, drive) {
     }
 
     if (block.Size > 0) {
-        make_block_page(parent, block, card);
+        make_block_page(parent, block, card, { partitionable: true });
     } else {
         new_page(parent, card);
     }

pkg/storaged/mdraid/mdraid.jsx

@@ -247,7 +247,7 @@ export function make_mdraid_page(parent, mdraid) {
     if (!block) {
         new_page(parent, mdraid_card);
     } else
-        make_block_page(parent, block, mdraid_card);
+        make_block_page(parent, block, mdraid_card, { partitionable: true });
 }
 
 const MDRaidCard = ({ card, mdraid, block }) => {

pkg/storaged/partitions/partition-table.jsx

@@ -21,6 +21,10 @@ import cockpit from "cockpit";
 import React from "react";
 import client from "../client";
 
+import { Alert } from "@patternfly/react-core/dist/esm/components/Alert/index.js";
+
+import { CardBody } from "@patternfly/react-core/dist/esm/components/Card/index.js";
+
 import { get_partitions } from "../utils.js";
 import { StorageCard, ChildrenTable, new_page, new_card } from "../pages.jsx";
 import { format_dialog } from "../block/format-dialog.jsx";
@@ -83,20 +87,21 @@ function make_partition_pages(parent, block) {
                        block_ptable.Type == 'dos');
 }
 
-export function make_partition_table_page(parent, block, next_card) {
+export function make_partition_table_page(parent, block, next_card, partitionable) {
     const block_ptable = client.blocks_ptable[block.path];
 
     const parts_card = new_card({
         title: (block_ptable.Type
             ? cockpit.format(_("$0 partitions"), block_ptable.Type.toLocaleUpperCase())
             : _("Partitions")),
         next: next_card,
-        component: PartitionsCard,
+        component: partitionable ? PartitionsCard : UnexpectedPartitionsCard,
         props: { },
     });
 
     const p = new_page(parent, parts_card, { sorted: false });
-    make_partition_pages(p, block);
+    if (partitionable)
+        make_partition_pages(p, block);
 }
 
 const PartitionsCard = ({ card }) => {
@@ -109,3 +114,15 @@ const PartitionsCard = ({ card }) => {
         </StorageCard>
     );
 };
+
+const UnexpectedPartitionsCard = ({ card }) => {
+    return (
+        <StorageCard card={card}>
+            <CardBody>
+                <Alert isInline isPlain variant="info" title={_("Unexpected partitions")}>
+                    <p>{_("Partitions are not supported on this block device. If it is used as a disk for a virtual machine, the partitions must be managed by the operating system inside the virtual machine.")}</p>
+                </Alert>
+            </CardBody>
+        </StorageCard>
+    );
+};

pkg/storaged/utils.js

@@ -500,14 +500,19 @@ export function is_available_block(client, block, honor_ignore_hint) {
         return !!block && client.blocks_swap[block.path];
     }
 
+    function part_is_for_vm() {
+        const table_block = client.blocks[block_part.Table];
+        return table_block && !client.drives[table_block.Drive] && !client.mdraids[table_block.MDRaid];
+    }
+
     return (!(block.HintIgnore && honor_ignore_hint) &&
             block.Size > 0 &&
             !has_fs_label() &&
             !is_mpath_member() &&
             !is_vdo_backing_dev() &&
             !is_swap() &&
             !block_ptable &&
-            !(block_part && block_part.IsContainer) &&
+            !(block_part && (block_part.IsContainer || part_is_for_vm())) &&
             !should_ignore(client, block.path));
 }
 
@@ -524,6 +529,13 @@ export function get_available_spaces(client) {
             .map(make);
 
     function add_free_spaces(block) {
+        /* Only offer to create partitions on Disks and MDRaids,
+           partition tables in other locations very likely belong to
+           virtual machines.
+         */
+        if (!client.drives[block.Drive] && !client.mdraids[block.MDRaid])
+            return;
+
         const parts = get_partitions(client, block);
         let i;
         let p;

test/verify/check-storage-lvm2

@@ -841,6 +841,31 @@ class TestStorageLvm2(storagelib.StorageCase):
             b.wait_in_text(self.card_desc("LVM2 logical volume", "Physical volumes"), bn(disk))
             b.wait_in_text(self.card_desc("LVM2 logical volume", "Physical volumes"), bn(disk2))
 
+    def testUnsupportedPartitions(self):
+        b = self.browser
+        m = self.machine
+
+        self.login_and_go("/storage")
+
+        dev_1 = self.add_ram_disk(100)
+        m.execute(f"vgcreate vgroup0 {dev_1}")
+        self.addCleanupVG("vgroup0")
+        m.execute("lvcreate vgroup0 -n lvol0 -l100%FREE")
+        m.execute("parted /dev/vgroup0/lvol0 -s mktable gpt mkpart primary ext2 1M 50M")
+        self.addCleanup(m.execute, "parted /dev/vgroup0/lvol0 -s mktable gpt; wipefs -a /dev/vgroup0/lvol0")
+
+        b.wait_text(self.card_row_col("Storage", row_name="lvol0", col_index=3), "GPT partitions")
+        self.click_card_row("Storage", name="lvol0")
+        b.wait_in_text(self.card("GPT partitions"), "Partitions are not supported on this block device.")
+
+        # Neither the partition nor the free space should be offered
+        # for creating new things.
+
+        b.click(self.card_parent_link())
+        b.click(self.card_parent_link())
+        self.click_devices_dropdown("Create LVM2 volume group")
+        b.wait_in_text("#dialog", "No disks are available")
+
 
 class TestStorageLvm2Destructive(storagelib.StorageCase):