daos_prop.h

 
#ifndef __DAOS_PROP_H__
#define __DAOS_PROP_H__
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#include <ctype.h>
#include <daos_types.h>

enum daos_pool_props {
    DAOS_PROP_PO_MIN = 0,
    DAOS_PROP_PO_LABEL,
    DAOS_PROP_PO_ACL,
    DAOS_PROP_PO_SPACE_RB,
    DAOS_PROP_PO_SELF_HEAL,
    DAOS_PROP_PO_RECLAIM,
    DAOS_PROP_PO_OWNER,
    DAOS_PROP_PO_OWNER_GROUP,
    DAOS_PROP_PO_SVC_LIST,
    DAOS_PROP_PO_EC_CELL_SZ,
    DAOS_PROP_PO_DATA_THRESH,
    DAOS_PROP_PO_REDUN_FAC,
    DAOS_PROP_PO_EC_PDA,
    DAOS_PROP_PO_RP_PDA,

    DAOS_PROP_PO_GLOBAL_VERSION,
    DAOS_PROP_PO_UPGRADE_STATUS,
    /*
     * Schedule that the checksum scrubber will run. See
     * DAOS_SCRUBBER_SCHED_*
     *
     * default: DAOS_SCRUB_MODE_OFF
     */
    DAOS_PROP_PO_SCRUB_MODE,
    DAOS_PROP_PO_SCRUB_FREQ,
    DAOS_PROP_PO_SCRUB_THRESH,
    DAOS_PROP_PO_SVC_REDUN_FAC,
    DAOS_PROP_PO_OBJ_VERSION,
    DAOS_PROP_PO_PERF_DOMAIN,
    DAOS_PROP_PO_CHECKPOINT_MODE,
    DAOS_PROP_PO_CHECKPOINT_FREQ,
    DAOS_PROP_PO_CHECKPOINT_THRESH,
    DAOS_PROP_PO_REINT_MODE,
    DAOS_PROP_PO_SVC_OPS_ENABLED,
    DAOS_PROP_PO_SVC_OPS_ENTRY_AGE,
    DAOS_PROP_PO_CA_CERT,
    DAOS_PROP_PO_CERT_WATERMARKS,
    DAOS_PROP_PO_MAX,
};
 
#define DAOS_PROP_PO_NUM                (DAOS_PROP_PO_MAX - DAOS_PROP_PO_MIN - 1)

struct daos_prop_byteval {
    void  *dpb_data;
    size_t dpb_len;
};
 
#define DAOS_PROP_BYTEVAL_MAX_LEN       (1U << 20)
 
#define DAOS_PROP_PO_EC_CELL_SZ_MIN (1UL << 10)
#define DAOS_PROP_PO_EC_CELL_SZ_MAX (1UL << 30)
 
#define DAOS_PROP_PO_REDUN_FAC_MAX  4
#define DAOS_PROP_PO_REDUN_FAC_DEFAULT  3
 
static inline bool
daos_rf_is_valid(unsigned long long rf)
{
    return rf <= DAOS_PROP_PO_REDUN_FAC_MAX;
}
 
#define DAOS_PROP_PDA_MAX   ((uint32_t)-1)
#define DAOS_PROP_PO_RP_PDA_DEFAULT DAOS_PROP_PDA_MAX
#define DAOS_PROP_PO_EC_PDA_DEFAULT ((uint32_t)1)

enum {
    DAOS_UPGRADE_STATUS_NOT_STARTED = 0,
    DAOS_UPGRADE_STATUS_IN_PROGRESS = 1,
    DAOS_UPGRADE_STATUS_COMPLETED = 2,
    DAOS_UPGRADE_STATUS_FAILED = 3,
};
 
#define DAOS_PROP_PO_SVC_REDUN_FAC_MAX      4
#define DAOS_PROP_PO_SVC_REDUN_FAC_DEFAULT  2
 
