daos_obj.h

 
#ifndef __DAOS_OBJ_H__
#define __DAOS_OBJ_H__
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#include <daos_types.h>
#include <daos_event.h>
#include <daos_obj_class.h>
 
#define DAOS_OBJ_NIL        ((daos_obj_id_t){0})
 
#define OID_FMT_INTR_BITS   32
#define OID_FMT_TYPE_BITS   8
#define OID_FMT_CLASS_BITS  8
#define OID_FMT_META_BITS   16
 
#define OID_FMT_TYPE_SHIFT  (64 - OID_FMT_TYPE_BITS)
#define OID_FMT_CLASS_SHIFT (OID_FMT_TYPE_SHIFT - OID_FMT_CLASS_BITS)
#define OID_FMT_META_SHIFT  (OID_FMT_CLASS_SHIFT - OID_FMT_META_BITS)
 
#define OID_FMT_TYPE_MAX    ((1ULL << OID_FMT_TYPE_BITS) - 1)
#define OID_FMT_CLASS_MAX   ((1ULL << OID_FMT_CLASS_BITS) - 1)
#define OID_FMT_META_MAX    ((1ULL << OID_FMT_META_BITS) - 1)
 
#define OID_FMT_TYPE_MASK   (OID_FMT_TYPE_MAX << OID_FMT_TYPE_SHIFT)
#define OID_FMT_CLASS_MASK  (OID_FMT_CLASS_MAX << OID_FMT_CLASS_SHIFT)
#define OID_FMT_META_MASK   (OID_FMT_META_MAX << OID_FMT_META_SHIFT)
 
enum daos_otype_t {
    DAOS_OT_MULTI_HASHED    = 0,
 
    DAOS_OT_OIT     = 1,
 
    DAOS_OT_DKEY_UINT64 = 2,
 
    DAOS_OT_AKEY_UINT64 = 3,
 
    DAOS_OT_MULTI_UINT64    = 4,
 
    DAOS_OT_DKEY_LEXICAL    = 5,
 
    DAOS_OT_AKEY_LEXICAL    = 6,
 
    DAOS_OT_MULTI_LEXICAL   = 7,
 
    DAOS_OT_KV_HASHED   = 8,
 
    DAOS_OT_KV_UINT64   = 9,
 
    DAOS_OT_KV_LEXICAL  = 10,
 
    DAOS_OT_ARRAY       = 11,
 
    DAOS_OT_ARRAY_ATTR  = 12,
 
    DAOS_OT_ARRAY_BYTE  = 13,
 
    DAOS_OT_MAX     = 13,
};
 
static inline bool
daos_otype_t_is_valid(enum daos_otype_t type)
{
    return type <= DAOS_OT_MAX;
}
 
static inline enum daos_otype_t
daos_obj_id2type(daos_obj_id_t oid)
{
    uint64_t type;
 
    type = (oid.hi & OID_FMT_TYPE_MASK) >> OID_FMT_TYPE_SHIFT;
 
    return (enum daos_otype_t)type;
}
 
static inline bool
daos_is_dkey_lexical_type(enum daos_otype_t type)
{
    switch (type) {
    case DAOS_OT_DKEY_LEXICAL:
    case DAOS_OT_MULTI_LEXICAL:
    case DAOS_OT_KV_LEXICAL:
        return true;
    default:
        return false;
 
    }
}
 
static inline bool
daos_is_dkey_lexical(daos_obj_id_t oid)
{
    return daos_is_dkey_lexical_type(daos_obj_id2type(oid));
}
 
static inline bool
daos_is_akey_lexical_type(enum daos_otype_t type)
{
    switch (type) {
    case DAOS_OT_AKEY_LEXICAL:
    case DAOS_OT_MULTI_LEXICAL:
        return true;
    default:
        return false;
 
    }
}
 
static inline bool
daos_is_akey_lexical(daos_obj_id_t oid)
{
    return daos_is_akey_lexical_type(daos_obj_id2type(oid));
}
 
static inline bool
daos_is_dkey_uint64_type(enum daos_otype_t type)
{
    switch (type) {
    case DAOS_OT_MULTI_UINT64:
    case DAOS_OT_DKEY_UINT64:
    case DAOS_OT_KV_UINT64:
    case DAOS_OT_ARRAY:
    case DAOS_OT_ARRAY_ATTR:
    case DAOS_OT_ARRAY_BYTE:
        return true;
    default:
        return false;
 
    }
}
 
static inline bool
daos_is_dkey_uint64(daos_obj_id_t oid)
{
    return daos_is_dkey_uint64_type(daos_obj_id2type(oid));
}
 
static inline bool
daos_is_akey_uint64_type(enum daos_otype_t type)
{
    switch (type) {
    case DAOS_OT_MULTI_UINT64:
    case DAOS_OT_AKEY_UINT64:
        return true;
    default:
        return false;
 
    }
}
 
