finject.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#pragma once

#ifndef __MOTR_LIB_FINJECT_H__
#define __MOTR_LIB_FINJECT_H__

#ifdef HAVE_CONFIG_H
#  include "config.h"     /* ENABLE_FAULT_INJECTION */
#endif

#include "lib/types.h"
#include "lib/assert.h"   /* M0_PRE */

M0_INTERNAL int m0_fi_init(void);

M0_INTERNAL void m0_fi_fini(void);

M0_INTERNAL void m0_fi_print_info(void);

struct m0_fi_fpoint_state;

struct m0_fi_fault_point {
        const char                 *fp_module;
        const char                 *fp_file;
        uint32_t                   fp_line_num;
        const char                 *fp_func;
        const char                 *fp_tag;
        struct m0_fi_fpoint_state  *fp_state;
};

enum m0_fi_fpoint_type {
        M0_FI_ALWAYS,
        M0_FI_ONESHOT,
        M0_FI_RANDOM,
        M0_FI_OFF_N_ON_M,
        M0_FI_FUNC,
        /* Not valid FP type (used by internal API) */
        M0_FI_INVALID_TYPE,
        /* this should be the last  */
        M0_FI_TYPES_NR
};

typedef bool (*m0_fi_fpoint_state_func_t)(void *data);

struct m0_fi_fpoint_data {
        enum m0_fi_fpoint_type    fpd_type;
        union {
                struct {
                        uint32_t  fpd_n;
                        uint32_t  fpd_m;
                        uint32_t  fpd___n_cnt;
                        uint32_t  fpd___m_cnt;
                } s1;
                struct {
                        m0_fi_fpoint_state_func_t  fpd_trigger_func;
                        void                       *fpd_private;
                } s2;
                uint32_t          fpd_p;
        } u;
        uint32_t                  fpd_hit_cnt;
        uint32_t                  fpd_trigger_cnt;
};

#ifdef ENABLE_FAULT_INJECTION

#define M0_FI_ENABLED(tag)                              \
({                                                      \
        static struct m0_fi_fault_point fp = {          \
                .fp_state    = NULL,                    \
 /* TODO: add some macro to automatically get name of current module */ \
                .fp_module   = "UNKNOWN",               \
                .fp_file     = __FILE__,                \
                .fp_line_num = __LINE__,                \
                .fp_func     = __func__,                \
                .fp_tag      = (tag),                   \
        };                                              \
                                                        \
        if (unlikely(fp.fp_state == NULL)) {            \
                m0_fi_register(&fp);                    \
                M0_ASSERT(fp.fp_state != NULL);         \
        }                                               \
                                                        \
        m0_fi_enabled(fp.fp_state);                     \
})

M0_INTERNAL void m0_fi_enable_generic(const char *fp_func, const char *fp_tag,
                                      const struct m0_fi_fpoint_data *fp_data);

static inline void m0_fi_enable(const char *func, const char *tag)
{
/*
 * Our headers are processed by gccxml, which is essentially a C++
 * compiler, and it doesn't support C99 compound literals and designated
 * initializers. So we want to hide this fancy code from gccxml to protect it
 * from brain damage :D It's safe, because we are interested only in type
 * definition information, produced by gccxml, and not a function
 * implementation.
 */
#if !defined(__cplusplus)
        m0_fi_enable_generic(func, tag, &(const struct m0_fi_fpoint_data){
                                                .fpd_type = M0_FI_ALWAYS });
#endif
}

static inline void m0_fi_enable_once(const char *func, const char *tag)
{
/* See the comment inside m0_fi_enable() about purpose of this C++ guard */
#if !defined(__cplusplus)
        m0_fi_enable_generic(func, tag, &(const struct m0_fi_fpoint_data){
                                                .fpd_type = M0_FI_ONESHOT });
#endif
}

static inline void m0_fi_enable_random(const char *func, const char *tag,
                                       uint32_t p)
{
/* See the comment inside m0_fi_enable() about purpose of this C++ guard */
#if !defined(__cplusplus)
        m0_fi_enable_generic(func, tag, &(const struct m0_fi_fpoint_data){
                                                .fpd_type = M0_FI_RANDOM,
                                                .u = { .fpd_p = p } });
#endif
}

static inline void m0_fi_enable_off_n_on_m(const char *func, const char *tag,
                                           uint32_t n, uint32_t m)
{
/* See the comment inside m0_fi_enable() about purpose of this C++ guard */
#if !defined(__cplusplus)
        m0_fi_enable_generic(func, tag,
                        &(const struct m0_fi_fpoint_data){
                                .fpd_type = M0_FI_OFF_N_ON_M,
                                .u = { .s1 = { .fpd_n = n, .fpd_m = m } } });
#endif
}

static inline void m0_fi_enable_each_nth_time(const char *func, const char *tag,
                                              uint32_t n)
{
        M0_PRE(n > 0);
        m0_fi_enable_off_n_on_m(func, tag, n - 1, 1);
}

static inline void m0_fi_enable_func(const char *func, const char *tag,
                                     m0_fi_fpoint_state_func_t trigger_func,
                                     void *data)
{
/* See the comment inside m0_fi_enable() about purpose of this C++ guard */
#if !defined(__cplusplus)
        m0_fi_enable_generic(func, tag,
                        &(const struct m0_fi_fpoint_data){
                                .fpd_type = M0_FI_FUNC,
                                .u = { .s2 = {
                                          .fpd_trigger_func = trigger_func,
                                          .fpd_private = data
                                       }
                                 } });
#endif
}

M0_INTERNAL void m0_fi_disable(const char *fp_func, const char *fp_tag);

void m0_fi_register(struct m0_fi_fault_point *fp);

bool m0_fi_enabled(struct m0_fi_fpoint_state *fps);

M0_INTERNAL enum m0_fi_fpoint_type m0_fi_fpoint_type_from_str(const char
                                                              *type_name);

#else /* ENABLE_FAULT_INJECTION */
#define M0_FI_ENABLED(tag)                               (false)

static inline void m0_fi_enable_generic(const char *fp_func, const char *fp_tag,
                                        const struct m0_fi_fpoint_data *fp_data)
{
}

static inline void m0_fi_enable(const char *func, const char *tag)
{
}

static inline void m0_fi_enable_once(const char *func, const char *tag)
{
}

static inline void m0_fi_enable_random(const char *func, const char *tag,
                                       uint32_t p)
{
}

static inline void m0_fi_enable_each_nth_time(const char *func, const char *tag,
                                              uint32_t n)
{
}

static inline void m0_fi_enable_off_n_on_m(const char *func, const char *tag,
                                           uint32_t n, uint32_t m)
{
}

static inline void m0_fi_enable_func(const char *func, const char *tag,
                                     m0_fi_fpoint_state_func_t trigger_func,
                                     void *data)
{
}

static inline void m0_fi_disable(const char *fp_func, const char *fp_tag)
{
}

static inline void m0_fi_register(struct m0_fi_fault_point *fp)
{
}

static inline bool m0_fi_enabled(struct m0_fi_fpoint_state *fps)
{
        return false;
}

#endif /* ENABLE_FAULT_INJECTION */
M0_INTERNAL int m0_fi_enable_fault_point(const char *str);
M0_INTERNAL int m0_fi_enable_fault_points_from_file(const char *file_name);
#endif /* __MOTR_LIB_FINJECT_H__ */