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

@@ -38,11 +38,12 @@ import { make_btrfs_filesystem_card } from "../btrfs/filesystem.jsx";
 import { make_btrfs_subvolume_pages } from "../btrfs/subvolume.jsx";
 
 import { new_page } from "../pages.jsx";
+import { register_available_block_space } from "../utils";
 
 /* 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 +63,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;
     }
 
@@ -114,6 +115,8 @@ export function make_block_page(parent, block, card) {
                    (content_block.IdUsage == "other" && content_block.IdType == "swap")) {
             card = make_swap_card(card, block, content_block);
         } else if (client.blocks_available[content_block.path]) {
+            if (!block.HintIgnore)
+                register_available_block_space(client, content_block);
             card = make_unformatted_data_card(card, block, content_block);
         } else {
             card = make_unrecognized_data_card(card, block, content_block);

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/pages.jsx

@@ -39,7 +39,10 @@ import { Spinner } from "@patternfly/react-core/dist/esm/components/Spinner/inde
 import { DescriptionListDescription, DescriptionListGroup, DescriptionListTerm } from "@patternfly/react-core/dist/esm/components/DescriptionList/index.js";
 import { Flex, FlexItem } from "@patternfly/react-core/dist/esm/layouts/Flex/index.js";
 
-import { decode_filename, block_short_name, fmt_size } from "./utils.js";
+import {
+    decode_filename, block_short_name, fmt_size,
+    reset_available_spaces
+} from "./utils.js";
 import { StorageButton, StorageBarMenu, StorageMenuItem, StorageSize } from "./storage-controls.jsx";
 import { MultipathAlert } from "./multipath.jsx";
 import { JobsPanel } from "./jobs-panel.jsx";
@@ -142,6 +145,7 @@ export const PAGE_CATEGORY_NETWORK = 3;
 export function reset_pages() {
     pages = new Map();
     crossrefs = new Map();
+    reset_available_spaces();
 }
 
 function name_from_card(card) {

pkg/storaged/partitions/partition-table.jsx

@@ -21,7 +21,11 @@ import cockpit from "cockpit";
 import React from "react";
 import client from "../client";
 
-import { get_partitions } from "../utils.js";
+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, register_available_free_space } from "../utils.js";
 import { StorageCard, ChildrenTable, new_page, new_card } from "../pages.jsx";
 import { format_dialog } from "../block/format-dialog.jsx";
 import { make_block_page } from "../block/create-pages.jsx";
@@ -68,9 +72,10 @@ function make_partition_pages(parent, block) {
         let p;
         for (i = 0; i < partitions.length; i++) {
             p = partitions[i];
-            if (p.type == 'free')
+            if (p.type == 'free') {
+                register_available_free_space(client, block, p);
                 make_free_space_page(parent, p.start, p.size, enable_dos_extended);
-            else if (p.type == 'container')
+            } else if (p.type == 'container')
                 make_extended_partition_page(parent, p);
             else {
                 const card = make_partition_card(null, p.block);
@@ -83,20 +88,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 +115,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

@@ -511,44 +511,32 @@ export function is_available_block(client, block, honor_ignore_hint) {
             !should_ignore(client, block.path));
 }
 
-export function get_available_spaces(client) {
-    function make(path) {
-        const block = client.blocks[path];
-        const parts = get_block_link_parts(client, path);
-        const text = cockpit.format(parts.format, parts.link);
-        return { type: 'block', block, size: block.Size, desc: text };
-    }
+let available_spaces = [];
 
-    const spaces = Object.keys(client.blocks).filter(p => is_available_block(client, client.blocks[p], true))
-            .sort(make_block_path_cmp(client))
-            .map(make);
-
-    function add_free_spaces(block) {
-        const parts = get_partitions(client, block);
-        let i;
-        let p;
-        let link_parts;
-        let text;
-        for (i in parts) {
-            p = parts[i];
-            if (p.type == 'free') {
-                link_parts = get_block_link_parts(client, block.path);
-                text = cockpit.format(link_parts.format, link_parts.link);
-                spaces.push({
-                    type: 'free',
-                    block,
-                    start: p.start,
-                    size: p.size,
-                    desc: cockpit.format(_("unpartitioned space on $0"), text)
-                });
-            }
-        }
-    }
+export function get_available_spaces() {
+    return available_spaces.sort((a, b) => block_cmp(a.block, b.block));
+}
+
+export function reset_available_spaces() {
+    available_spaces = [];
+}
 
-    for (const p in client.blocks_ptable)
-        add_free_spaces(client.blocks[p]);
+export function register_available_block_space(client, block) {
+    const parts = get_block_link_parts(client, block.path);
+    const text = cockpit.format(parts.format, parts.link);
+    available_spaces.push({ type: 'block', block, size: block.Size, desc: text });
+}
 
-    return spaces;
+export function register_available_free_space(client, block, partition) {
+    const link_parts = get_block_link_parts(client, block.path);
+    const text = cockpit.format(link_parts.format, link_parts.link);
+    available_spaces.push({
+        type: 'free',
+        block,
+        start: partition.start,
+        size: partition.size,
+        desc: cockpit.format(_("unpartitioned space on $0"), text)
+    });
 }
 
 export function prepare_available_spaces(client, spcs) {

test/verify/check-storage-lvm2

@@ -844,6 +844,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):