static inline bool
daos_svc_rf_is_valid(uint64_t svc_rf)
{
    return svc_rf <= DAOS_PROP_PO_SVC_REDUN_FAC_MAX;
}

enum {
    DAOS_PROP_PERF_DOMAIN_ROOT  = 255,
    DAOS_PROP_PERF_DOMAIN_GROUP = 200,
};

#define DAOS_PROP_PO_PERF_DOMAIN_DEFAULT    DAOS_PROP_PERF_DOMAIN_ROOT
#define DAOS_PROP_CO_PERF_DOMAIN_DEFAULT    DAOS_PROP_PERF_DOMAIN_ROOT

#define DAOS_PROP_PO_NUM    (DAOS_PROP_PO_MAX - DAOS_PROP_PO_MIN - 1)

enum {
    DAOS_RECLAIM_DISABLED = 0,
    DAOS_RECLAIM_LAZY,
    DAOS_RECLAIM_SNAPSHOT,
    DAOS_RECLAIM_BATCH,
    DAOS_RECLAIM_TIME,
};
 
enum {
    DAOS_REINT_MODE_DATA_SYNC = 0,
    DAOS_REINT_MODE_NO_DATA_SYNC = 1,
    DAOS_REINT_MODE_INCREMENTAL = 2,
};

#define DAOS_PROP_PO_REINT_MODE_DEFAULT DAOS_REINT_MODE_DATA_SYNC

enum {
    DAOS_SCRUB_MODE_OFF = 0,
    DAOS_SCRUB_MODE_LAZY = 1,
    DAOS_SCRUB_MODE_TIMED = 2,
    DAOS_SCRUB_MODE_INVALID = 3,
};
 
/* Checksum Scrubbing Defaults */
#define DAOS_PROP_PO_SCRUB_MODE_DEFAULT DAOS_SCRUB_MODE_OFF
 
#define DAOS_PROP_PO_SCRUB_FREQ_DEFAULT 604800 /* 1 week in seconds */
#define DAOS_PROP_PO_SCRUB_THRESH_DEFAULT 0

enum {
    DAOS_CHECKPOINT_DISABLED = 0,
    DAOS_CHECKPOINT_TIMED,
    DAOS_CHECKPOINT_LAZY,
};
 
#define DAOS_PROP_PO_CHECKPOINT_MODE_DEFAULT   DAOS_CHECKPOINT_TIMED
#define DAOS_PROP_PO_CHECKPOINT_FREQ_DEFAULT   5         /* 5 seconds */
#define DAOS_PROP_PO_CHECKPOINT_FREQ_MIN       1         /* 1 seconds */
#define DAOS_PROP_PO_CHECKPOINT_FREQ_MAX       (1 << 20) /* 1 million seconds */
#define DAOS_PROP_PO_CHECKPOINT_THRESH_DEFAULT 50        /* 50 % WAL capacity */
#define DAOS_PROP_PO_CHECKPOINT_THRESH_MAX     75        /* 75 % WAL capacity */
#define DAOS_PROP_PO_CHECKPOINT_THRESH_MIN     10        /* 10 % WAL capacity */
#define DAOS_PROP_PO_SVC_OPS_ENABLED_DEFAULT   1         /* true: enabled by default */
#define DAOS_PROP_PO_SVC_OPS_ENTRY_AGE_DEFAULT 300       /* 300 seconds */
#define DAOS_PROP_PO_SVC_OPS_ENTRY_AGE_MIN     60        /* 60 seconds */
#define DAOS_PROP_PO_SVC_OPS_ENTRY_AGE_MAX     600       /* 600 seconds */

#define DAOS_SELF_HEAL_AUTO_EXCLUDE (1U << 0)
#define DAOS_SELF_HEAL_AUTO_REBUILD (1U << 1)
#define DAOS_SELF_HEAL_DELAY_REBUILD    (1U << 2)

enum daos_cont_props {
    DAOS_PROP_CO_MIN = 0x1000,
    DAOS_PROP_CO_LABEL,
    DAOS_PROP_CO_LAYOUT_TYPE,
    DAOS_PROP_CO_LAYOUT_VER,
    DAOS_PROP_CO_CSUM,
    DAOS_PROP_CO_CSUM_CHUNK_SIZE,
    DAOS_PROP_CO_CSUM_SERVER_VERIFY,
    DAOS_PROP_CO_REDUN_FAC,
    DAOS_PROP_CO_REDUN_LVL,
    DAOS_PROP_CO_SNAPSHOT_MAX,
    DAOS_PROP_CO_ACL,
    DAOS_PROP_CO_COMPRESS,
    DAOS_PROP_CO_ENCRYPT,
    DAOS_PROP_CO_OWNER,
    DAOS_PROP_CO_OWNER_GROUP,
    DAOS_PROP_CO_DEDUP,
    DAOS_PROP_CO_DEDUP_THRESHOLD,
    DAOS_PROP_CO_ROOTS,
    DAOS_PROP_CO_STATUS,
    DAOS_PROP_CO_ALLOCED_OID,
    DAOS_PROP_CO_EC_CELL_SZ,
    DAOS_PROP_CO_EC_PDA,
    DAOS_PROP_CO_RP_PDA,
    DAOS_PROP_CO_GLOBAL_VERSION,
    DAOS_PROP_CO_SCRUBBER_DISABLED,
    DAOS_PROP_CO_OBJ_VERSION,
    DAOS_PROP_CO_PERF_DOMAIN,
    DAOS_PROP_CO_MAX,
};

struct daos_prop_co_roots {
    daos_obj_id_t   cr_oids[4];
};

#define DAOS_PROP_CO_NUM    (DAOS_PROP_CO_MAX - DAOS_PROP_CO_MIN - 1)
 
typedef uint16_t daos_cont_layout_t;

enum {
    DAOS_PROP_CO_LAYOUT_UNKNOWN,
    DAOS_PROP_CO_LAYOUT_UNKOWN = DAOS_PROP_CO_LAYOUT_UNKNOWN,
    DAOS_PROP_CO_LAYOUT_POSIX,  
    DAOS_PROP_CO_LAYOUT_HDF5,   
    DAOS_PROP_CO_LAYOUT_PYTHON, 
    DAOS_PROP_CO_LAYOUT_SPARK,  
    DAOS_PROP_CO_LAYOUT_DATABASE,   
    DAOS_PROP_CO_LAYOUT_ROOT,   
    DAOS_PROP_CO_LAYOUT_SEISMIC,    
    DAOS_PROP_CO_LAYOUT_METEO,  
    DAOS_PROP_CO_LAYOUT_MAX
};

enum {
    DAOS_PROP_CO_CSUM_OFF,
    DAOS_PROP_CO_CSUM_CRC16,
    DAOS_PROP_CO_CSUM_CRC32,
    DAOS_PROP_CO_CSUM_CRC64,
    DAOS_PROP_CO_CSUM_SHA1,
    DAOS_PROP_CO_CSUM_SHA256,
    DAOS_PROP_CO_CSUM_SHA512,
    DAOS_PROP_CO_CSUM_ADLER32
};

enum {
    DAOS_PROP_CO_CSUM_SV_OFF,
    DAOS_PROP_CO_CSUM_SV_ON
};

enum {
    DAOS_PROP_CO_DEDUP_OFF,
    DAOS_PROP_CO_DEDUP_MEMCMP,
    DAOS_PROP_CO_DEDUP_HASH
};

enum {
    DAOS_PROP_CO_COMPRESS_OFF,
    DAOS_PROP_CO_COMPRESS_LZ4,
    DAOS_PROP_CO_COMPRESS_DEFLATE, 
    DAOS_PROP_CO_COMPRESS_DEFLATE1,
    DAOS_PROP_CO_COMPRESS_DEFLATE2,
    DAOS_PROP_CO_COMPRESS_DEFLATE3,
    DAOS_PROP_CO_COMPRESS_DEFLATE4,
};

