Partition.h

/*
 * Copyright (c) [2014-2015] Novell, Inc.
 * Copyright (c) [2016-2026] SUSE LLC
 *
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, contact Novell, Inc.
 *
 * To contact Novell about this file by physical or electronic mail, you may
 * find current contact information at www.novell.com.
 */
 
 
#ifndef STORAGE_PARTITION_H
#define STORAGE_PARTITION_H
 
 
#include "storage/Devices/BlkDevice.h"
 
 
namespace storage
{
 
    class PartitionTable;
    class Partitionable;
    class SystemInfo;
    class Arch;
 
 
    enum class PartitionType {
 
        PRIMARY,
 
        EXTENDED,
 
        LOGICAL
 
    };
 
 
    std::string get_partition_type_name(PartitionType partition_type);
 
 
    enum IdNum : unsigned int {
 
        ID_DOS12 = 0x01,
 
        ID_DOS16 = 0x06,
 
        ID_NTFS = 0x07,
 
        ID_DOS32 = 0x0c,
 
        ID_EXTENDED = 0x0f,
 
        ID_DIAG = 0x12,
 
        ID_PREP = 0x41,
 
        ID_SWAP = 0x82,
 
        ID_LINUX = 0x83,
 
        ID_IRST = 0x84,
 
        ID_LVM = 0x8e,
 
        ID_RAID = 0xfd,
 
        ID_XBOOTLDR = 0xea,
 
        ID_ESP = 0xef,
 
        ID_UNKNOWN = 0x100,
 
        ID_BIOS_BOOT,
 
        ID_WINDOWS_BASIC_DATA,
 
        ID_MICROSOFT_RESERVED,
 
        ID_LINUX_HOME,
 
        ID_LINUX_SERVER_DATA,
 
        ID_LINUX_ROOT_ARM,
 
        ID_LINUX_ROOT_AARCH64,
 
        ID_LINUX_ROOT_PPC32,
 
        ID_LINUX_ROOT_PPC64BE,
 
        ID_LINUX_ROOT_PPC64LE,
 
        ID_LINUX_ROOT_RISCV32,
 
        ID_LINUX_ROOT_RISCV64,
 
        ID_LINUX_ROOT_S390,
 
        ID_LINUX_ROOT_S390X,
 
        ID_LINUX_ROOT_X86,
 
        ID_LINUX_ROOT_X86_64,
 
        ID_LINUX_USR_ARM,
 
        ID_LINUX_USR_AARCH64,
 
        ID_LINUX_USR_PPC32,
 
        ID_LINUX_USR_PPC64BE,
 
        ID_LINUX_USR_PPC64LE,
 
        ID_LINUX_USR_RISCV32,
 
        ID_LINUX_USR_RISCV64,
 
        ID_LINUX_USR_S390,
 
        ID_LINUX_USR_S390X,
 
        ID_LINUX_USR_X86,
 
        ID_LINUX_USR_X86_64,
 
    };
 
 
    std::string get_partition_id_name(IdNum partition_id);
 
 
    bool is_linux_partition_id(IdNum id);
 
 
    enum class LinuxPartitionIdCategory
    {
        ROOT, USR
    };
 
 
    bool is_linux_partition_id(IdNum id, LinuxPartitionIdCategory linux_partition_id_category);
 
 
    IdNum get_linux_partition_id(LinuxPartitionIdCategory linux_partition_id_category, const Arch& arch);
 
 
    IdNum get_linux_partition_id(LinuxPartitionIdCategory linux_partition_id_category, SystemInfo& system_info);
 
 
    class Partition : public BlkDevice
    {
    public:
 
        static Partition* create(Devicegraph* devicegraph, const std::string& name,
                                 const Region& region, PartitionType type);
 
        static Partition* load(Devicegraph* devicegraph, const xmlNode* node);
 
        unsigned int get_number() const;
 
        PartitionType get_type() const;
 
        void set_type(PartitionType type);
 
        unsigned int get_id() const;
 
        void set_id(unsigned int id);
 
        bool is_boot() const;
 
        void set_boot(bool boot);
 
        bool is_legacy_boot() const;
 
        void set_legacy_boot(bool legacy_boot);
 
        bool is_no_automount() const;
 
        void set_no_automount(bool no_automount);
 
        const std::string& get_label() const;
 
        void set_label(const std::string& label);
 
        const std::string& get_uuid() const;
 
        PartitionTable* get_partition_table();
 
        const PartitionTable* get_partition_table() const;
 
        Partitionable* get_partitionable();
 
        const Partitionable* get_partitionable() const;
 
        Region get_unused_surrounding_region() const;
 
        static Partition* find_by_name(Devicegraph* devicegraph, const std::string& name);
 
        static const Partition* find_by_name(const Devicegraph* devicegraph, const std::string& name);
 
        static bool compare_by_number(const Partition* lhs, const Partition* rhs);
 
    public:
 
        class Impl;
 
        Impl& get_impl();
        const Impl& get_impl() const;
 
        virtual Partition* clone() const override;
        virtual std::unique_ptr<Device> clone_v2() const override;
 
        Partition(Impl* impl);
        ST_NO_SWIG Partition(std::unique_ptr<Device::Impl>&& impl);
 
    };
 
 
    bool is_partition(const Device* device);
 
    Partition* to_partition(Device* device);
 
    const Partition* to_partition(const Device* device);
 
}
 
#endif