daos_errno.h

 
#ifndef __DAOS_ERRNO_H__
#define __DAOS_ERRNO_H__
 
#if defined(__cplusplus)
extern "C" {
#endif
 
/*
 * This preprocessor machinery defines the errno values but also
 * enables the internal definition of d_errstr.  A new macro should
 * be defined for each non-contiguous range
 */
 
#define D_FOREACH_GURT_ERR(ACTION)                  \
                        \
    ACTION(DER_NO_PERM,     (DER_ERR_GURT_BASE + 1),    \
           Operation not permitted)                 \
                        \
    ACTION(DER_NO_HDL,      (DER_ERR_GURT_BASE + 2),    \
           Invalid handle)                      \
                    \
    ACTION(DER_INVAL,       (DER_ERR_GURT_BASE + 3),    \
           Invalid parameters)                  \
                    \
    ACTION(DER_EXIST,       (DER_ERR_GURT_BASE + 4),    \
           Entity already exists)                   \
                    \
    ACTION(DER_NONEXIST,        (DER_ERR_GURT_BASE + 5),    \
           The specified entity does not exist)         \
                        \
    ACTION(DER_UNREACH,     (DER_ERR_GURT_BASE + 6),    \
           Unreachable node)                    \
                \
    ACTION(DER_NOSPACE,     (DER_ERR_GURT_BASE + 7),    \
           No space on storage target)              \
                        \
    ACTION(DER_ALREADY,     (DER_ERR_GURT_BASE + 8),    \
           Operation already performed)             \
                        \
    ACTION(DER_NOMEM,       (DER_ERR_GURT_BASE + 9),    \
           Out of memory)                       \
                    \
    ACTION(DER_NOSYS,       (DER_ERR_GURT_BASE + 10),   \
           Function not implemented)                \
                        \
    ACTION(DER_TIMEDOUT,        (DER_ERR_GURT_BASE + 11),   \
           Time out)                        \
                            \
    ACTION(DER_BUSY,        (DER_ERR_GURT_BASE + 12),   \
           Device or resource busy)                 \
                        \
    ACTION(DER_AGAIN,       (DER_ERR_GURT_BASE + 13),   \
           Try again)                       \
                    \
    ACTION(DER_PROTO,       (DER_ERR_GURT_BASE + 14),   \
           Incompatible protocol)                   \
                        \
    ACTION(DER_UNINIT,      (DER_ERR_GURT_BASE + 15),   \
           Device or resource not initialized)          \
            \
    ACTION(DER_TRUNC,       (DER_ERR_GURT_BASE + 16),   \
           Buffer too short)                    \
    \
    ACTION(DER_OVERFLOW,        (DER_ERR_GURT_BASE + 17),   \
           Data too long for defined data type or buffer size)  \
                    \
    ACTION(DER_CANCELED,        (DER_ERR_GURT_BASE + 18),   \
           Operation canceled)                  \
                \
    ACTION(DER_OOG,         (DER_ERR_GURT_BASE + 19),   \
           Out of group or member list)             \
                \
    ACTION(DER_HG,          (DER_ERR_GURT_BASE + 20),   \
           Transport layer mercury error)               \
            \
    ACTION(DER_UNREG,       (DER_ERR_GURT_BASE + 21),   \
           RPC or protocol version not registered)          \
            \
    ACTION(DER_ADDRSTR_GEN,     (DER_ERR_GURT_BASE + 22),   \
           Failed to generate an address string)            \
                        \
    ACTION(DER_PMIX,        (DER_ERR_GURT_BASE + 23),   \
           PMIx layer error)                    \
            \
    ACTION(DER_IVCB_FORWARD,    (DER_ERR_GURT_BASE + 24),   \
           Incast variable unavailable locally. Must forward)   \
                    \
    ACTION(DER_MISC,        (DER_ERR_GURT_BASE + 25),   \
           Miscellaneous error)                 \
                        \
    ACTION(DER_BADPATH,     (DER_ERR_GURT_BASE + 26),   \
           Bad path name)                       \
                        \
    ACTION(DER_NOTDIR,      (DER_ERR_GURT_BASE + 27),   \
           Not a directory)                     \
                        \
    ACTION(DER_CORPC_INCOMPLETE,    (DER_ERR_GURT_BASE + 28),   \
           Collective RPC failed)                   \
                \
    ACTION(DER_NO_RAS_RANK,     (DER_ERR_GURT_BASE + 29),   \
           No rank is subscribed to RAS)                \
                \
    ACTION(DER_NOTATTACH,       (DER_ERR_GURT_BASE + 30),   \
           Service group not attached)              \
                        \
    ACTION(DER_MISMATCH,        (DER_ERR_GURT_BASE + 31),   \
           Version mismatch)                    \
                    \
    ACTION(DER_EXCLUDED,        (DER_ERR_GURT_BASE + 32),   \
           Rank has been excluded)                  \
        \
    ACTION(DER_NOREPLY,     (DER_ERR_GURT_BASE + 33),   \
           User provided RPC handler did not send reply back)   \
                    \
    ACTION(DER_DOS,         (DER_ERR_GURT_BASE + 34),       \
           Denial of service)                   \
                \
    ACTION(DER_BAD_TARGET,      (DER_ERR_GURT_BASE + 35),   \
           Incorrect target for the RPC)                \
                \
    ACTION(DER_GRPVER,      (DER_ERR_GURT_BASE + 36),   \
           Group versioning mismatch)               \
                \
    ACTION(DER_HLC_SYNC,        (DER_ERR_GURT_BASE + 37),   \
           HLC synchronization error)               \
                \
    ACTION(DER_NO_SHMEM,        (DER_ERR_GURT_BASE + 38),   \
           Not enough shared memory free)               \
                    \
    ACTION(DER_ADD_METRIC_FAILED,   (DER_ERR_GURT_BASE + 39),   \
           Failed to add the specified metric)          \
                \
    ACTION(DER_DURATION_MISMATCH,   (DER_ERR_GURT_BASE + 40),   \
           Duration end not paired with duration start)     \
            \
    ACTION(DER_OP_NOT_PERMITTED,    (DER_ERR_GURT_BASE + 41),   \
           Operation not permitted for metric type provided)    \
            \
    ACTION(DER_EXCEEDS_PATH_LEN,    (DER_ERR_GURT_BASE + 42),   \
           Path name exceeds permitted length)          \
                    \
    ACTION(DER_METRIC_NOT_FOUND,    (DER_ERR_GURT_BASE + 43),   \
           Read failed because metric not found)            \
                \
    ACTION(DER_SHMEM_PERMS,         (DER_ERR_GURT_BASE + 44),   \
           Unable to access shared memory segment due to        \
           incompatible user or group permissions)
#define D_FOREACH_DAOS_ERR(ACTION)                  \
                    \
    ACTION(DER_IO,          (DER_ERR_DAOS_BASE + 1),    \
           I/O error)                       \
                    \
    ACTION(DER_FREE_MEM,        (DER_ERR_DAOS_BASE + 2),    \
           Memory free error)                   \
                        \
    ACTION(DER_ENOENT,      (DER_ERR_DAOS_BASE + 3),    \
           Entity not found)                    \
                    \
    ACTION(DER_NOTYPE,      (DER_ERR_DAOS_BASE + 4),    \
           Unknown object type)                 \
                    \
    ACTION(DER_NOSCHEMA,        (DER_ERR_DAOS_BASE + 5),    \
           Unknown object schema)                   \
                    \
    ACTION(DER_NOLOCAL,     (DER_ERR_DAOS_BASE + 6),    \
           Object is not local)                 \
                    \
    ACTION(DER_STALE,       (DER_ERR_DAOS_BASE + 7),    \
           Stale pool map version)                  \
                    \
    ACTION(DER_NOTLEADER,       (DER_ERR_DAOS_BASE + 8),    \
           Not service leader)                  \
                    \
    ACTION(DER_TGT_CREATE,      (DER_ERR_DAOS_BASE + 9),    \
           Target create error)                 \
                    \
    ACTION(DER_EP_RO,       (DER_ERR_DAOS_BASE + 10),   \
           Epoch is read only)                  \
        \
    ACTION(DER_EP_OLD,      (DER_ERR_DAOS_BASE + 11),   \
           Epoch is too old. All data have been recycled)       \
                        \
    ACTION(DER_KEY2BIG,     (DER_ERR_DAOS_BASE + 12),   \
           Key is too large)                    \
                    \
    ACTION(DER_REC2BIG,     (DER_ERR_DAOS_BASE + 13),   \
           Record is too large)                 \
            \
    ACTION(DER_IO_INVAL,        (DER_ERR_DAOS_BASE + 14),   \
           I/O buffers do not match object extents)         \
                    \
    ACTION(DER_EQ_BUSY,     (DER_ERR_DAOS_BASE + 15),   \
           Event queue is busy)                 \
            \
    ACTION(DER_DOMAIN,      (DER_ERR_DAOS_BASE + 16),   \
           Domain of cluster component do not match)        \
                    \
    ACTION(DER_SHUTDOWN,        (DER_ERR_DAOS_BASE + 17),   \
           Service should shut down)                \
                \
    ACTION(DER_INPROGRESS,      (DER_ERR_DAOS_BASE + 18),   \
           Operation now in progress)               \
                        \
    ACTION(DER_NOTAPPLICABLE,   (DER_ERR_DAOS_BASE + 19),   \
           Not applicable)                      \
                    \
    ACTION(DER_NOTREPLICA,      (DER_ERR_DAOS_BASE + 20),   \
           Not a service replica)                   \
                        \
    ACTION(DER_CSUM,        (DER_ERR_DAOS_BASE + 21),   \
           Checksum error)                      \
                \
    ACTION(DER_DF_INVAL,        (DER_ERR_DAOS_BASE + 22),   \
           Unsupported durable format)              \
            \
    ACTION(DER_DF_INCOMPT,      (DER_ERR_DAOS_BASE + 23),   \
           Incompatible durable format version)         \
                    \
    ACTION(DER_REC_SIZE,        (DER_ERR_DAOS_BASE + 24),   \
           Record size error)                   \
        \
    ACTION(DER_TX_RESTART,      (DER_ERR_DAOS_BASE + 25),   \
           Transaction should restart)              \
                \
    ACTION(DER_DATA_LOSS,       (DER_ERR_DAOS_BASE + 26),   \
           Data lost or not recoverable)                \
                \
    ACTION(DER_OP_CANCELED,     (DER_ERR_DAOS_BASE + 27),   \
           Operation canceled)                  \
    \
    ACTION(DER_TX_BUSY,     (DER_ERR_DAOS_BASE + 28),   \
           TX is not committed)                 \
            \
    ACTION(DER_AGENT_INCOMPAT,  (DER_ERR_DAOS_BASE + 29),   \
           Agent is incompatible with libdaos)          \
        \
    ACTION(DER_SHARDS_OVERLAP,  (DER_ERR_DAOS_BASE + 30),   \
           Shards overlap)                      \
 \
    ACTION(DER_RF,          (DER_ERR_DAOS_BASE + 31),   \
           Failures exceed RF)                  \
 \
    ACTION(DER_FETCH_AGAIN,     (DER_ERR_DAOS_BASE + 32),   \
           Fetch again)                     \
    \
    ACTION(DER_TX_UNCERTAIN,    (DER_ERR_DAOS_BASE + 33),   \
           TX status is uncertaion)                 \
                \
    ACTION(DER_AGENT_COMM,      (DER_ERR_DAOS_BASE + 34),   \
           Agent communication error)               \
                        \
    ACTION(DER_ID_MISMATCH,     (DER_ERR_DAOS_BASE + 35),   \
           ID mismatch)                     \
 \
    ACTION(DER_TGT_RETRY,       (DER_ERR_DAOS_BASE + 36),   \
        Retry with other target)                \
    ACTION(DER_NOTSUPPORTED,    (DER_ERR_DAOS_BASE + 37),   \
           Operation not supported)                 \
    ACTION(DER_CONTROL_INCOMPAT,    (DER_ERR_DAOS_BASE + 38),   \
           One or more control plane components are incompatible)   \
                    \
    ACTION(DER_NO_SERVICE,      (DER_ERR_DAOS_BASE + 39),   \
           No service available)
 
#define D_FOREACH_ERR_RANGE(ACTION) \
    ACTION(GURT,    1000)       \
    ACTION(DAOS,    2000)
 
#define D_DEFINE_ERRNO(name, value, desc) name = value,
#define D_DEFINE_ERRSTR(name, value, desc) #name,
#define D_DEFINE_ERRDESC(name, value, desc) #desc,
 
#define D_DEFINE_RANGE_ERRNO(name, base)            \
    enum {                          \
        DER_ERR_##name##_BASE       =   (base), \
        D_FOREACH_##name##_ERR(D_DEFINE_ERRNO)      \
        DER_ERR_##name##_LIMIT,             \
    };
 
#define D_DEFINE_RANGE_ERRSTR(name)             \
    static const char * const g_##name##_error_strings[] = {\
        D_FOREACH_##name##_ERR(D_DEFINE_ERRSTR)     \
    }; \
    static const char * const g_##name##_strerror[] = { \
        D_FOREACH_##name##_ERR(D_DEFINE_ERRDESC)    \
    };
 
