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_TP_UNKNOWN,
    DAOS_TP_HDD,
    DAOS_TP_SSD,
    DAOS_TP_PM,
    DAOS_TP_VM,
} daos_target_type_t;
 
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 {
    daos_target_type_t  ta_type;
    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,
};
 
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;
    int16_t                 rs_padding16;
 
    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_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__ */