daos_types.h

 
#ifndef DAOS_TYPES_H
#define DAOS_TYPES_H
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#include <limits.h>

#include <uuid/uuid.h>
#include <cart/types.h>
 
#include <daos_errno.h>

#define DAOS_SYS_NAME_MAX 15

#define DAOS_SYS_INFO_STRING_MAX 63

 
typedef uint64_t    daos_size_t;
typedef uint64_t    daos_off_t;
 
#define crt_proc_daos_key_t crt_proc_d_iov_t
#define crt_proc_daos_size_t    crt_proc_uint64_t
#define crt_proc_daos_epoch_t   crt_proc_uint64_t

#define DAOS_HKEY_MAX   32
 
typedef enum {
    DAOS_ANCHOR_TYPE_ZERO   = 0,
    DAOS_ANCHOR_TYPE_HKEY   = 1,
    DAOS_ANCHOR_TYPE_KEY    = 2,
    DAOS_ANCHOR_TYPE_EOF    = 3,
} daos_anchor_type_t;
 
#define DAOS_ANCHOR_BUF_MAX 104
typedef struct {
    uint16_t    da_type;    
    uint16_t    da_shard;   
    uint32_t    da_flags;   
    uint64_t    da_sub_anchors; 
    uint8_t     da_buf[DAOS_ANCHOR_BUF_MAX];    
} daos_anchor_t;
 
#define DAOS_ANCHOR_INIT    { .da_type = DAOS_ANCHOR_TYPE_ZERO, \
                  .da_shard = 0,            \
                  .da_flags = 0,            \
                  .da_sub_anchors = 0,          \
                  .da_buf = { 0 } }

typedef struct {
    uint64_t    cookie;
} daos_handle_t;
 
#define DAOS_HDL_INVAL  ((daos_handle_t){0})
#define DAOS_TX_NONE    DAOS_HDL_INVAL
 
static inline bool
daos_handle_is_inval(daos_handle_t hdl)
{
    return hdl.cookie == 0;
}
 
static inline bool
daos_handle_is_valid(daos_handle_t hdl)
{
    return !daos_handle_is_inval(hdl);
}

#define DAOS_PC_RO  (1U << 0)
#define DAOS_PC_RW  (1U << 1)
#define DAOS_PC_EX  (1U << 2)
 
#define DAOS_PC_NBITS   3
#define DAOS_PC_MASK    ((1U << DAOS_PC_NBITS) - 1)

typedef uint64_t    daos_epoch_t;

typedef struct {
    daos_epoch_t    epr_lo;
    daos_epoch_t    epr_hi;
} daos_epoch_range_t;

#define DAOS_EPOCH_MAX  (~0ULL)

typedef struct {
    uuid_t          ci_uuid;
    daos_epoch_t        ci_lsnapshot;
    uint32_t        ci_nhandles;
    uint32_t        ci_nsnapshots;
    uint64_t        ci_md_otime;
    uint64_t        ci_md_mtime;
    /* TODO: add more members, e.g., size, # objects, uid, gid... */
} daos_cont_info_t;
 
typedef d_iov_t daos_key_t;
 
static inline bool
daos_key_is_null(daos_key_t key)
{
    return key.iov_buf_len == 0 || key.iov_buf == NULL;
}

 
typedef struct daos_event {
    int         ev_error;
    struct {
        uint64_t    space[20];
    }           ev_private;

    uint64_t        ev_debug;
} daos_event_t;

#define DAOS_EQ_WAIT            -1
#define DAOS_EQ_NOWAIT          0
 
typedef enum {
    DAOS_EQR_COMPLETED  = (1),
    DAOS_EQR_WAITING    = (1 << 1),
    DAOS_EQR_ALL        = (DAOS_EQR_COMPLETED | DAOS_EQR_WAITING),
} daos_eq_query_t;
 
typedef enum {
    DAOS_EVS_READY,
    DAOS_EVS_RUNNING,
    DAOS_EVS_COMPLETED,
    DAOS_EVS_ABORTED,
} daos_ev_status_t;

struct d_tgt_list {
    d_rank_t    *tl_ranks;
    int32_t     *tl_tgts;
    uint32_t    tl_nr;
};
 
struct daos_eq;

enum {
    DAOS_HTYPE_EQ       = 1, 
    DAOS_HTYPE_POOL     = 3, 
    DAOS_HTYPE_CO       = 5, 
    DAOS_HTYPE_OBJ      = 7, 
    DAOS_HTYPE_ARRAY    = 9, 
    DAOS_HTYPE_TX       = 11, 
    DAOS_HTYPE_KV       = 13, 
    /* Must enlarge D_HTYPE_BITS to add more types */
};

typedef struct {
    uint64_t    lo;
    uint64_t    hi;
} daos_obj_id_t;
 
#define DAOS_UUID_STR_SIZE 37   /* 36 + 1 for '\0' */
 
#define UUID_SST_UPPER     1
#define UUID_SST_LOWER     -1
#define UUID_SST_NONE      0
 
/*
 * \param sensitive positive: expect uppercase character.
 *          negative: expect lowercase character.
 *          zero: no care uppercase or lowercase.
 */
static inline bool
daos_is_valid_uuid_iov(const d_iov_t *iov, int sensitive)
{
    const char  *p;
    int      len = DAOS_UUID_STR_SIZE - 1; /* Not include the terminated '\0' */
    int      i;
 
    if (iov->iov_len != (size_t)len)
        return false;
 
    for (i = 0, p = (const char *)iov->iov_buf; i < len; i++, p++) {
        if (i == 8 || i == 13 || i == 18 || i == 23) {
            if (*p != '-')
                return false;
        } else {
            if (sensitive >= UUID_SST_UPPER) {
                if (!isxdigit(*p) || islower(*p))
                    return false;
            } else if (sensitive <= UUID_SST_LOWER) {
                if (!isxdigit(*p) || isupper(*p))
                    return false;
            } else if (!isxdigit(*p)) {
                return false;
            }
        }
    }
 
    return true;
}
 
/* Same as daos_is_valid_uuid_iov(), for a NUL-terminated string. */
static inline bool
daos_is_valid_uuid_string(const char *uuid, int sensitive)
{
    d_iov_t iov;
    size_t  len = strnlen(uuid, DAOS_UUID_STR_SIZE);
 
    iov.iov_buf     = (void *)uuid;
    iov.iov_buf_len = len;
    iov.iov_len     = len;
 
    return daos_is_valid_uuid_iov(&iov, sensitive);
}

struct daos_rank_uri {
    uint32_t     dru_rank;
    char        *dru_uri;
};

struct daos_sys_info {
    char             dsi_system_name[DAOS_SYS_INFO_STRING_MAX + 1];
    char             dsi_fabric_provider[DAOS_SYS_INFO_STRING_MAX + 1];
    char                     dsi_agent_path[PATH_MAX];
    uint32_t         dsi_nr_ranks;
    struct daos_rank_uri    *dsi_ranks;
    uint32_t                 dsi_nr_ms_ranks;
    uint32_t                *dsi_ms_ranks;
};

#define DAOS_ATTR_NAME_MAX 511
 
#if defined(__cplusplus)
}
#endif
 
#endif /* DAOS_TYPES_H */