daos_pool.h

 
#ifndef __DAOS_POOL_H__
#define __DAOS_POOL_H__
 
#if defined(__cplusplus)
extern "C" {
#endif
 
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_SCM  = 0,
    DAOS_MEDIA_NVME,
    DAOS_MEDIA_MAX
};
 
struct daos_space {
    /* Total space in bytes */
    uint64_t        s_total[DAOS_MEDIA_MAX];
    /* Free space in bytes */
    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 {
    /* Aggregated space for all live targets */
    struct daos_space   ps_space;
    /* Min target free space in bytes */
    uint64_t        ps_free_min[DAOS_MEDIA_MAX];
    /* Max target free space in bytes */
    uint64_t        ps_free_max[DAOS_MEDIA_MAX];
    /* Average target free space in bytes */
    uint64_t        ps_free_mean[DAOS_MEDIA_MAX];
    /* Target(VOS) count */
    uint32_t        ps_ntargets;
    uint32_t        ps_padding;
};
 
struct daos_rebuild_status {
    uint32_t        rs_version;
    uint32_t        rs_seconds;
    int32_t         rs_errno;
    int32_t         rs_done;
 
    /* padding of rebuild status */
    int32_t         rs_padding32;
 
    /* Failure on which rank */
    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_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];
};
 
#define DAOS_SYS_NAME_MAX_LEN 127
 
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 *tgts, 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);
 
int
daos_pool_connect2(const char *pool, const char *sys, unsigned int flags,
           daos_handle_t *poh, daos_pool_info_t *info, daos_event_t *ev);
 
 
#if defined(__cplusplus)
}
#define daos_pool_connect daos_pool_connect_cpp
static inline int
daos_pool_connect_cpp(const char *pool, const char *sys, unsigned int flags, daos_handle_t *poh,
              daos_pool_info_t *info, daos_event_t *ev)
{
    return daos_pool_connect2(pool, sys, flags, poh, info, ev);
}
 
static inline int
daos_pool_connect_cpp(const uuid_t pool, const char *sys, unsigned int flags, daos_handle_t *poh,
              daos_pool_info_t *info, daos_event_t *ev)
{
    char str[37];
 
    uuid_unparse(pool, str);
    return daos_pool_connect2(str, sys, flags, poh, info, ev);
}
#else
#define daos_pool_connect(po, ...)                  \
    ({                              \
        int _ret;                       \
        char _str[37];                      \
        const char *__str = NULL;               \
        if (d_is_string(po)) {                  \
            __str = (const char *)(po);         \
        } else if (d_is_uuid(po)) {             \
            uuid_unparse((unsigned char *)(po), _str);  \
            __str = _str;                   \
        }                           \
        _ret = daos_pool_connect2(__str, __VA_ARGS__);      \
        _ret;                           \
    })
#endif
 
#endif /* __DAOS_POOL_H__ */