daos_pool.h

#ifndef __DAOS_POOL_H__
#define __DAOS_POOL_H__
 
#define daos_pool_connect daos_pool_connect2
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#include <inttypes.h>
#include <uuid/uuid.h>
 
#include <daos_prop.h>

typedef enum {
    DAOS_TS_UNKNOWN,
    /* Not available */
    DAOS_TS_DOWN_OUT,
    /* Not available, may need rebuild */
    DAOS_TS_DOWN,
    /* Up */
    DAOS_TS_UP,
    /* Up and running */
    DAOS_TS_UP_IN,
    /* Intermediate state for pool map change */
    DAOS_TS_NEW,
    /* Being drained */
    DAOS_TS_DRAIN,
} daos_target_state_t;

typedef struct {
    int         foo;
} daos_target_perf_t;
 

enum daos_media_type_t {
    DAOS_MEDIA_SCM  = 0,
    DAOS_MEDIA_NVME,
    DAOS_MEDIA_MAX
};

struct daos_space {
    uint64_t        s_total[DAOS_MEDIA_MAX];
    uint64_t        s_free[DAOS_MEDIA_MAX];
};

typedef struct {
    uint32_t                ta_padding;
    daos_target_state_t ta_state;
    daos_target_perf_t  ta_perf;
    struct daos_space   ta_space;
} daos_target_info_t;

struct daos_pool_space {
    struct daos_space   ps_space;
    uint64_t        ps_free_min[DAOS_MEDIA_MAX];
    uint64_t        ps_free_max[DAOS_MEDIA_MAX];
    uint64_t        ps_free_mean[DAOS_MEDIA_MAX];
    uint32_t        ps_ntargets;
    uint32_t        ps_padding;
};
 
enum daos_rebuild_state_t {
    DRS_IN_PROGRESS     = 0,
    DRS_NOT_STARTED     = 1,
    DRS_COMPLETED       = 2,
};

enum daos_rebuild_status_flag {
    DAOS_RSF_DEGRADED = (1 << 0),
};

struct daos_rebuild_status {
    uint32_t        rs_version;
    uint32_t        rs_seconds;
    int32_t         rs_errno;
    union {
        int32_t     rs_state;
        int32_t     rs_done;
    };
    uint16_t                rs_max_supported_layout_ver;
    uint8_t                 rs_flags;
    uint8_t                 rs_reserved_;

    int32_t         rs_fail_rank;
    uint64_t        rs_toberb_obj_nr;
    uint64_t        rs_obj_nr;
    uint64_t        rs_rec_nr;

    uint64_t        rs_size;
};

enum daos_pool_info_bit {
    DPI_SPACE = 1ULL << 0,
    DPI_REBUILD_STATUS = 1ULL << 1,
    DPI_ENGINES_ENABLED = 1ULL << 2,
    DPI_ENGINES_DISABLED = 1ULL << 3,
    DPI_ENGINES_DEAD = 1ULL << 4,
    DPI_REBUILD_MAX_LAYOUT_VER = 1ULL << 5,
    DPI_SELF_HEAL_POLICY = 1ULL << 6,
    DPI_ALL = -1,
};

typedef struct {
    uuid_t              pi_uuid;
    uint32_t            pi_ntargets;
    uint32_t            pi_nnodes;
    uint32_t            pi_ndisabled;
    uint32_t            pi_map_ver;
    uint32_t            pi_leader;
    uint64_t            pi_bits;
    struct daos_pool_space      pi_space;
    struct daos_rebuild_status  pi_rebuild_st;
} daos_pool_info_t;

struct daos_pool_cont_info {
    uuid_t      pci_uuid;
    char        pci_label[DAOS_PROP_LABEL_MAX_LEN+1];
};

struct daos_pool_cont_info2 {
    struct daos_pool_cont_info  pci_id;

    daos_cont_info_t        pci_cinfo;

    void                *pci_reserved[2];
};

int
daos_pool_connect(const char *pool, const char *sys, unsigned int flags,
          daos_handle_t *poh, daos_pool_info_t *info, daos_event_t *ev);

int
daos_pool_disconnect(daos_handle_t poh, daos_event_t *ev);
 
/*
 * Handle API
 */

int
daos_pool_local2global(daos_handle_t poh, d_iov_t *glob);