D_FOREACH_ERR_RANGE(D_DEFINE_RANGE_ERRNO)
 
 
#define D_REGISTER_RANGE(name)              \
    d_errno_register_range(DER_ERR_##name##_BASE,   \
                   DER_ERR_##name##_LIMIT,  \
                   g_##name##_error_strings,\
                   g_##name##_strerror)
 
#define D_DEREGISTER_RANGE(name)            \
    d_errno_deregister_range(DER_ERR_##name##_BASE)
 
#define DER_SUCCESS 0
#define DER_UNKNOWN (DER_ERR_GURT_BASE + 500000)
 
const char *d_errstr(int rc);
 
int d_errno_register_range(int start, int end,
               const char * const *error_strings,
               const char * const *strerror);
 
void d_errno_deregister_range(int start);
 
const char *d_errdesc(int errnum);
 
#define DO_PRAGMA(str)  _Pragma(#str)
#define DEPRECATE_ERROR(olde, newe)             \
({                              \
    DO_PRAGMA(message(#olde " is deprecated, use " #newe)); \
    newe;                           \
})
#define DER_EVICTED DEPRECATE_ERROR(DER_EVICTED, DER_EXCLUDED)
 
#ifndef DF_RC
#define DF_RC "%s(%d): '%s'"
#define DP_RC(rc) d_errstr(rc), rc, d_errdesc(rc)
#endif /* DF_RC */
 
#if defined(__cplusplus)
}
#endif
 
#endif /*  __DAOS_ERRNO_H__ */