fom.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_FOP_FOM_H__
#define __MOTR_FOP_FOM_H__

/* import */

#include "lib/queue.h"
#include "lib/thread.h"
#include "lib/bitmap.h"
#include "lib/mutex.h"
#include "lib/chan.h"
#include "lib/atomic.h"
#include "lib/tlist.h"
#include "lib/locality.h"

#include "dtm/dtm.h"               /* m0_dtx */
#include "fol/fol.h"
#include "stob/stob.h"
#include "addb2/counter.h"
#include "addb2/histogram.h"
#include "addb2/sys.h"

struct m0_addb2_mach;

/* import */
struct m0_reqh_service;
struct m0_reqh_service_type;

/* export */
struct m0_fom_domain;
struct m0_fom_domain_ops;
struct m0_fom_locality;
struct m0_fom_type;
struct m0_fom_type_ops;
struct m0_fom;
struct m0_fom_ops;
struct m0_long_lock;

/* defined in fom.c */
struct m0_loc_thread;

#define FOM_PHASE_DEBUG (1)

struct m0_fom_locality {
        struct m0_fom_domain          *fl_dom;

        struct m0_tl                   fl_runq;
        size_t                         fl_runq_nr;

        struct m0_tl                   fl_wail;
        size_t                         fl_wail_nr;

        unsigned                       fl_foms;

        struct m0_sm_group             fl_group;

        struct m0_chan                 fl_runrun;
        bool                           fl_shutdown;
        struct m0_loc_thread          *fl_handler;
        struct m0_tl                   fl_threads;
        struct m0_atomic64             fl_unblocking;
        struct m0_chan                 fl_idle;
        struct m0_bitmap               fl_processors;
        int                            fl_idx;
        struct m0_addb2_mach          *fl_addb2_mach;
        struct m0_addb2_hist           fl_fom_active;
        struct m0_addb2_hist           fl_runq_counter;
        struct m0_addb2_hist           fl_wail_counter;
        struct m0_addb2_sensor         fl_clock;
        struct m0_locality             fl_locality;
        struct m0_sm_group_addb2       fl_grp_addb2;
        struct m0_chan_addb2           fl_chan_addb2;
};

M0_INTERNAL bool m0_locality_invariant(const struct m0_fom_locality *loc);

M0_INTERNAL void m0_fom_locality_post_stats(struct m0_fom_locality *loc);

struct m0_fom_domain {
        struct m0_fom_locality        **fd_localities;
        size_t                          fd_localities_nr;
        const struct m0_fom_domain_ops *fd_ops;
        struct m0_locality_chore        fd_hung_foms_chore;
        struct m0_addb2_sys            *fd_addb2_sys;
};

struct m0_fom_domain_ops {
        bool   (*fdo_time_is_out)(const struct m0_fom_domain *dom,
                                  const struct m0_fom *fom);
};

enum m0_fom_state {
        M0_FOS_INIT,
        M0_FOS_READY,
        M0_FOS_RUNNING,
        M0_FOS_WAITING,
        M0_FOS_FINISH,
};

enum { M0_FOS_TRANS_NR = 8 };

enum m0_fom_phase {
        M0_FOM_PHASE_INIT,   /*< 0 fom has been initialised. */
        M0_FOM_PHASE_FINISH, /*< 1 terminal phase. */
        M0_FOM_PHASE_NR      /*< 2 */
};


M0_INTERNAL int m0_fom_domain_init(struct m0_fom_domain **dom);

M0_INTERNAL void m0_fom_domain_fini(struct m0_fom_domain *dom);

M0_INTERNAL bool m0_fom_domain_is_idle(const struct m0_fom_domain *dom);
M0_INTERNAL bool m0_fom_domain_is_idle_for(const struct m0_reqh_service *svc);

M0_INTERNAL bool m0_fom_domain_invariant(const struct m0_fom_domain *dom);

M0_INTERNAL void m0_fom_locality_inc(struct m0_fom *fom);

M0_INTERNAL bool m0_fom_locality_dec(struct m0_fom *fom);

enum m0_fc_state {
        M0_FCS_ARMED = 1,       
        M0_FCS_DONE,            
};

struct m0_fom_callback {
        struct m0_clink   fc_clink;
        struct m0_sm_ast  fc_ast;
        enum m0_fc_state  fc_state;
        struct m0_fom    *fc_fom;
        bool (*fc_top)(struct m0_fom_callback *cb);
        void (*fc_bottom)(struct m0_fom_callback *cb);
};

struct m0_fom {
        struct m0_fom_locality   *fo_loc;
        size_t                    fo_loc_idx;
        const struct m0_fom_type *fo_type;
        const struct m0_fom_ops  *fo_ops;
        struct m0_fom_callback    fo_cb;
        struct m0_fop            *fo_fop;
        struct m0_fop            *fo_rep_fop;
        struct m0_dtx             fo_tx;
        bool                      fo_local;
        struct m0_reqh_service   *fo_service;
        struct m0_tlink           fo_linkage;
        unsigned                  fo_transitions;
        unsigned                  fo_transitions_saved;

        struct m0_sm              fo_sm_phase;
        struct m0_sm              fo_sm_state;
        struct m0_loc_thread     *fo_thread;
        struct m0_fom_callback   *fo_pending;
#if FOM_PHASE_DEBUG
        int                       fo_log[32];
#endif
        uint64_t                  fo_magic;
};

