note.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2013-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___HA_NOTE_H__
#define __MOTR___HA_NOTE_H__

/* import */
#include "fid/fid.h"
#include "fid/fid_xc.h"
#include "lib/chan.h"
#include "lib/types.h"
#include "lib/buf.h"          /* m0_buf, m0_bufs */
#include "lib/buf_xc.h"       /* m0_buf_xc, m0_bufs_xc */
#include "lib/mutex.h"        /* m0_mutex */
#include "lib/tlist.h"        /* m0_tl */
#include "lib/atomic.h"       /* m0_atomic64 */
#include "xcode/xcode_attr.h"
#include "ha/dispatcher.h"    /* m0_ha_handler */

/* export */
struct m0_ha_note;
struct m0_ha_nvec;

/* foward declaration */
struct m0_conf_obj;

enum m0_ha_obj_state {
        M0_NC_UNKNOWN,
        M0_NC_ONLINE,
        M0_NC_FAILED,
        M0_NC_TRANSIENT,
        M0_NC_REPAIR,
        M0_NC_REPAIRED,
        M0_NC_REBALANCE,
        M0_NC_DTM_RECOVERING,

        M0_NC_NR
};

struct m0_ha_note {
        struct m0_fid no_id;
        uint32_t      no_state;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_ha_nvec {
        int32_t            nv_nr;
        struct m0_ha_note *nv_note;
} M0_XCA_SEQUENCE M0_XCA_DOMAIN(rpc);

struct m0_ha_state_single {
        struct m0_ha_note hss_note;
        struct m0_ha_nvec hss_nvec;
};

enum m0_ha_state_update_defaults {
        M0_HA_STATE_UPDATE_LIMIT = 1024,
};

enum {
        M0_HA_NVEC_SET,
        M0_HA_NVEC_GET,
};

struct m0_ha_msg_nvec_array {
        struct m0_ha_note hmna_arr[M0_HA_STATE_UPDATE_LIMIT];
} M0_XCA_ARRAY M0_XCA_DOMAIN(rpc);

struct m0_ha_msg_nvec {
        uint64_t                    hmnv_type;
        uint64_t                    hmnv_id_of_get;
        uint64_t                    hmnv_ignore_same_state;
        uint64_t                    hmnv_nr;
        struct m0_ha_msg_nvec_array hmnv_arr;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

#define M0_NVEC_PRINT(nvec_, label, level) ({                     \
        int i;                                                    \
        struct m0_ha_nvec *nvec = nvec_;                          \
        char *lbl = label;                                        \
        for (i = 0; i < nvec->nv_nr; i++) {                       \
                M0_LOG(level, "%s [%d] " FID_F ", (%d)", lbl, i,  \
                       FID_P(&nvec->nv_note[i].no_id),            \
                       nvec->nv_note[i].no_state);                \
        }                                                         \
})

M0_INTERNAL int m0_ha_state_get(struct m0_ha_nvec *note, struct m0_chan *chan);
M0_INTERNAL void m0_ha_state_set(const struct m0_ha_nvec *note);
M0_INTERNAL void m0_ha_local_state_set(const struct m0_ha_nvec *nvec);

M0_INTERNAL void m0_ha_state_single_post(struct m0_ha_nvec     *nvec);
M0_INTERNAL void m0_ha_state_accept(const struct m0_ha_nvec *note,
                                    bool                     ignore_same_state);

M0_INTERNAL void m0_conf_ha_callback(struct m0_conf_obj *obj);

struct m0_ha_link;

M0_INTERNAL void m0_ha_msg_accept(const struct m0_ha_msg *msg,
                                  struct m0_ha_link      *hl);
M0_INTERNAL uint64_t
m0_ha_msg_nvec_send(const struct m0_ha_nvec *nvec,
                    uint64_t                 id_of_get,
                    bool                     ignore_same_state,
                    int                      direction,
                    struct m0_ha_link       *hl);

struct m0_ha_note_handler {
        struct m0_tl             hnh_gets;
        struct m0_mutex          hnh_lock;
        struct m0_ha_handler     hnh_handler;
        struct m0_ha_dispatcher *hnh_dispatcher;
        uint64_t                 hnh_id_of_get;
};

M0_INTERNAL int m0_ha_note_handler_init(struct m0_ha_note_handler *hnh,
                                        struct m0_ha_dispatcher   *hd);
M0_INTERNAL void m0_ha_note_handler_fini(struct m0_ha_note_handler *hnh);

M0_INTERNAL uint64_t m0_ha_note_handler_add(struct m0_ha_note_handler *hnh,
                                            struct m0_ha_nvec         *nvec_req,
                                            struct m0_chan            *chan);
M0_INTERNAL void m0_ha_note_handler_signal(struct m0_ha_note_handler *hnh,
                                           struct m0_ha_nvec         *nvec_rep,
                                           uint64_t                   id);

M0_INTERNAL const char *m0_ha_state2str(enum m0_ha_obj_state state);

#endif /* __MOTR___HA_NOTE_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */
/*
 * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
 */