daos_cont.h

Go to the documentation of this file.

/*
 * (C) Copyright 2020-2022 Intel Corporation.
 *
 * SPDX-License-Identifier: BSD-2-Clause-Patent
 */
#ifndef __DAOS_CONT_H__
#define __DAOS_CONT_H__
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#include <daos_security.h>
 
#define DAOS_COO_RO     (1U << 0)
#define DAOS_COO_RW     (1U << 1)
#define DAOS_COO_NOSLIP     (1U << 2)
#define DAOS_COO_FORCE      (1U << 3)
 
#define DAOS_COO_NBITS  (4)
#define DAOS_COO_MASK   ((1U << DAOS_COO_NBITS) - 1)
 
typedef struct {
    uuid_t          ci_uuid;
    daos_epoch_t        ci_lsnapshot;
    uint32_t        ci_redun_fac;
    uint32_t        ci_nsnapshots;
    uint64_t        ci_pad[2];
    /* TODO: add more members, e.g., size, # objects, uid, gid... */
} daos_cont_info_t;
 
 
d_rank_list_t *daos_rank_list_parse(const char *str, const char *sep);
 
int
daos_cont_local2global(daos_handle_t coh, d_iov_t *glob);
 
int
daos_cont_global2local(daos_handle_t poh, d_iov_t glob, daos_handle_t *coh);
 
/*
 * Container API
 */
 
int
daos_cont_create(daos_handle_t poh, uuid_t *uuid, daos_prop_t *cont_prop, daos_event_t *ev);
 
int
daos_cont_create_with_label(daos_handle_t poh, const char *label,
                daos_prop_t *cont_prop, uuid_t *uuid,
                daos_event_t *ev);
 
int
daos_cont_open(daos_handle_t poh, const char *cont, unsigned int flags, daos_handle_t *coh,
           daos_cont_info_t *info, daos_event_t *ev);
 
int
daos_cont_close(daos_handle_t coh, daos_event_t *ev);
 
int
daos_cont_destroy(daos_handle_t poh, const char *cont, int force, daos_event_t *ev);
 
int
daos_cont_query(daos_handle_t container, daos_cont_info_t *info,
        daos_prop_t *cont_prop, daos_event_t *ev);
 
int
daos_cont_get_acl(daos_handle_t container, daos_prop_t **acl_prop,
          daos_event_t *ev);
int
daos_cont_set_prop(daos_handle_t coh, daos_prop_t *prop, daos_event_t *ev);
 
 
int
daos_cont_status_clear(daos_handle_t coh, daos_event_t *ev);
 
int
daos_cont_overwrite_acl(daos_handle_t coh, struct daos_acl *acl,
            daos_event_t *ev);
 
int
daos_cont_update_acl(daos_handle_t coh, struct daos_acl *acl, daos_event_t *ev);
 
int
daos_cont_delete_acl(daos_handle_t coh, enum daos_acl_principal_type type,
             d_string_t name, daos_event_t *ev);
 
int
daos_cont_set_owner(daos_handle_t coh, d_string_t user, d_string_t group,
            daos_event_t *ev);
 
int
daos_cont_list_attr(daos_handle_t coh, char *buffer, size_t *size,
            daos_event_t *ev);
 
int
daos_cont_get_attr(daos_handle_t coh, int n, char const *const names[],
           void *const buffers[], size_t sizes[], daos_event_t *ev);
 
int
daos_cont_set_attr(daos_handle_t coh, int n, char const *const names[],
           void const *const values[], size_t const sizes[],
           daos_event_t *ev);
 
int
daos_cont_del_attr(daos_handle_t coh, int n, char const *const names[],
           daos_event_t *ev);
 
int
daos_cont_alloc_oids(daos_handle_t coh, daos_size_t num_oids, uint64_t *oid,
             daos_event_t *ev);
 
int
daos_cont_aggregate(daos_handle_t coh, daos_epoch_t epoch, daos_event_t *ev);
 
int
daos_cont_rollback(daos_handle_t coh, daos_epoch_t epoch, daos_event_t *ev);
 
int
daos_cont_subscribe(daos_handle_t coh, daos_epoch_t *epoch, daos_event_t *ev);
 
#define DAOS_SNAPSHOT_MAX_LEN 128
 
int
daos_cont_create_snap(daos_handle_t coh, daos_epoch_t *epoch, char *name,
              daos_event_t *ev);
 
enum daos_snapshot_opts {
    DAOS_SNAP_OPT_CR    = (1 << 0),
    DAOS_SNAP_OPT_OIT   = (1 << 1),
};
 