static inline struct m0_be_tx *m0_fom_tx(struct m0_fom *fom)
{
        return &fom->fo_tx.tx_betx;
}

static inline struct m0_be_tx_credit *m0_fom_tx_credit(struct m0_fom *fom)
{
        return &fom->fo_tx.tx_betx_cred;
}

M0_INTERNAL void m0_fom_queue(struct m0_fom *fom);

M0_INTERNAL struct m0_reqh *m0_fom_reqh(const struct m0_fom *fom);

void m0_fom_init(struct m0_fom *fom, const struct m0_fom_type *fom_type,
                 const struct m0_fom_ops *ops, struct m0_fop *fop,
                 struct m0_fop *reply, struct m0_reqh *reqh);
void m0_fom_fini(struct m0_fom *fom);

M0_INTERNAL bool m0_fom_invariant(const struct m0_fom *fom);

struct m0_fom_type {
        uint64_t                           ft_id;
        const struct m0_fom_type_ops      *ft_ops;
              struct m0_sm_conf            ft_conf;
              struct m0_sm_conf            ft_state_conf;
        const struct m0_reqh_service_type *ft_rstype;
};

enum m0_fom_phase_outcome {
        M0_FSO_WAIT = 1,
        M0_FSO_AGAIN,
        M0_FSO_NR
};

struct m0_fom_type_ops {
        int (*fto_create)(struct m0_fop *fop, struct m0_fom **out,
                          struct m0_reqh *reqh);
};

struct m0_fom_ops {
        void (*fo_fini)(struct m0_fom *fom);
        int  (*fo_tick)(struct m0_fom *fom);
        size_t  (*fo_home_locality) (const struct m0_fom *fom);
        void (*fo_addb2_descr)(struct m0_fom *fom);

        void (*fo_hung_notify)(const struct m0_fom *fom);
};

M0_INTERNAL void m0_fom_block_enter(struct m0_fom *fom);

M0_INTERNAL void m0_fom_block_leave(struct m0_fom *fom);

M0_INTERNAL void m0_fom_ready(struct m0_fom *fom);

M0_INTERNAL void m0_fom_wakeup(struct m0_fom *fom);

M0_INTERNAL void m0_fom_callback_init(struct m0_fom_callback *cb);

M0_INTERNAL void m0_fom_callback_arm(struct m0_fom *fom, struct m0_chan *chan,
                                     struct m0_fom_callback *cb);

M0_INTERNAL bool m0_fom_is_waiting_on(const struct m0_fom *fom);

M0_INTERNAL void m0_fom_wait_on(struct m0_fom *fom, struct m0_chan *chan,
                                struct m0_fom_callback *cb);

M0_INTERNAL void m0_fom_callback_fini(struct m0_fom_callback *cb);

M0_INTERNAL void m0_fom_callback_cancel(struct m0_fom_callback *cb);

struct m0_fom_timeout {
        struct m0_sm_timer     to_timer;
        struct m0_fom_callback to_cb;
};

M0_INTERNAL void m0_fom_timeout_init(struct m0_fom_timeout *to);
M0_INTERNAL void m0_fom_timeout_fini(struct m0_fom_timeout *to);

M0_INTERNAL int m0_fom_timeout_wait_on(struct m0_fom_timeout *to,
                                       struct m0_fom *fom, m0_time_t deadline);
M0_INTERNAL int m0_fom_timeout_arm(struct m0_fom_timeout *to,
                                   struct m0_fom *fom,
                                   void (*cb)(struct m0_fom_callback *),
                                   m0_time_t deadline);
M0_INTERNAL void m0_fom_timeout_cancel(struct m0_fom_timeout *to);

M0_INTERNAL bool m0_fom_group_is_locked(const struct m0_fom *fom);

M0_INTERNAL void m0_fom_sm_init(struct m0_fom *fom);

void m0_fom_phase_set(struct m0_fom *fom, int phase);

void m0_fom_phase_move(struct m0_fom *fom, int32_t rc, int phase);

void m0_fom_phase_moveif(struct m0_fom *fom, int32_t rc, int phase0,
                         int phase1);

int m0_fom_phase(const struct m0_fom *fom);

M0_INTERNAL const char *m0_fom_phase_name(const struct m0_fom *fom, int phase);

M0_INTERNAL int m0_fom_rc(const struct m0_fom *fom);

M0_INTERNAL bool m0_fom_is_waiting(const struct m0_fom *fom);

M0_INTERNAL void m0_fom_type_init(struct m0_fom_type *type, uint64_t id,
                                  const struct m0_fom_type_ops *ops,
                                  const struct m0_reqh_service_type *svc_type,
                                  const struct m0_sm_conf *sm);

M0_INTERNAL int m0_fom_addb2_init(struct m0_fom_type *type, uint64_t id);

M0_INTERNAL int m0_fom_fol_rec_add(struct m0_fom *fom);

M0_INTERNAL void m0_fom_fdmi_record_post(struct m0_fom *fom);

M0_INTERNAL struct m0_reqh *m0_fom2reqh(const struct m0_fom *fom);

M0_INTERNAL int m0_fom_timedwait(struct m0_fom *fom, uint64_t phases,
                                 m0_time_t deadline);

#endif /* __MOTR_FOP_FOM_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */