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_MAX,
};
 
#define DAOS_PROP_PO_EC_CELL_SZ_MIN (1UL << 10)
#define DAOS_PROP_PO_EC_CELL_SZ_MAX (1UL << 30)
 
#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,
};
 
#define DAOS_SELF_HEAL_AUTO_EXCLUDE (1U << 0)
#define DAOS_SELF_HEAL_AUTO_REBUILD (1U << 1)
 
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_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,
    DAOS_PROP_CO_REDUN_RF1,
    DAOS_PROP_CO_REDUN_RF2,
    DAOS_PROP_CO_REDUN_RF3,
    DAOS_PROP_CO_REDUN_RF4,
};
 
enum {
    DAOS_PROP_CO_REDUN_MIN  = 1,
    DAOS_PROP_CO_REDUN_RANK = 1, 
    DAOS_PROP_CO_REDUN_MAX  = 254,
};
 
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);
}
 
struct daos_prop_entry {
    uint32_t         dpe_type;
    uint32_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)
 
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 && strnlen(label, 36) == 36) {
        bool        is_uuid = true;
        const char  *p;
 
        for (i = 0, p = label; i < 36; i++, p++) {
            if (i == 8 || i == 13 || i == 18 || i == 23) {
                if (*p != '-') {
                    is_uuid = false;
                    break;
                }
                continue;
            }
            if (!isxdigit(*p)) {
                is_uuid = false;
                break;
            }
        }
 
        if (is_uuid)
            return false;
    }
 
    return true;
}
 
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);
 
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_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);
 
#if defined(__cplusplus)
}
#endif
 
#endif /* __DAOS_PROP_H__ */