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