int
daos_pool_global2local(d_iov_t glob, daos_handle_t *poh);

int
daos_pool_query(daos_handle_t poh, d_rank_list_t **ranks, daos_pool_info_t *info,
        daos_prop_t *pool_prop, daos_event_t *ev);

int
daos_pool_query_target(daos_handle_t poh, uint32_t tgt, d_rank_t rank,
               daos_target_info_t *info, daos_event_t *ev);

int
daos_pool_list_attr(daos_handle_t poh, char *buffer, size_t *size,
            daos_event_t *ev);

int
daos_pool_get_attr(daos_handle_t poh, int n, char const *const names[],
           void *const buffers[], size_t sizes[], daos_event_t *ev);

int
daos_pool_set_attr(daos_handle_t poh, int n, char const *const names[],
           void const *const values[], size_t const sizes[],
           daos_event_t *ev);

int
daos_pool_del_attr(daos_handle_t poh, int n, char const *const names[],
           daos_event_t *ev);

int
daos_pool_list_cont(daos_handle_t poh, daos_size_t *ncont,
            struct daos_pool_cont_info *cbuf, daos_event_t *ev);

enum daos_pool_cont_filter_func {
    PCF_FUNC_EQ = 0,
    PCF_FUNC_NE,
    PCF_FUNC_LT,
    PCF_FUNC_LE,
    PCF_FUNC_GT,
    PCF_FUNC_GE,
    /* future: add more functions */
    PCF_FUNC_MAX
};

static inline const char *
daos_pool_cont_filter_func_str(enum daos_pool_cont_filter_func f)
{
    switch(f) {
    case PCF_FUNC_EQ:
        return "==";
    case PCF_FUNC_NE:
        return "!=";
    case PCF_FUNC_LT:
        return "<";
    case PCF_FUNC_LE:
        return "<=";
    case PCF_FUNC_GT:
        return ">";
    case PCF_FUNC_GE:
        return ">=";
    default:
        return "UNKNOWN";
    }
}

enum daos_pool_cont_filter_key {
    PCF_KEY_MD_OTIME = 0,
    PCF_KEY_MD_MTIME,
    PCF_KEY_NUM_SNAPSHOTS,
    PCF_KEY_NUM_HANDLES,
    PCF_KEY_MAX
};

static inline const char *
daos_pool_cont_filter_key_str(enum daos_pool_cont_filter_key k)
{
    switch(k) {
    case PCF_KEY_MD_OTIME:
        return "md_open_time";
    case PCF_KEY_MD_MTIME:
        return "md_modify_time";
    case PCF_KEY_NUM_SNAPSHOTS:
        return "num_snapshots";
    case PCF_KEY_NUM_HANDLES:
        return "num_handles";
    default:
        return "UNKNOWN";
    }
}

typedef struct daos_pool_cont_filter_part {
    uint32_t            pcfp_func;

    uint32_t            pcfp_key;

    union {
        uint64_t        pcfp_val64;
        d_string_t      pcfp_valstr;
    };
} daos_pool_cont_filter_part_t;

enum daos_pool_cont_filter_combine {
    PCF_COMBINE_LOGICAL_AND = 0,
    PCF_COMBINE_LOGICAL_OR,
};

typedef struct daos_pool_cont_filter {
    uint32_t                pcf_combine_func;
    uint32_t                pcf_nparts;
    struct daos_pool_cont_filter_part     **pcf_parts;
} daos_pool_cont_filter_t;

#define DAOS_POOL_CONT_FILTER_MAX_NPARTS (8)

int
daos_pool_cont_filter_init(daos_pool_cont_filter_t *filt, uint32_t combine_func);

int
daos_pool_cont_filter_add(daos_pool_cont_filter_t *filt, daos_pool_cont_filter_part_t *part);

void
daos_pool_cont_filter_fini(daos_pool_cont_filter_t *filt);

int
daos_pool_filter_cont(daos_handle_t poh, daos_pool_cont_filter_t *filter,
              daos_size_t *ncont, struct daos_pool_cont_info2 *cbuf, daos_event_t *ev);

int
daos_pool_get_perms(daos_prop_t *pool_prop, uid_t uid, gid_t *gids, size_t nr_gids,
            uint64_t *perms);
 
#if defined(__cplusplus)
}
#endif
 
#endif /* __DAOS_POOL_H__ */