enum {
    DAOS_PROP_CO_ENCRYPT_OFF,
    DAOS_PROP_CO_ENCRYPT_AES_XTS128,
    DAOS_PROP_CO_ENCRYPT_AES_XTS256,
    DAOS_PROP_CO_ENCRYPT_AES_CBC128,
    DAOS_PROP_CO_ENCRYPT_AES_CBC192,
    DAOS_PROP_CO_ENCRYPT_AES_CBC256,
    DAOS_PROP_CO_ENCRYPT_AES_GCM128,
    DAOS_PROP_CO_ENCRYPT_AES_GCM256
};

enum {
    DAOS_PROP_CO_REDUN_RF0  = 0,
    DAOS_PROP_CO_REDUN_RF1  = 1,
    DAOS_PROP_CO_REDUN_RF2  = 2,
    DAOS_PROP_CO_REDUN_RF3  = 3,
    DAOS_PROP_CO_REDUN_RF4  = 4,
    DAOS_RF_MAX     = 4,
};

enum {
    DAOS_PROP_CO_REDUN_MIN = 1,
    /* server rank (engine) level */
    DAOS_PROP_CO_REDUN_RANK = 1,
    /* server node level */
    DAOS_PROP_CO_REDUN_NODE = 2,
    /* pool fault domain level */
    DAOS_PROP_CO_REDUN_FAULT = 3,
    DAOS_PROP_CO_REDUN_MAX   = 254,
};

#define DAOS_PROP_CO_REDUN_DEFAULT  DAOS_PROP_CO_REDUN_NODE

enum {
    /* in healthy status, data protection work as expected */
    DAOS_PROP_CO_HEALTHY,
    /* in unclean status, data protection possibly cannot work.
     * typical scenario - cascading failed targets exceed the container
     * redundancy factor, that possibly cause lost data cannot be detected
     * or rebuilt.
     */
    DAOS_PROP_CO_UNCLEAN,
};

#define DAOS_PROP_CO_CLEAR  (0x1)

struct daos_co_status {
    uint16_t    dcs_status;
    uint16_t    dcs_flags;
    uint32_t    dcs_pm_ver;
};
 
#define DAOS_PROP_CO_STATUS_VAL(status, flag, pm_ver)           \
    ((((uint64_t)(flag)) << 48)     |           \
     (((uint64_t)(status) & 0xFFFF) << 32)  |           \
     ((uint64_t)(pm_ver)))
 
static inline uint64_t
daos_prop_co_status_2_val(struct daos_co_status *co_status)
{
    return DAOS_PROP_CO_STATUS_VAL(co_status->dcs_status,
                       co_status->dcs_flags,
                       co_status->dcs_pm_ver);
}
 
static inline void
daos_prop_val_2_co_status(uint64_t val, struct daos_co_status *co_status)
{
    co_status->dcs_flags = (uint16_t)(val >> 48);
    co_status->dcs_status = (uint16_t)((val >> 32) & 0xFFFF);
    co_status->dcs_pm_ver = (uint32_t)(val & 0xFFFFFFFF);
}
 
enum {
    DAOS_PROP_ENTRY_NOT_SET = (1 << 0),
};

struct daos_prop_entry {
    uint32_t         dpe_type;
    uint16_t         dpe_flags;
    uint16_t         dpe_reserv;
    union {
        uint64_t     dpe_val;
        d_string_t   dpe_str;
        void        *dpe_val_ptr;
    };
};

#define DAOS_PROP_ENTRIES_MAX_NR    (128)

#define DAOS_PROP_LABEL_MAX_LEN     (127)
#define DAOS_PROP_MAX_LABEL_BUF_LEN (DAOS_PROP_LABEL_MAX_LEN + 1)

#define DAOS_PROP_CO_LABEL_DEFAULT "container_label_not_set"
#define DAOS_PROP_PO_LABEL_DEFAULT "pool_label_not_set"

