StorageInterface.h

/*
 * Copyright (c) [2004-2014] Novell, Inc.
 *
 * 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_INTERFACE_H
#define STORAGE_INTERFACE_H


#include <string>
#include <deque>
#include <list>
#include <map>

using std::string;
using std::deque;
using std::list;
using std::map;


#include "storage/StorageVersion.h"
#include "storage/StorageSwig.h"


namespace storage
{
    enum FsType { FSUNKNOWN, REISERFS, EXT2, EXT3, EXT4, BTRFS, VFAT, XFS, JFS, HFS, NTFS,
                  SWAP, HFSPLUS, NFS, NFS4, TMPFS, FSNONE };

    enum PartitionType { PRIMARY, EXTENDED, LOGICAL, PTYPE_ANY };

    enum MountByType { MOUNTBY_DEVICE, MOUNTBY_UUID, MOUNTBY_LABEL, MOUNTBY_ID, MOUNTBY_PATH };

    enum EncryptType { ENC_NONE, ENC_TWOFISH, ENC_TWOFISH_OLD,
                       ENC_TWOFISH256_OLD, ENC_LUKS, ENC_UNKNOWN };

    enum MdType { RAID_UNK, RAID0, RAID1, RAID5, RAID6, RAID10, MULTIPATH };

    enum MdParity { PAR_DEFAULT, LEFT_ASYMMETRIC, LEFT_SYMMETRIC,
                    RIGHT_ASYMMETRIC, RIGHT_SYMMETRIC, PAR_FIRST, PAR_LAST,
                    LEFT_ASYMMETRIC_6, LEFT_SYMMETRIC_6, RIGHT_ASYMMETRIC_6,
                    RIGHT_SYMMETRIC_6, PAR_FIRST_6,
                    PAR_NEAR_2, PAR_OFFSET_2, PAR_FAR_2,
                    PAR_NEAR_3, PAR_OFFSET_3, PAR_FAR_3 };

    enum MdArrayState { UNKNOWN, CLEAR, INACTIVE, SUSPENDED, READONLY, READ_AUTO,
                        CLEAN, ACTIVE, WRITE_PENDING, ACTIVE_IDLE };

    enum UsedByType { UB_NONE, UB_LVM, UB_MD, UB_MDPART, UB_DM, UB_DMRAID, UB_DMMULTIPATH, UB_BTRFS };

    enum CType { CUNKNOWN, DISK, MD, LOOP, LVM, DM, DMRAID, NFSC, DMMULTIPATH, MDPART, BTRFSC, TMPFSC };

    enum Transport { TUNKNOWN, SBP, ATA, FC, ISCSI, SAS, SATA, SPI, USB, FCOE };

    enum MultipathAutostart { MPAS_UNDECIDED, MPAS_ON, MPAS_OFF };

    enum PartAlign { ALIGN_OPTIMAL, ALIGN_CYLINDER };


    typedef void (*CallbackProgressBar)(const string& id, unsigned cur, unsigned max);

    typedef void (*CallbackShowInstallInfo)(const string& id);

    typedef void (*CallbackInfoPopup)(const string& text);

    typedef bool (*CallbackYesNoPopup)(const string& text);

    typedef bool (*CallbackCommitErrorPopup)(int error, const string& last_action,
                                             const string& extended_message);

    typedef bool (*CallbackPasswordPopup)(const string& device, int attempts, string& password);


    struct FsCapabilities
    {
        FsCapabilities() {}
        bool isExtendable;
        bool isExtendableWhileMounted;
        bool isReduceable;
        bool isReduceableWhileMounted;
        bool supportsUuid;
        bool supportsLabel;
        bool labelWhileMounted;
        unsigned int labelLength;
        unsigned long long minimalFsSizeK;
    };

    struct DlabelCapabilities
    {
        DlabelCapabilities() {}
        unsigned maxPrimary;
        bool extendedPossible;
        unsigned maxLogical;
        unsigned long long maxSectors;
    };


    struct UsedByInfo
    {
        UsedByInfo() : type(UB_NONE) {} // only for swig bindings
        UsedByInfo(UsedByType type, const string& device) : type(type), device(device) {}
        UsedByType type;
        string device;
    };


    struct ResizeInfo
    {
        ResizeInfo() : df_freeK(0), resize_freeK(0), usedK(0), resize_ok(false) {}
        unsigned long long df_freeK;
        unsigned long long resize_freeK;
        unsigned long long usedK;
        bool resize_ok;
    };


    struct ContentInfo
    {
        ContentInfo() : windows(false), efi(false), homes(0) {}
        bool windows;
        bool efi;
        unsigned homes;
    };


    struct DeviceInfo
    {
        DeviceInfo() {}

        string device;
        string name;

        string udevPath;
        list<string> udevId;

        list<UsedByInfo> usedBy;

        map<string, string> userdata;
    };


    struct ContainerInfo : public DeviceInfo
    {
        ContainerInfo() {}
        CType type;
        bool readonly;
    };

    struct DiskInfo
    {
        DiskInfo() {}
        unsigned long long sizeK;
        unsigned long long cylSize;
        unsigned long cyl;
        unsigned long heads;
        unsigned long sectors;
        unsigned int sectorSize;
        string disklabel;
        string orig_disklabel;
        unsigned maxPrimary;
        bool extendedPossible;
        unsigned maxLogical;
        bool initDisk;
        Transport transport;
        bool has_fake_partition;
    };

    struct LvmVgInfo
    {
        LvmVgInfo() {}
        unsigned long long sizeK;
        unsigned long long peSizeK;
        unsigned long peCount;
        unsigned long peFree;
        string uuid;
        bool lvm2;
        bool create;
        list<string> devices;
        list<string> devices_add;
        list<string> devices_rem;
    };

    struct DmPartCoInfo
    {
        DmPartCoInfo() {}
        DiskInfo d;
        list<string> devices;
        unsigned long minor;
    };

    struct DmraidCoInfo
    {
        DmraidCoInfo() {}
        DmPartCoInfo p;
    };

    struct DmmultipathCoInfo
    {
        DmmultipathCoInfo() {}
        DmPartCoInfo p;
        string vendor;
        string model;
    };

    struct VolumeInfo : public DeviceInfo
    {
        VolumeInfo() {}
        unsigned long long sizeK;
        unsigned long major;
        unsigned long minor;
        string mount;
        string crypt_device;
        MountByType mount_by;
        bool ignore_fstab;
        string fstab_options;
        string uuid;
        string label;
        string mkfs_options;
        string tunefs_options;
        string loop;
        string dtxt;
        EncryptType encryption;
        string crypt_pwd;
        FsType fs;
        FsType detected_fs;
        bool format;
        bool create;
        bool is_mounted;
        bool resize;
        bool ignore_fs;
        unsigned long long origSizeK;
    };

    struct RegionInfo
    {
        RegionInfo() : start(0), len(0) {}
        RegionInfo(unsigned long long start, unsigned long long len) : start(start), len(len) {}
        unsigned long long start;
        unsigned long long len;
    };

    struct PartitionAddInfo
    {
        PartitionAddInfo() {}
        unsigned nr;
        RegionInfo cylRegion;
        PartitionType partitionType;
        unsigned id;
        bool boot;
    };

    struct PartitionInfo
    {
        PartitionInfo() {}
        PartitionInfo& operator=( const PartitionAddInfo& rhs );
        VolumeInfo v;
        unsigned nr;
        RegionInfo cylRegion;
        PartitionType partitionType;
        unsigned id;
        bool boot;
    };

    struct LvmLvInfo
    {
        LvmLvInfo() {}
        VolumeInfo v;
        unsigned stripes;
        unsigned stripeSizeK;
        string uuid;
        string status;
        string dm_table;
        string dm_target;
        string origin;
        string used_pool;
        bool pool;
    };

    struct LvmLvSnapshotStateInfo
    {
        LvmLvSnapshotStateInfo() {}
        bool active;
        double allocated;
    };

    struct MdInfo
    {
        MdInfo() {}
        VolumeInfo v;
        unsigned nr;
        unsigned type;
        unsigned parity;
        string uuid;
        string sb_ver;
        unsigned long chunkSizeK;
        list<string> devices;
        list<string> spares;
        bool inactive;
    };

    struct MdStateInfo
    {
        MdStateInfo() {}
        MdArrayState state;
    };

    struct MdPartCoInfo
    {
        MdPartCoInfo() {}
        DiskInfo d;
        unsigned type;        // RAID level
        unsigned nr;          // MD device number
        unsigned parity;      // Parity (not for all RAID level)
        string   uuid;        // MD Device UUID
        string   sb_ver;      // Metadata version
        unsigned long chunkSizeK;  // Chunksize (strip size)
        list<string> devices;
        list<string> spares;
    };

    struct MdPartCoStateInfo
    {
        MdPartCoStateInfo() {}
        MdArrayState state;
    };

    struct MdPartInfo
    {
        MdPartInfo() {}
        VolumeInfo v;
        PartitionAddInfo p;
        bool part;
    };

    struct NfsInfo
    {
        NfsInfo() {}
        VolumeInfo v;
    };

    struct LoopInfo
    {
        LoopInfo() {}
        VolumeInfo v;
        bool reuseFile;
        unsigned nr;
        string file;
    };

    struct BtrfsInfo
    {
        BtrfsInfo() {}
        VolumeInfo v;
        list<string> devices;
        list<string> devices_add;
        list<string> devices_rem;
        list<string> subvol;
        list<string> subvol_add;
        list<string> subvol_rem;
    };

    struct TmpfsInfo
    {
        TmpfsInfo() {}
        VolumeInfo v;
    };

    struct DmInfo
    {
        DmInfo() {}
        VolumeInfo v;
        unsigned nr;
        string table;
        string target;
    };

    struct DmPartInfo
    {
        DmPartInfo() {}
        VolumeInfo v;
        PartitionAddInfo p;
        bool part;
        string table;
        string target;
    };

    struct DmraidInfo
    {
        DmraidInfo() {}
        DmPartInfo p;
    };

    struct DmmultipathInfo
    {
        DmmultipathInfo() {}
        DmPartInfo p;
    };

    struct ContVolInfo
    {
        ContVolInfo() : ctype(CUNKNOWN), num(-1) {}
        CType ctype;
        string cname;
        string cdevice;
        string vname;
        string vdevice;
        int num;
    };

    struct PartitionSlotInfo
    {
        PartitionSlotInfo() {}
        RegionInfo cylRegion;
        unsigned nr;
        string device;
        bool primarySlot;
        bool primaryPossible;
        bool extendedSlot;
        bool extendedPossible;
        bool logicalSlot;
        bool logicalPossible;
    };

    struct CommitInfo
    {
        CommitInfo() {}
        bool destructive;
        string text;
    };


    enum ErrorCodes
    {
        STORAGE_NO_ERROR = 0,

        DISK_PARTITION_OVERLAPS_EXISTING = -1000,
        DISK_PARTITION_EXCEEDS_DISK = -1001,
        DISK_CREATE_PARTITION_EXT_ONLY_ONCE = -1002,
        DISK_CREATE_PARTITION_EXT_IMPOSSIBLE = -1003,
        DISK_PARTITION_NO_FREE_NUMBER = -1004,
        DISK_CREATE_PARTITION_INVALID_VOLUME = -1005,
        DISK_CREATE_PARTITION_INVALID_TYPE = -1006,
        DISK_CREATE_PARTITION_PARTED_FAILED = -1007,
        DISK_PARTITION_NOT_FOUND = -1008,
        DISK_CREATE_PARTITION_LOGICAL_NO_EXT = -1009,
        DISK_PARTITION_LOGICAL_OUTSIDE_EXT = -1010,
        DISK_SET_TYPE_INVALID_VOLUME = -1011,
        DISK_SET_TYPE_PARTED_FAILED = -1012,
        DISK_SET_LABEL_PARTED_FAILED = -1013,
        DISK_REMOVE_PARTITION_PARTED_FAILED = -1014,
        DISK_REMOVE_PARTITION_INVALID_VOLUME = -1015,
        DISK_REMOVE_PARTITION_LIST_ERASE = -1016,
        DISK_DESTROY_TABLE_INVALID_LABEL = -1017,
        DISK_PARTITION_ZERO_SIZE = -1018,
        DISK_CHANGE_READONLY = -1019,
        DISK_RESIZE_PARTITION_INVALID_VOLUME = -1020,
        DISK_RESIZE_PARTITION_PARTED_FAILED = -1021,
        DISK_RESIZE_NO_SPACE = -1022,
        DISK_CHECK_RESIZE_INVALID_VOLUME = -1023,
        DISK_REMOVE_PARTITION_CREATE_NOT_FOUND = -1024,
        DISK_COMMIT_NOTHING_TODO = -1025,
        DISK_CREATE_PARTITION_NO_SPACE = -1026,
        DISK_REMOVE_USED_BY = -1027,
        DISK_INIT_NOT_POSSIBLE = -1028,
        DISK_INVALID_PARTITION_ID = -1029,

        STORAGE_DISK_NOT_FOUND = -2000,
        STORAGE_VOLUME_NOT_FOUND = -2001,
        STORAGE_REMOVE_PARTITION_INVALID_CONTAINER = -2002,
        STORAGE_CHANGE_PARTITION_ID_INVALID_CONTAINER = -2003,
        STORAGE_CHANGE_READONLY = -2004,
        STORAGE_DISK_USED_BY = -2005,
        STORAGE_LVM_VG_EXISTS = -2006,
        STORAGE_LVM_VG_NOT_FOUND = -2007,
        STORAGE_LVM_INVALID_DEVICE = -2008,
        STORAGE_CONTAINER_NOT_FOUND = -2009,
        STORAGE_VG_INVALID_NAME = -2010,
        STORAGE_REMOVE_USED_VOLUME = -2011,
        STORAGE_REMOVE_USING_UNKNOWN_TYPE = -2012,
        STORAGE_NOT_YET_IMPLEMENTED = -2013,
        STORAGE_MD_INVALID_NAME = -2014,
        STORAGE_MD_NOT_FOUND = -2015,
        STORAGE_MEMORY_EXHAUSTED = -2016,
        STORAGE_LOOP_NOT_FOUND = -2017,
        STORAGE_CREATED_LOOP_NOT_FOUND = -2018,
        STORAGE_CHANGE_AREA_INVALID_CONTAINER = -2023,
        STORAGE_BACKUP_STATE_NOT_FOUND = -2024,
        STORAGE_INVALID_FSTAB_VALUE = -2025,
        STORAGE_NO_FSTAB_PTR = -2026,
        STORAGE_DEVICE_NODE_NOT_FOUND = -2027,
        STORAGE_DMRAID_CO_NOT_FOUND = -2028,
        STORAGE_RESIZE_INVALID_CONTAINER = -2029,
        STORAGE_DMMULTIPATH_CO_NOT_FOUND = -2030,
        STORAGE_ZERO_DEVICE_FAILED = -2031,
        STORAGE_INVALID_BACKUP_STATE_NAME = -2032,
        STORAGE_MDPART_CO_NOT_FOUND = -2033,
        STORAGE_DEVICE_NOT_FOUND = -2034,
        STORAGE_BTRFS_CO_NOT_FOUND = -2035,
        STORAGE_TMPFS_CO_NOT_FOUND = -2036,
        STORAGE_VOLUME_NOT_ENCRYPTED = -2037,
        STORAGE_DM_RENAME_FAILED = -2038,

        VOLUME_COMMIT_UNKNOWN_STAGE = -3000,
        VOLUME_FSTAB_EMPTY_MOUNT = -3001,
        VOLUME_UMOUNT_FAILED = -3002,
        VOLUME_MOUNT_FAILED = -3003,
        VOLUME_FORMAT_UNKNOWN_FS = -3005,
        VOLUME_FORMAT_FS_UNDETECTED = -3006,
        VOLUME_FORMAT_FS_TOO_SMALL = -3007,
        VOLUME_FORMAT_FAILED = -3008,
        VOLUME_TUNE2FS_FAILED = -3009,
        VOLUME_MKLABEL_FS_UNABLE = -3010,
        VOLUME_MKLABEL_FAILED = -3011,
        VOLUME_LOSETUP_NO_LOOP = -3012,
        VOLUME_LOSETUP_FAILED = -3013,
        VOLUME_CRYPT_NO_PWD = -3014,
        VOLUME_CRYPT_PWD_TOO_SHORT = -3015,
        VOLUME_CRYPT_NOT_DETECTED = -3016,
        VOLUME_FORMAT_EXTENDED_UNSUPPORTED = -3017,
        VOLUME_MOUNT_EXTENDED_UNSUPPORTED = -3018,
        VOLUME_MOUNT_POINT_INVALID = -3019,
        VOLUME_MOUNTBY_NOT_ENCRYPTED = -3020,
        VOLUME_MOUNTBY_UNSUPPORTED_BY_FS = -3021,
        VOLUME_LABEL_NOT_SUPPORTED = -3022,
        VOLUME_LABEL_TOO_LONG = -3023,
        VOLUME_LABEL_WHILE_MOUNTED = -3024,
        VOLUME_RESIZE_UNSUPPORTED_BY_FS = -3025,
        VOLUME_RESIZE_UNSUPPORTED_BY_CONTAINER = -3026,
        VOLUME_RESIZE_FAILED = -3027,
        VOLUME_ALREADY_IN_USE = -3028,
        VOLUME_LOUNSETUP_FAILED = -3029,
        VOLUME_DEVICE_NOT_PRESENT = -3030,
        VOLUME_DEVICE_NOT_BLOCK = -3031,
        VOLUME_MOUNTBY_UNSUPPORTED_BY_VOLUME = -3032,
        VOLUME_CRYPTFORMAT_FAILED = -3033,
        VOLUME_CRYPTSETUP_FAILED = -3034,
        VOLUME_CRYPTUNSETUP_FAILED = -3035,
        VOLUME_FORMAT_NOT_IMPLEMENTED = -3036,
        VOLUME_FORMAT_IMPOSSIBLE = -3037,
        VOLUME_CRYPT_NFS_IMPOSSIBLE = -3038,
        VOLUME_REMOUNT_FAILED = -3039,
        VOLUME_TUNEREISERFS_FAILED = -3040,
        VOLUME_UMOUNT_NOT_MOUNTED = -3041,
        VOLUME_BTRFS_ADD_FAILED = -3042,
        VOLUME_CANNOT_TMP_MOUNT = -3043,
        VOLUME_CANNOT_TMP_UMOUNT = -3044,
        VOLUME_BTRFS_SUBVOL_INIT_FAILED = -3045,
        VOLUME_BTRFS_SUBVOL_SETDEFAULT = -3046,

        LVM_CREATE_PV_FAILED = -4000,
        LVM_PV_ALREADY_CONTAINED = -4001,
        LVM_PV_DEVICE_UNKNOWN = -4002,
        LVM_PV_DEVICE_USED = -4003,
        LVM_VG_HAS_NONE_PV = -4004,
        LVM_LV_INVALID_NAME = -4005,
        LVM_LV_DUPLICATE_NAME = -4006,
        LVM_LV_NO_SPACE = -4007,
        LVM_LV_UNKNOWN_NAME = -4008,
        LVM_LV_NOT_IN_LIST = -4009,
        LVM_VG_CREATE_FAILED = -4010,
        LVM_VG_EXTEND_FAILED = -4011,
        LVM_VG_REDUCE_FAILED = -4012,
        LVM_VG_REMOVE_FAILED = -4013,
        LVM_LV_CREATE_FAILED = -4014,
        LVM_LV_REMOVE_FAILED = -4015,
        LVM_LV_RESIZE_FAILED = -4016,
        LVM_PV_STILL_ADDED = -4017,
        LVM_PV_REMOVE_NOT_FOUND = -4018,
        LVM_CREATE_LV_INVALID_VOLUME = -4019,
        LVM_REMOVE_LV_INVALID_VOLUME = -4020,
        LVM_RESIZE_LV_INVALID_VOLUME = -4021,
        LVM_CHANGE_READONLY = -4022,
        LVM_CHECK_RESIZE_INVALID_VOLUME = -4023,
        LVM_COMMIT_NOTHING_TODO = -4024,
        LVM_LV_REMOVE_USED_BY = -4025,
        LVM_LV_ALREADY_ON_DISK = -4026,
        LVM_LV_NO_STRIPE_SIZE = -4027,
        LVM_LV_UNKNOWN_ORIGIN = -4028,
        LVM_LV_NOT_ON_DISK = -4029,
        LVM_LV_NOT_SNAPSHOT = -4030,
        LVM_LV_HAS_SNAPSHOTS = -4031,
        LVM_LV_IS_SNAPSHOT = -4032,
        LVM_LIST_EMPTY = -4033,
        LVM_LV_NO_POOL_OR_SNAP = -4034,
        LVM_LV_NO_POOL = -4035,
        LVM_LV_UNKNOWN_POOL = -4036,
        LVM_LV_INVALID_CHUNK_SIZE = -4037,
        LVM_LV_POOL_NO_FORMAT = -4038,
        LVM_LV_POOL_NO_MOUNT = -4039,

        FSTAB_ENTRY_NOT_FOUND = -5000,
        FSTAB_CHANGE_PREFIX_IMPOSSIBLE = -5001,
        FSTAB_REMOVE_ENTRY_NOT_FOUND = -5002,
        FSTAB_UPDATE_ENTRY_NOT_FOUND = -5003,
        FSTAB_ADD_ENTRY_FOUND = -5004,

        MD_CHANGE_READONLY = -6000,
        MD_DUPLICATE_NUMBER = -6001,
        MD_TOO_FEW_DEVICES = -6002,
        MD_DEVICE_UNKNOWN = -6003,
        MD_DEVICE_USED = -6004,
        MD_CREATE_INVALID_VOLUME = -6005,
        MD_REMOVE_FAILED = -6006,
        MD_NOT_IN_LIST = -6007,
        MD_CREATE_FAILED = -6008,
        MD_UNKNOWN_NUMBER = -6009,
        MD_REMOVE_USED_BY = -6010,
        MD_NUMBER_TOO_LARGE = -6011,
        MD_REMOVE_INVALID_VOLUME = -6012,
        MD_REMOVE_CREATE_NOT_FOUND = -6013,
        MD_NO_RESIZE_ON_DISK = -6014,
        MD_ADD_DUPLICATE = -6015,
        MD_REMOVE_NONEXISTENT = -6016,
        MD_NO_CHANGE_ON_DISK = -6017,
        MD_NO_CREATE_UNKNOWN = -6018,
        MD_STATE_NOT_ON_DISK = -6019,
        MD_PARTITION_NOT_FOUND = -6020,
        MD_INVALID_PARITY = -6021,
        MD_TOO_MANY_SPARES = -6022,
        MD_GET_STATE_FAILED = -6023,
        MD_DUPLICATE_NAME = -6024,

        MDPART_CHANGE_READONLY = -6100,
        MDPART_INTERNAL_ERR = -6101,
        MDPART_INVALID_VOLUME = -6012,
        MDPART_PARTITION_NOT_FOUND = -6103,
        MDPART_REMOVE_PARTITION_LIST_ERASE = -6104,
        MDPART_COMMIT_NOTHING_TODO = -6105,
        MDPART_NO_REMOVE = -6106,
        MDPART_DEVICE_NOT_FOUND = -6107,

        LOOP_CHANGE_READONLY = -7000,
        LOOP_DUPLICATE_FILE = -7001,
        LOOP_UNKNOWN_FILE = -7002,
        LOOP_REMOVE_USED_BY = -7003,
        LOOP_FILE_CREATE_FAILED = -7004,
        LOOP_CREATE_INVALID_VOLUME = -7005,
        LOOP_REMOVE_FILE_FAILED = -7006,
        LOOP_REMOVE_INVALID_VOLUME = -7007,
        LOOP_NOT_IN_LIST = -7008,
        LOOP_REMOVE_CREATE_NOT_FOUND = -7009,
        LOOP_MODIFY_EXISTING = -7010,

        PEC_PE_SIZE_INVALID = -9000,
        PEC_PV_NOT_FOUND = -9001,
        PEC_REMOVE_PV_IN_USE = -9002,
        PEC_REMOVE_PV_SIZE_NEEDED = -9003,
        PEC_LV_NO_SPACE_STRIPED = -9004,
        PEC_LV_NO_SPACE_SINGLE = -9005,
        PEC_LV_PE_DEV_NOT_FOUND = -9006,

        DM_CHANGE_READONLY = -10000,
        DM_UNKNOWN_TABLE = -10001,
        DM_REMOVE_USED_BY = -10002,
        DM_REMOVE_CREATE_NOT_FOUND = -10003,
        DM_REMOVE_INVALID_VOLUME = -10004,
        DM_REMOVE_FAILED = -10005,
        DM_NOT_IN_LIST = -10006,

        DASD_NOT_POSSIBLE = -11000,
        DASD_DASDFMT_FAILED = -11002,

        DMPART_CHANGE_READONLY = -12001,
        DMPART_INTERNAL_ERR = -12002,
        DMPART_INVALID_VOLUME = -12003,
        DMPART_PARTITION_NOT_FOUND = -12004,
        DMPART_REMOVE_PARTITION_LIST_ERASE = -12005,
        DMPART_COMMIT_NOTHING_TODO = -12006,
        DMPART_NO_REMOVE = -12007,

        DMRAID_REMOVE_FAILED = -13001,

        NFS_VOLUME_NOT_FOUND = -14001,
        NFS_CHANGE_READONLY = -14002,
        NFS_REMOVE_VOLUME_CREATE_NOT_FOUND = -14003,
        NFS_REMOVE_VOLUME_LIST_ERASE = -14004,
        NFS_REMOVE_INVALID_VOLUME = -14005,

        BTRFS_COMMIT_INVALID_VOLUME = -15001,
        BTRFS_CANNOT_TMP_MOUNT = -15002,
        BTRFS_CANNOT_TMP_UMOUNT = -15003,
        BTRFS_DELETE_SUBVOL_FAIL = -15004,
        BTRFS_CREATE_SUBVOL_FAIL = -15005,
        BTRFS_VOLUME_NOT_FOUND = -15006,
        BTRFS_SUBVOL_EXISTS = -15007,
        BTRFS_SUBVOL_NON_EXISTS = -15008,
        BTRFS_REMOVE_NOT_FOUND = -15009,
        BTRFS_REMOVE_NO_BTRFS = -15010,
        BTRFS_REMOVE_INVALID_VOLUME = -15011,
        BTRFS_CHANGE_READONLY = -15012,
        BTRFS_DEV_ALREADY_CONTAINED = -15013,
        BTRFS_DEVICE_UNKNOWN = -15014,
        BTRFS_DEVICE_USED = -15015,
        BTRFS_HAS_NONE_DEV = -15016,
        BTRFS_DEV_NOT_FOUND = -15017,
        BTRFS_EXTEND_FAIL = -15018,
        BTRFS_REDUCE_FAIL = -15019,
        BTRFS_LIST_EMPTY = -15020,
        BTRFS_RESIZE_INVALID_VOLUME = -15021,
        BTRFS_MULTIDEV_SHRINK_UNSUPPORTED = -15022,

        TMPFS_REMOVE_INVALID_VOLUME = -16001,
        TMPFS_REMOVE_NO_TMPFS = -16002,
        TMPFS_REMOVE_NOT_FOUND = -16003,

        CONTAINER_INTERNAL_ERROR = -99000,
        CONTAINER_INVALID_VIRTUAL_CALL = -99001,

    };


    class StorageInterface
    {
    public:

        StorageInterface () {}
        virtual ~StorageInterface () {}

        virtual void getContainers( deque<ContainerInfo>& infos) = 0;

        virtual int getDiskInfo( const string& disk, DiskInfo& info) = 0;

        virtual int getContDiskInfo( const string& disk, ContainerInfo& cinfo,
                                     DiskInfo& info ) = 0;

        virtual int getLvmVgInfo( const string& name, LvmVgInfo& info) = 0;

        virtual int getContLvmVgInfo( const string& name, ContainerInfo& cinfo,
                                      LvmVgInfo& info) = 0;

        virtual int getDmraidCoInfo( const string& name, DmraidCoInfo& info) = 0;

        virtual int getContDmraidCoInfo( const string& name, ContainerInfo& cinfo,
                                         DmraidCoInfo& info) = 0;

        virtual int getDmmultipathCoInfo( const string& name, DmmultipathCoInfo& info) = 0;

        virtual int getContDmmultipathCoInfo( const string& name, ContainerInfo& cinfo,
                                              DmmultipathCoInfo& info) = 0;

        virtual int getMdPartCoInfo( const string& name, MdPartCoInfo& info) = 0;


        virtual int getContMdPartCoInfo( const string& name, ContainerInfo& cinfo,
                                         MdPartCoInfo& info) = 0;

        virtual void setMultipathAutostart(MultipathAutostart multipath_autostart) = 0;

        virtual MultipathAutostart getMultipathAutostart() const = 0;

        virtual void getVolumes( deque<VolumeInfo>& infos) = 0;

        virtual int getVolume( const string& device, VolumeInfo& info) = 0;

        virtual int getPartitionInfo( const string& disk,
                                      deque<PartitionInfo>& plist ) = 0;

        virtual int getLvmLvInfo( const string& name,
                                  deque<LvmLvInfo>& plist ) = 0;

        virtual int getMdInfo( deque<MdInfo>& plist ) = 0;

        virtual int getMdPartInfo( const string& device,
                                   deque<MdPartInfo>& plist ) = 0;

        virtual int getNfsInfo( deque<NfsInfo>& plist ) = 0;

        virtual int getLoopInfo( deque<LoopInfo>& plist ) = 0;

        virtual int getDmInfo( deque<DmInfo>& plist ) = 0;

        virtual int getBtrfsInfo( deque<BtrfsInfo>& plist ) = 0;

        virtual int getTmpfsInfo( deque<TmpfsInfo>& plist ) = 0;

        virtual int getDmraidInfo( const string& name,
                                   deque<DmraidInfo>& plist ) = 0;

        virtual int getDmmultipathInfo( const string& name,
                                        deque<DmmultipathInfo>& plist ) = 0;

        virtual bool getFsCapabilities (FsType fstype, FsCapabilities& fscapabilities) const = 0;

        virtual bool getDlabelCapabilities(const string& dlabel,
                                           DlabelCapabilities& dlabelcapabilities) const = 0;

        virtual list<string> getAllUsedFs() const = 0;

        virtual int createPartition(const string& disk, PartitionType type,
                                    const RegionInfo& cylRegion,
                                    string& SWIG_OUTPUT(device)) = 0;

        virtual int resizePartition( const string& device,
                                     unsigned long sizeCyl ) = 0;

        virtual int resizePartitionNoFs( const string& device,
                                         unsigned long sizeCyl ) = 0;

        virtual int updatePartitionArea(const string& device, const RegionInfo& cylRegion) = 0;

        virtual int freeCylindersAroundPartition(const string& device,
                                                 unsigned long& SWIG_OUTPUT(freeCylsBefore),
                                                 unsigned long& SWIG_OUTPUT(freeCylsAfter)) = 0;

        virtual int nextFreePartition( const string& disk, PartitionType type,
                                       unsigned & SWIG_OUTPUT(nr),
                                       string& SWIG_OUTPUT(device) ) = 0;

        virtual int createPartitionKb(const string& disk, PartitionType type,
                                      const RegionInfo& kRegion,
                                      string& SWIG_OUTPUT(device)) = 0;

        virtual int createPartitionAny( const string& disk,
                                        unsigned long long sizeK,
                                        string& SWIG_OUTPUT(device) ) = 0;

        virtual int createPartitionMax( const string& disk, PartitionType type,
                                        string& SWIG_OUTPUT(device) ) = 0;

        virtual unsigned long long cylinderToKb( const string& disk,
                                                 unsigned long sizeCyl) = 0;

        virtual unsigned long kbToCylinder( const string& disk,
                                            unsigned long long sizeK) = 0;

        virtual int removePartition (const string& partition) = 0;

        virtual int changePartitionId (const string& partition, unsigned id) = 0;

        virtual int forgetChangePartitionId (const string& partition ) = 0;

        virtual string getPartitionPrefix(const string& disk) = 0;

        virtual string getPartitionName(const string& disk, int partition_no) = 0;

        virtual int getUnusedPartitionSlots(const string& disk, list<PartitionSlotInfo>& slots) = 0;

        virtual int destroyPartitionTable (const string& disk, const string& label) = 0;

        virtual int initializeDisk( const string& disk, bool value ) = 0;

        virtual string defaultDiskLabel(const string& device) = 0;

        virtual int changeFormatVolume( const string& device, bool format, FsType fs ) = 0;

        virtual int changeLabelVolume( const string& device, const string& label ) = 0;

        virtual int changeMkfsOptVolume( const string& device, const string& opts ) = 0;

        virtual int changeTunefsOptVolume( const string& device, const string& opts ) = 0;

        virtual int changeMountPoint( const string& device, const string& mount ) = 0;

        virtual int getMountPoint( const string& device,
                                   string& SWIG_OUTPUT(mount) ) = 0;

        virtual int changeMountBy( const string& device, MountByType mby ) = 0;

        virtual int getMountBy( const string& device,
                                MountByType& SWIG_OUTPUT(mby) ) = 0;

        virtual int changeFstabOptions( const string& device, const string& options ) = 0;

        virtual int getFstabOptions( const string& device,
                                     string& SWIG_OUTPUT(options) ) = 0;


        virtual int addFstabOptions( const string& device, const string& options ) = 0;

        virtual int removeFstabOptions( const string& device, const string& options ) = 0;

        virtual int setCryptPassword( const string& device, const string& pwd ) = 0;

        virtual int forgetCryptPassword( const string& device ) = 0;

        virtual int getCryptPassword( const string& device,
                                      string& SWIG_OUTPUT(pwd) ) = 0;

        virtual int verifyCryptPassword( const string& device,
                                         const string& pwd, bool erase ) = 0;

        virtual bool needCryptPassword( const string& device ) = 0;

        virtual int setCrypt( const string& device, bool val ) = 0;

        virtual int setCryptType( const string& device, bool val, EncryptType typ ) = 0;

        virtual int getCrypt( const string& device, bool& SWIG_OUTPUT(val) ) = 0;

        virtual int setIgnoreFstab( const string& device, bool val ) = 0;

        virtual int getIgnoreFstab( const string& device, bool& SWIG_OUTPUT(val) ) = 0;

        virtual int changeDescText( const string& device, const string& txt ) = 0;

        virtual int addFstabEntry( const string& device, const string& mount,
                                   const string& vfs, const string& options,
                                   unsigned freq, unsigned passno ) = 0;


        virtual int resizeVolume(const string& device, unsigned long long newSizeK) = 0;

        virtual int resizeVolumeNoFs(const string& device, unsigned long long newSizeK) = 0;

        virtual int forgetResizeVolume( const string& device ) = 0;

        virtual void setRecursiveRemoval( bool val ) = 0;

        virtual bool getRecursiveRemoval() const = 0;

        virtual int getRecursiveUsing(const list<string>& devices, bool itself,
                                      list<string>& using_devices) = 0;

        virtual int getRecursiveUsedBy(const list<string>& devices, bool itself,
                                       list<string>& usedby_devices) = 0;

        virtual void setZeroNewPartitions( bool val ) = 0;

        virtual bool getZeroNewPartitions() const = 0;

        virtual void setPartitionAlignment( PartAlign val ) = 0;

        virtual PartAlign getPartitionAlignment() const = 0;

        virtual void setDefaultMountBy( MountByType val ) = 0;

        virtual MountByType getDefaultMountBy() const = 0;

        virtual void setDefaultFs(FsType val) = 0;

        virtual FsType getDefaultFs() const = 0;

        virtual void setDefaultSubvolName( const string& val) = 0;

        virtual string getDefaultSubvolName() const = 0;

        virtual bool getEfiBoot() = 0;

        virtual void setRootPrefix( const string& root ) = 0;

        virtual string getRootPrefix() const = 0;

        virtual void setDetectMountedVolumes( bool val ) = 0;

        virtual bool getDetectMountedVolumes() const = 0;

        virtual int removeVolume( const string& device ) = 0;

        virtual int createLvmVg( const string& name,
                                 unsigned long long peSizeK, bool lvm1,
                                 const deque<string>& devs ) = 0;

        virtual int removeLvmVg( const string& name ) = 0;

        virtual int extendLvmVg( const string& name,
                                 const deque<string>& devs ) = 0;

        virtual int shrinkLvmVg( const string& name,
                                 const deque<string>& devs ) = 0;

        virtual int createLvmLv( const string& vg, const string& name,
                                 unsigned long long sizeK, unsigned stripes,
                                 string& SWIG_OUTPUT(device) ) = 0;

        virtual int removeLvmLvByDevice( const string& device ) = 0;

        virtual int removeLvmLv( const string& vg, const string& name ) = 0;

        virtual int changeLvStripeCount( const string& vg, const string& name,
                                         unsigned long stripes ) = 0;

        virtual int changeLvStripeSize( const string& vg, const string& name,
                                        unsigned long long stripeSizeK) = 0;

        virtual int createLvmLvSnapshot(const string& vg, const string& origin,
                                        const string& name, unsigned long long cowSizeK,
                                        string& SWIG_OUTPUT(device) ) = 0;

        virtual int removeLvmLvSnapshot(const string& vg, const string& name) = 0;

        virtual int getLvmLvSnapshotStateInfo(const string& vg, const string& name,
                                              LvmLvSnapshotStateInfo& info) = 0;

        virtual int createLvmLvPool(const string& vg, const string& name,
                                    unsigned long long sizeK,
                                    string& SWIG_OUTPUT(device) ) = 0;

        virtual int createLvmLvThin(const string& vg, const string& name,
                                    const string& pool,
                                    unsigned long long sizeK,
                                    string& SWIG_OUTPUT(device) ) = 0;

        virtual int changeLvChunkSize( const string& vg, const string& name,
                                       unsigned long long chunkSizeK) = 0;

        virtual int nextFreeMd(unsigned& SWIG_OUTPUT(nr),
                               string& SWIG_OUTPUT(device)) = 0;

        virtual int createMd(const string& name, MdType md_type, const list<string>& devices,
                             const list<string>& spares) = 0;

        virtual int createMdAny(MdType md_type, const list<string>& devices,
                                const list<string>& spares,
                                string& SWIG_OUTPUT(device) ) = 0;

        virtual int removeMd( const string& name, bool destroySb ) = 0;

        virtual int extendMd(const string& name, const list<string>& devices,
                             const list<string>& spares) = 0;

        virtual int updateMd(const string& name, const list<string>& devices,
                             const list<string>& spares) = 0;

        virtual int shrinkMd(const string& name, const list<string>& devices,
                             const list<string>& spares) = 0;

        virtual int changeMdType(const string& name, MdType md_type) = 0;

        virtual int changeMdChunk(const string& name, unsigned long chunkSizeK) = 0;

        virtual int changeMdParity( const string& name, MdParity ptype ) = 0;

        virtual int checkMd( const string& name ) = 0;

        virtual int getMdStateInfo(const string& name, MdStateInfo& info) = 0;

        virtual int getMdPartCoStateInfo(const string& name,
                                         MdPartCoStateInfo& info) = 0;

        virtual int computeMdSize(MdType md_type, const list<string>& devices,
                                  const list<string>& spares, unsigned long long& SWIG_OUTPUT(sizeK)) = 0;

        virtual list<int> getMdAllowedParity(MdType md_type, unsigned devnr) = 0;

        virtual int removeMdPartCo(const string& name, bool destroySb ) = 0;

        virtual int addNfsDevice(const string& nfsDev, const string& opts,
                                 unsigned long long sizeK, const string& mp,
                                 bool nfs4) = 0;

        virtual int checkNfsDevice(const string& nfsDev, const string& opts,
                                   bool nfs4, unsigned long long& SWIG_OUTPUT(sizeK)) = 0;

        virtual int createFileLoop( const string& lname, bool reuseExisting,
                                    unsigned long long sizeK,
                                    const string& mp, const string& pwd,
                                    string& SWIG_OUTPUT(device) ) = 0;

        virtual int modifyFileLoop( const string& device, const string& lname,
                                    bool reuseExisting,
                                    unsigned long long sizeK ) = 0;

        virtual int removeFileLoop( const string& lname, bool removeFile ) = 0;

        virtual int removeDmraid( const string& name ) = 0;

        virtual bool existSubvolume( const string& device, const string& name ) = 0;

        virtual int createSubvolume( const string& device, const string& name ) = 0;

        virtual int removeSubvolume( const string& device, const string& name ) = 0;

        virtual int extendBtrfsVolume( const string& name,
                                       const deque<string>& devs ) = 0;

        virtual int shrinkBtrfsVolume( const string& name,
                                       const deque<string>& devs ) = 0;

        virtual int addTmpfsMount( const string& mp, const string& opts ) = 0;

        virtual int removeTmpfsMount( const string& mp ) = 0;

        virtual void getCommitInfos(list<CommitInfo>& infos) const = 0;

        virtual const string& getLastAction() const = 0;

        virtual const string& getExtendedErrorMessage() const = 0;

// temporarily disable callback function for swig
#ifndef SWIG

        virtual void setCallbackProgressBar(CallbackProgressBar pfnc) = 0;

        virtual CallbackProgressBar getCallbackProgressBar() const = 0;


        virtual void setCallbackShowInstallInfo(CallbackShowInstallInfo pfnc) = 0;

        virtual CallbackShowInstallInfo getCallbackShowInstallInfo() const = 0;


        virtual void setCallbackInfoPopup(CallbackInfoPopup pfnc) = 0;

        virtual CallbackInfoPopup getCallbackInfoPopup() const = 0;


        virtual void setCallbackYesNoPopup(CallbackYesNoPopup pfnc) = 0;

        virtual CallbackYesNoPopup getCallbackYesNoPopup() const = 0;


        virtual void setCallbackCommitErrorPopup(CallbackCommitErrorPopup pfnc) = 0;

        virtual CallbackCommitErrorPopup getCallbackCommitErrorPopup() const = 0;


        virtual void setCallbackPasswordPopup(CallbackPasswordPopup pfnc) = 0;

        virtual CallbackPasswordPopup getCallbackPasswordPopup() const = 0;

#endif

        virtual void setCacheChanges (bool cache) = 0;

        virtual bool isCacheChanges () const = 0;

        virtual int commit() = 0;

        virtual string getErrorString(int error) const = 0;

        virtual int createBackupState( const string& name ) = 0;

        virtual int restoreBackupState( const string& name ) = 0;

        virtual bool checkBackupState(const string& name) const = 0;

        virtual bool equalBackupStates(const string& lhs, const string& rhs,
                                       bool verbose_log) const = 0;

        virtual int removeBackupState( const string& name ) = 0;

        virtual bool checkDeviceMounted(const string& device, list<string>& mps) = 0;

        virtual bool umountDevice( const string& device ) = 0;

        virtual bool umountDeviceUns( const string& device, bool unsetup ) = 0;

        virtual bool mountDevice( const string& device, const string& mp ) = 0;

        virtual int activateEncryption( const string& device, bool on ) = 0;

        virtual bool mountDeviceOpts( const string& device, const string& mp,
                                      const string& opts ) = 0;

        virtual bool mountDeviceRo( const string& device, const string& mp,
                                    const string& opts ) = 0;

        virtual bool checkDmMapsTo( const string& device ) = 0;

        virtual void removeDmTableTo( const string& device ) = 0;

        virtual int renameCryptDm( const string& device,
                                   const string& new_name ) = 0;

        virtual bool getFreeInfo(const string& device, bool get_resize, ResizeInfo& resize_info,
                                 bool get_content, ContentInfo& content_info, bool use_cache) = 0;

        virtual bool readFstab( const string& dir, deque<VolumeInfo>& infos) = 0;

        virtual void activateHld( bool val ) = 0;

        virtual void activateMultipath( bool val ) = 0;

        virtual void rescanEverything() = 0;

        virtual bool rescanCryptedObjects() = 0;

        virtual void dumpObjectList() = 0;

        virtual void dumpCommitInfos() const = 0;

        virtual int getContVolInfo(const string& dev, ContVolInfo& info) = 0;

        virtual int setUserdata(const string& device, const map<string, string>& userdata) = 0;

        virtual int getUserdata(const string& device, map<string, string>& userdata) = 0;

    };


    void initDefaultLogger( const string& logdir );

    typedef void (*CallbackLogDo)( int level, const string& component, const char* file,
                                   int line, const char* function, const string& content );

    typedef bool (*CallbackLogQuery)( int level, const string& component );

    void setLogDoCallback( CallbackLogDo pfc );

    CallbackLogDo getLogDoCallback();

    void setLogQueryCallback( CallbackLogQuery pfc );

    CallbackLogQuery getLogQueryCallback();

    struct Environment
    {
        Environment(bool readonly, const string& logdir = "/var/log/YaST2")
            : readonly(readonly), testmode(false), autodetect(true),
              instsys(false), logdir(logdir), testdir("tmp")
            {
            storage::initDefaultLogger( logdir );
            }

        bool readonly;
        bool testmode;
        bool autodetect;
        bool instsys;
        string logdir;
        string testdir;
    };


    StorageInterface* createStorageInterface(const Environment& env);


    StorageInterface* createStorageInterfacePid(const Environment& env, int& SWIG_OUTPUT(locker_pid));


    void destroyStorageInterface(StorageInterface*);

}


#endif