static inline bool
daos_is_akey_uint64(daos_obj_id_t oid)
{
    return daos_is_akey_uint64_type(daos_obj_id2type(oid));
}
 
static inline bool
daos_is_array_type(enum daos_otype_t type)
{
    switch (type) {
    case DAOS_OT_ARRAY:
    case DAOS_OT_ARRAY_ATTR:
    case DAOS_OT_ARRAY_BYTE:
        return true;
    default:
        return false;
 
    }
}
 
static inline bool
daos_is_array(daos_obj_id_t oid)
{
    enum daos_otype_t type = daos_obj_id2type(oid);
 
    return daos_is_array_type(type);
}
 
static inline bool
daos_is_kv_type(enum daos_otype_t type)
{
    switch (type) {
    case DAOS_OT_KV_HASHED:
    case DAOS_OT_KV_UINT64:
    case DAOS_OT_KV_LEXICAL:
        return true;
    default:
        return false;
 
    }
}
 
static inline bool
daos_is_kv(daos_obj_id_t oid)
{
    enum daos_otype_t type = daos_obj_id2type(oid);
 
    return daos_is_kv_type(type);
}
 
#define IO_FLAGS_COND_BITS  8
 
enum {
    /* Conditional Op: Punch key if it exists, fail otherwise */
    DAOS_COND_PUNCH = (1 << 0),
    /* Conditional Op: Insert dkey if it doesn't exist, fail otherwise */
    DAOS_COND_DKEY_INSERT = (1 << 1),
    /* Conditional Op: Update dkey if it exists, fail otherwise */
    DAOS_COND_DKEY_UPDATE = (1 << 2),
    /* Conditional Op: Fetch dkey if it exists, fail otherwise */
    DAOS_COND_DKEY_FETCH = (1 << 3),
    /* Conditional Op: Insert akey if it doesn't exist, fail otherwise */
    DAOS_COND_AKEY_INSERT = (1 << 4),
    /* Conditional Op: Update akey if it exists, fail otherwise */
    DAOS_COND_AKEY_UPDATE = (1 << 5),
    /* Conditional Op: Fetch akey if it exists, fail otherwise */
    DAOS_COND_AKEY_FETCH = (1 << 6),
    /* Indication of per akey conditional ops.  If set, the global
     * flag should not have any akey conditional ops specified. The
     * per akey flags will be read from the iod_flags field.
     */
    DAOS_COND_PER_AKEY = (1 << 7),
    DAOS_COND_MASK = ((1 << IO_FLAGS_COND_BITS) - 1),
};
 
struct daos_obj_attr {
    d_rank_t         oa_rank;
    struct daos_oclass_attr *oa_oa;
};
 
enum {
    DAOS_OO_RO             = (1 << 1),
    DAOS_OO_RW             = (1 << 2),
    DAOS_OO_EXCL           = (1 << 3),
    DAOS_OO_IO_RAND        = (1 << 4),
    DAOS_OO_IO_SEQ         = (1 << 5),
};
 
struct daos_oid_list {
    uint32_t         ol_nr;
    uint32_t         ol_nr_out;
    daos_obj_id_t       *ol_oids;
};
 
typedef struct {
    uint64_t    rx_idx;
    uint64_t    rx_nr;
} daos_recx_t;
 
typedef enum {
    DAOS_IOD_NONE       = 0,
    DAOS_IOD_SINGLE     = 1,
    DAOS_IOD_ARRAY      = 2,
} daos_iod_type_t;
 
typedef struct {
    daos_key_t      iod_name;
    /*
     * Type of the value in an iod can be either a single type that is
     * always overwritten when updated, or it can be an array of EQUAL sized
     * records where the record is updated atomically. Note that an akey can
     * only support one type of value which is set on the first update. If
     * user attempts to mix types in the same akey, the behavior is
     * undefined, even after the object, key, or value is punched. If
     * \a iod_type == DAOS_IOD_SINGLE, then iod_nr has to be 1, and
     * \a iod_size would be the size of the single atomic value. The idx is
     * ignored and the rx_nr is also required to be 1.
     */
    daos_iod_type_t     iod_type;
    daos_size_t     iod_size;
    uint64_t        iod_flags;
    /*
     * Number of entries in the \a iod_recxs for arrays,
     * should be 1 if single value.
     */
    uint32_t        iod_nr;
    /*
     * Array of extents, where each extent defines the index of the first
     * record in the extent and the number of records to access. If the
     * type of the iod is single, this is ignored.
     */
    daos_recx_t     *iod_recxs;
} daos_iod_t;
 
#define DAOS_IOMF_DETAIL        (0x1U)
typedef struct {
    daos_iod_type_t      iom_type;
    uint32_t         iom_nr;
    uint32_t         iom_nr_out;
    uint32_t         iom_flags;
    daos_size_t      iom_size;
    daos_recx_t      iom_recx_lo;
    daos_recx_t      iom_recx_hi;
    daos_recx_t     *iom_recxs;
} daos_iom_t;
 
enum {
    DAOS_REC_ANY        = 0,
};
 
enum {
    DAOS_GET_MAX        = (1 << 0),
    DAOS_GET_MIN        = (1 << 1),
    DAOS_GET_DKEY       = (1 << 2),
    DAOS_GET_AKEY       = (1 << 3),
    DAOS_GET_RECX       = (1 << 4),
};
 
typedef struct {
    daos_size_t kd_key_len;
    uint32_t    kd_val_type;
} daos_key_desc_t;
 
static inline daos_oclass_id_t
daos_obj_id2class(daos_obj_id_t oid)
{
    enum daos_obj_redun ord;
    uint32_t nr_grps;
 
    ord = (enum daos_obj_redun)((oid.hi & OID_FMT_CLASS_MASK) >> OID_FMT_CLASS_SHIFT);
    nr_grps = (oid.hi & OID_FMT_META_MASK) >> OID_FMT_META_SHIFT;
 
    return (ord << OC_REDUN_SHIFT) | nr_grps;
}
 
static inline bool
daos_obj_id_is_nil(daos_obj_id_t oid)
{
    return oid.hi == 0 && oid.lo == 0;
}
 
#define DAOS_OCH_RDD_BITS   4
#define DAOS_OCH_SHD_BITS   6
#define DAOS_OCH_RDD_SHIFT  0
#define DAOS_OCH_SHD_SHIFT  DAOS_OCH_RDD_BITS
#define DAOS_OCH_RDD_MAX_VAL    ((1ULL << DAOS_OCH_RDD_BITS) - 1)
#define DAOS_OCH_SHD_MAX_VAL    ((1ULL << DAOS_OCH_SHD_BITS) - 1)
#define DAOS_OCH_RDD_MASK   (DAOS_OCH_RDD_MAX_VAL << DAOS_OCH_RDD_SHIFT)
#define DAOS_OCH_SHD_MASK   (DAOS_OCH_SHD_MAX_VAL << DAOS_OCH_SHD_SHIFT)
 
enum {
    DAOS_OCH_RDD_DEF    = (1 << 0), 
    DAOS_OCH_RDD_NO     = (1 << 1), 
    DAOS_OCH_RDD_RP     = (1 << 2), 
    DAOS_OCH_RDD_EC     = (1 << 3), 
    DAOS_OCH_SHD_DEF    = (1 << 4), 
    DAOS_OCH_SHD_TINY   = (1 << 5), 
    DAOS_OCH_SHD_REG    = (1 << 6), 
    DAOS_OCH_SHD_HI     = (1 << 7), 
    DAOS_OCH_SHD_EXT    = (1 << 8), 
    DAOS_OCH_SHD_MAX    = (1 << 9), 
};
 
int
daos_obj_generate_oid(daos_handle_t coh, daos_obj_id_t *oid,
              enum daos_otype_t type, daos_oclass_id_t cid,
              daos_oclass_hints_t hints, uint32_t args);
 
int
daos_obj_open(daos_handle_t coh, daos_obj_id_t oid, unsigned int mode,
          daos_handle_t *oh, daos_event_t *ev);
 
int
daos_obj_close(daos_handle_t oh, daos_event_t *ev);
 
int
daos_obj_punch(daos_handle_t oh, daos_handle_t th, uint64_t flags,
           daos_event_t *ev);
 
int
daos_obj_punch_dkeys(daos_handle_t oh, daos_handle_t th, uint64_t flags,
             unsigned int nr, daos_key_t *dkeys, daos_event_t *ev);
 
int
daos_obj_punch_akeys(daos_handle_t oh, daos_handle_t th, uint64_t flags,
             daos_key_t *dkey, unsigned int nr, daos_key_t *akeys,
             daos_event_t *ev);
 
int
daos_obj_query(daos_handle_t oh, struct daos_obj_attr *oa, d_rank_list_t *ranks,
           daos_event_t *ev);
 
/*
 * Object I/O API
 */
 
int
daos_obj_fetch(daos_handle_t oh, daos_handle_t th, uint64_t flags,
           daos_key_t *dkey, unsigned int nr, daos_iod_t *iods,
           d_sg_list_t *sgls, daos_iom_t *ioms, daos_event_t *ev);
 
int
daos_obj_update(daos_handle_t oh, daos_handle_t th, uint64_t flags,
        daos_key_t *dkey, unsigned int nr, daos_iod_t *iods,
        d_sg_list_t *sgls, daos_event_t *ev);
 
int
daos_obj_list_dkey(daos_handle_t oh, daos_handle_t th, uint32_t *nr,
           daos_key_desc_t *kds, d_sg_list_t *sgl,
           daos_anchor_t *anchor, daos_event_t *ev);
 
int
daos_obj_list_akey(daos_handle_t oh, daos_handle_t th, daos_key_t *dkey,
           uint32_t *nr, daos_key_desc_t *kds, d_sg_list_t *sgl,
           daos_anchor_t *anchor, daos_event_t *ev);
 
int
daos_obj_list_recx(daos_handle_t oh, daos_handle_t th, daos_key_t *dkey,
           daos_key_t *akey, daos_size_t *size, uint32_t *nr,
           daos_recx_t *recxs, daos_epoch_range_t *eprs,
           daos_anchor_t *anchor, bool incr_order,
           daos_event_t *ev);
 
int
daos_obj_query_key(daos_handle_t oh, daos_handle_t th, uint64_t flags,
           daos_key_t *dkey, daos_key_t *akey, daos_recx_t *recx,
           daos_event_t *ev);
 
int
daos_obj_verify(daos_handle_t coh, daos_obj_id_t oid, daos_epoch_t epoch);
 
int
daos_obj_anchor_split(daos_handle_t oh, uint32_t *nr, daos_anchor_t *anchors);
 
int
daos_obj_anchor_set(daos_handle_t oh, uint32_t index, daos_anchor_t *anchor);
 
int
daos_oit_open(daos_handle_t coh, daos_epoch_t epoch,
          daos_handle_t *oh, daos_event_t *ev);
 
int
daos_oit_close(daos_handle_t oh, daos_event_t *ev);
 
int
daos_oit_list(daos_handle_t oh, daos_obj_id_t *oids, uint32_t *oids_nr,
          daos_anchor_t *anchor, daos_event_t *ev);
 
typedef uint16_t daos_ofeat_t;
int
daos_obj_generate_oid1(daos_handle_t coh, daos_obj_id_t *oid,
               daos_ofeat_t type, daos_oclass_id_t cid,
               daos_oclass_hints_t hints, uint32_t args);
int
daos_obj_generate_oid2(daos_handle_t coh, daos_obj_id_t *oid,
               enum daos_otype_t type, daos_oclass_id_t cid,
               daos_oclass_hints_t hints, uint32_t args);
 
#define DAOS_OF_DKEY_UINT64 ((daos_ofeat_t)(1 << 0))
#define DAOS_OF_DKEY_LEXICAL    ((daos_ofeat_t)(1 << 1))
#define DAOS_OF_AKEY_UINT64 ((daos_ofeat_t)(1 << 2))
#define DAOS_OF_AKEY_LEXICAL    ((daos_ofeat_t)(1 << 3))
#define DAOS_OF_KV_FLAT     ((daos_ofeat_t)(1 << 4))
#define DAOS_OF_ARRAY       ((daos_ofeat_t)(1 << 5))
#define DAOS_OF_ARRAY_MD    ((daos_ofeat_t)(1 << 6))
#define DAOS_OF_ARRAY_BYTE  ((daos_ofeat_t)(1 << 7))
#define DAOS_OF_ECHO        ((daos_ofeat_t)(1 << 15))
#define DAOS_OF_MASK        ((daos_ofeat_t)((1 << 16) - 1))
 
#if defined(__cplusplus)
}
#define daos_obj_generate_oid daos_obj_generate_oid_cpp
static inline int
daos_obj_generate_oid_cpp(daos_handle_t coh, daos_obj_id_t *oid,
              enum daos_otype_t type, daos_oclass_id_t cid,
              daos_oclass_hints_t hints, uint32_t args)
{
    return daos_obj_generate_oid2(coh, oid, type, cid, hints, args);
}
static inline int
daos_obj_generate_oid_cpp(daos_handle_t coh, daos_obj_id_t *oid,
              daos_ofeat_t feat, daos_oclass_id_t cid,
              daos_oclass_hints_t hints, uint32_t args)
{
    return daos_obj_generate_oid1(coh, oid, feat, cid, hints, args);
}
#else
#define daos_obj_generate_oid(coh, oid, type, ...)          \
    ({                              \
        int _ret;                       \
        if (__builtin_types_compatible_p(__typeof__(type),  \
                         daos_ofeat_t)) {   \
            _ret = daos_obj_generate_oid((coh), (oid),  \
                             (type),        \
                             __VA_ARGS__);  \
        } else {                        \
            _ret = daos_obj_generate_oid2((coh), (oid), \
                              (type),       \
                              __VA_ARGS__); \
        }                           \
        _ret;                           \
    })
#endif /* __cplusplus */
#endif /* __DAOS_OBJ_H__ */