static inline bool
daos_label_is_valid(const char *label)
{
    int len;
    int i;
    bool    maybe_uuid = false;

    if (label == NULL)
        return false;

    len = strnlen(label, DAOS_PROP_LABEL_MAX_LEN + 1);
    if (len == 0 || len > DAOS_PROP_LABEL_MAX_LEN)
        return false;

    for (i = 0; i < len; i++) {
        char c = label[i];
 
        if (isalnum(c) || c == '.' || c == '_' || c == ':')
            continue;
        if (c == '-') {
            maybe_uuid = true;
            continue;
        }
 
        return false;
    }

    if (maybe_uuid && daos_is_valid_uuid_string(label, UUID_SST_NONE))
        return false;
 
    return true;
}
 
/* default data threshold size of 4KiB */
#define DAOS_PROP_PO_DATA_THRESH_DEFAULT (1UL << 12)
 
/* For the case of no label is set for the pool. */
#define DAOS_PROP_NO_PO_LABEL       "pool_label_not_set"
 
/* Default container label */
#define DEFAULT_CONT_LABEL      "container_label_not_set"
 
/* For the case of no label is set for the container. */
#define DAOS_PROP_NO_CO_LABEL       DEFAULT_CONT_LABEL

static inline bool
daos_perf_domain_is_valid(const char *perf_domain)
{
    return daos_label_is_valid(perf_domain);
}

typedef struct {
    uint32_t         dpp_nr;
    uint32_t         dpp_reserv;
    struct daos_prop_entry  *dpp_entries;
} daos_prop_t;

daos_prop_t *
daos_prop_alloc(uint32_t entries_nr);

void
daos_prop_fini(daos_prop_t *prop);

void
daos_prop_free(daos_prop_t *prop);

int
daos_prop_from_str(const char *str, daos_size_t len, daos_prop_t **prop);

int
daos_prop_merge2(daos_prop_t *old_prop, daos_prop_t *new_prop, daos_prop_t **out_prop);

daos_prop_t *
daos_prop_merge(daos_prop_t *old_prop, daos_prop_t *new_prop);

struct daos_prop_entry *
daos_prop_entry_get(daos_prop_t *prop, uint32_t type);

int
daos_prop_set_str(daos_prop_t *prop, uint32_t type, const char *str, daos_size_t len);

int
daos_prop_entry_set_str(struct daos_prop_entry *entry, const char *str, daos_size_t len);

int
daos_prop_set_ptr(daos_prop_t *prop, uint32_t type, const void *ptr, daos_size_t size);

int
daos_prop_entry_set_ptr(struct daos_prop_entry *entry, const void *ptr, daos_size_t size);

int
daos_prop_entry_dup_ptr(struct daos_prop_entry *entry_dst,
            struct daos_prop_entry *entry_src, size_t len);

int
daos_prop_set_byteval(daos_prop_t *prop, uint32_t type, const void *data, size_t len);

int
daos_prop_entry_set_byteval(struct daos_prop_entry *entry, const void *data, size_t len);

int
daos_prop_entry_dup_byteval(struct daos_prop_entry *entry_dst, struct daos_prop_entry *entry_src);

int
daos_prop_entry_cmp_acl(struct daos_prop_entry *entry1,
            struct daos_prop_entry *entry2);

int
daos_prop_entry_dup_co_roots(struct daos_prop_entry *dst,
                 struct daos_prop_entry *src);

bool
daos_prop_has_str(struct daos_prop_entry *entry);

bool
daos_prop_has_ptr(struct daos_prop_entry *entry);

bool
daos_prop_has_byteval(struct daos_prop_entry *entry);

bool
daos_prop_byteval_is_valid(struct daos_prop_entry *entry);

static inline bool
daos_prop_is_set(struct daos_prop_entry *entry)
{
    if (entry->dpe_flags & DAOS_PROP_ENTRY_NOT_SET)
        return false;
 
    return true;
}
 
#if defined(__cplusplus)
}
#endif
 
#endif /* __DAOS_PROP_H__ */