int
daos_cont_create_snap_opt(daos_handle_t coh, daos_epoch_t *epoch, char *name,
              enum daos_snapshot_opts opts, daos_event_t *ev);
 
int
daos_cont_list_snap(daos_handle_t coh, int *nr, daos_epoch_t *epochs,
            char **names, daos_anchor_t *anchor, daos_event_t *ev);
 
int
daos_cont_destroy_snap(daos_handle_t coh, daos_epoch_range_t epr,
               daos_event_t *ev);
 
int
daos_cont_open2(daos_handle_t poh, const char *cont, unsigned int flags, daos_handle_t *coh,
        daos_cont_info_t *info, daos_event_t *ev);
 
int
daos_cont_destroy2(daos_handle_t poh, const char *cont, int force, daos_event_t *ev);
 
int
daos_cont_create2(daos_handle_t poh, uuid_t *uuid, daos_prop_t *cont_prop, daos_event_t *ev);
int
daos_cont_create1(daos_handle_t poh, const uuid_t uuid, daos_prop_t *cont_prop, daos_event_t *ev);
 
#if defined(__cplusplus)
}
 
#define daos_cont_open daos_cont_open_cpp
static inline int
daos_cont_open_cpp(daos_handle_t poh, const char *cont, unsigned int flags, daos_handle_t *coh,
           daos_cont_info_t *info, daos_event_t *ev)
{
    return daos_cont_open2(poh, cont, flags, coh, info, ev);
}
 
static inline int
daos_cont_open_cpp(daos_handle_t poh, const uuid_t cont, unsigned int flags, daos_handle_t *coh,
           daos_cont_info_t *info, daos_event_t *ev)
{
    char str[37];
 
    uuid_unparse(cont, str);
    return daos_cont_open2(poh, str, flags, coh, info, ev);
}
 
#define daos_cont_destroy daos_cont_destroy_cpp
static inline int
daos_cont_destroy_cpp(daos_handle_t poh, const char *cont, int force, daos_event_t *ev)
{
    return daos_cont_destroy2(poh, cont, force, ev);
}
 
static inline int
daos_cont_destroy_cpp(daos_handle_t poh, const uuid_t cont, int force, daos_event_t *ev)
{
    char str[37];
 
    uuid_unparse(cont, str);
    return daos_cont_destroy2(poh, str, force, ev);
}
 
#define daos_cont_create daos_cont_create_cpp
static inline int
daos_cont_create_cpp(daos_handle_t poh, uuid_t *uuid, daos_prop_t *cont_prop, daos_event_t *ev)
{
    return daos_cont_create2(poh, uuid, cont_prop, ev);
}
 
static inline int
daos_cont_create_cpp(daos_handle_t poh, const uuid_t uuid, daos_prop_t *cont_prop, daos_event_t *ev)
{
    return daos_cont_create1(poh, uuid, cont_prop, ev);
}
#else
#define daos_cont_open(poh, co, ...)                    \
    ({                              \
        int _ret;                       \
        char _str[37];                      \
        const char *__str = NULL;               \
        if (d_is_string(co)) {                  \
            __str = (const char *)(co);         \
        } else if (d_is_uuid(co)) {             \
            uuid_unparse((unsigned char *)(co), _str);  \
            __str = _str;                   \
        }                           \
        _ret = daos_cont_open2((poh), __str, __VA_ARGS__);  \
        _ret;                           \
    })
 
#define daos_cont_destroy(poh, co, ...)                 \
    ({                              \
        int _ret;                       \
        char _str[37];                      \
        const char *__str = NULL;               \
        if (d_is_string(co)) {                  \
            __str = (const char *)(co);         \
        } else if (d_is_uuid(co)) {             \
            uuid_unparse((unsigned char *)(co), _str);  \
            __str = _str;                   \
        }                           \
        _ret = daos_cont_destroy2((poh), __str, __VA_ARGS__);   \
        _ret;                           \
    })
 
#define daos_cont_create(poh, co, ...)                  \
    ({                              \
        int _ret;                       \
        uuid_t *_u;                     \
        if (d_is_uuid(co)) {                    \
            _u = (uuid_t *)((unsigned char *)(co));     \
            _ret = daos_cont_create((poh), _u,      \
                        __VA_ARGS__);       \
        } else {                        \
            _u = (uuid_t *)(co);                \
            _ret = daos_cont_create2((poh), _u,     \
                         __VA_ARGS__);      \
        }                           \
        _ret;                           \
    })
 
#endif /* __cplusplus */
#endif /* __DAOS_CONT_H__ */