rm.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_RM_RM_H__
#define __MOTR_RM_RM_H__

#include "lib/tlist.h"
#include "lib/types.h"
#include "lib/cookie.h"
#include "lib/chan.h"   /* m0_clink */
#include "fid/fid.h"    /* m0_fid */
#include "net/net.h"
#include "sm/sm.h"
#include "rm/rm_ha.h"   /* m0_rm_ha_tracker */

/* import */
struct m0_bufvec_cursor;

/* export */
struct m0_rm_domain;
struct m0_rm_resource;
struct m0_rm_resource_ops;
struct m0_rm_resource_type;
struct m0_rm_resource_type_ops;
struct m0_rm_owner;
struct m0_rm_remote;
struct m0_rm_loan;
struct m0_rm_group;
struct m0_rm_credit;
struct m0_rm_credit_ops;
struct m0_rm_incoming;
struct m0_rm_incoming_ops;
struct m0_rm_outgoing;
struct m0_rm_lease;

enum {
        M0_RM_RESOURCE_TYPE_ID_MAX = 64,
};

enum {
        M0_RM_OWNER_FT = 'O',
};

enum m0_rm_incoming_type {
        M0_RIT_LOCAL,
        M0_RIT_BORROW,
        M0_RIT_REVOKE,
        M0_RIT_NR
};

extern const struct m0_uint128 m0_rm_no_group;

struct m0_rm_domain {
        struct m0_rm_resource_type *rd_types[M0_RM_RESOURCE_TYPE_ID_MAX];
        struct m0_mutex             rd_lock;
};

struct m0_rm_resource {
        struct m0_rm_resource_type      *r_type;
        const struct m0_rm_resource_ops *r_ops;
        struct m0_tlink                  r_linkage;
        struct m0_tl                     r_remotes;
        struct m0_mutex                  r_mutex;
        struct m0_tl                     r_local;
        uint32_t                         r_ref;
        uint64_t                         r_magix;
};

struct m0_rm_resource_ops {
        int (*rop_credit_decode)(struct m0_rm_resource *resource,
                                 struct m0_rm_credit *credit,
                                 struct m0_bufvec_cursor *cur);
        void (*rop_policy)(struct m0_rm_resource *resource,
                           struct m0_rm_incoming *in);
        void (*rop_credit_init)(struct m0_rm_resource *resource,
                                struct m0_rm_credit *credit);

        void (*rop_resource_free)(struct m0_rm_resource *resource);
};

enum m0_res_type_id {
        M0_RM_FLOCK_RT      = 1,
        M0_RM_RWLOCKABLE_RT = 2
};

struct m0_rm_resource_type {
        const struct m0_rm_resource_type_ops *rt_ops;
        const char                           *rt_name;
        uint64_t                              rt_id;
        struct m0_mutex                       rt_lock;
        struct m0_tl                          rt_resources;
        uint32_t                              rt_nr_resources;
        struct m0_sm_group                    rt_sm_grp;
        struct m0_thread                      rt_worker;
        bool                                  rt_stop_worker;
        struct m0_rm_domain                  *rt_dom;

        struct m0_mutex                       rt_queue_guard;

        struct m0_queue                       rt_ha_events;
};

struct m0_rm_resource_type_ops {
        bool (*rto_eq)(const struct m0_rm_resource *resource0,
                       const struct m0_rm_resource *resource1);
        bool (*rto_is)(const struct m0_rm_resource *resource,
                       uint64_t id);
        m0_bcount_t (*rto_len) (const struct m0_rm_resource *resource);
        int  (*rto_decode)(struct m0_bufvec_cursor *cur,
                           struct m0_rm_resource **resource);
        int  (*rto_encode)(struct m0_bufvec_cursor *cur,
                           const struct m0_rm_resource *resource);
};

struct m0_rm_credit {
        struct m0_rm_owner            *cr_owner;
        const struct m0_rm_credit_ops *cr_ops;
        struct m0_uint128              cr_group_id;
        m0_time_t                      cr_get_time;
        uint64_t                       cr_datum;
        struct m0_tlink                cr_linkage;
        struct m0_tl                   cr_pins;
        uint64_t                       cr_magix;
};

struct m0_rm_credit_ops {
        void (*cro_free)(struct m0_rm_credit *self);
        int  (*cro_encode)(struct m0_rm_credit *self,
                           struct m0_bufvec_cursor *cur);
        int  (*cro_decode)(struct m0_rm_credit *self,
                           struct m0_bufvec_cursor *cur);
        m0_bcount_t (*cro_len) (const struct m0_rm_credit *self);

        bool (*cro_intersects) (const struct m0_rm_credit *self,
                                const struct m0_rm_credit *c1);
        bool (*cro_is_subset) (const struct m0_rm_credit *self,
                               const struct m0_rm_credit *c1);
        int (*cro_join) (struct m0_rm_credit *self,
                         const struct m0_rm_credit *c1);
        int (*cro_disjoin) (struct m0_rm_credit *self,
                            const struct m0_rm_credit *c1,
                            struct m0_rm_credit *intersection);
        bool (*cro_conflicts) (const struct m0_rm_credit *self,
                               const struct m0_rm_credit *c1);
        int  (*cro_diff)(struct m0_rm_credit *self,
                         const struct m0_rm_credit *c1);
        int  (*cro_copy)(struct m0_rm_credit *dst,
                         const struct m0_rm_credit *self);
        void (*cro_initial_capital)(struct m0_rm_credit *self);
};

enum m0_rm_remote_state {
        REM_FREED = 0,
        REM_INITIALISED,
        REM_SERVICE_LOCATING,
        REM_SERVICE_LOCATED,
        REM_OWNER_LOCATING,
        REM_OWNER_LOCATED
};

struct m0_rm_remote {
        enum m0_rm_remote_state rem_state;
        struct m0_rm_resource  *rem_resource;
        struct m0_clink         rem_rev_sess_clink;
        struct m0_rpc_session  *rem_session;
        struct m0_chan          rem_signal;
        struct m0_tlink         rem_res_linkage;
        struct m0_cookie        rem_cookie;
        struct m0_ref           rem_refcnt;
        uint64_t                rem_id;
        struct m0_rm_ha_tracker rem_tracker;
        bool                    rem_dead;
        uint64_t                rem_magix;
};

enum m0_rm_owner_state {
        ROS_INITIAL = 1,
        ROS_INITIALISING,
        ROS_ACTIVE,
        ROS_QUIESCE,
        ROS_FINALISING,

        ROS_DEAD_CREDITOR,
        ROS_INSOLVENT,
        ROS_FINAL
};

enum {
        M0_RM_REQUEST_PRIORITY_MAX = 3,
        M0_RM_REQUEST_PRIORITY_NR
};

enum m0_rm_owner_owned_state {
        OWOS_HELD,
        OWOS_CACHED,
        OWOS_NR
};

enum m0_rm_owner_queue_state {
        OQS_GROUND,
        OQS_EXCITED,
        OQS_NR
};

struct m0_rm_owner {
        struct m0_sm           ro_sm;
        struct m0_fid          ro_fid;
        struct m0_rm_resource *ro_resource;
        struct m0_uint128      ro_group_id;
        struct m0_rm_remote   *ro_creditor;
        struct m0_tl           ro_borrowed;
        struct m0_tl           ro_sublet;
        struct m0_tl           ro_owned[OWOS_NR];
        struct m0_tl           ro_incoming[M0_RM_REQUEST_PRIORITY_NR][OQS_NR];
        struct m0_tl           ro_outgoing[OQS_NR];
        struct m0_tlink        ro_owner_linkage;
        uint64_t               ro_id;
        bool                   ro_user_windup;
        uint64_t               ro_seq;
        uint64_t               ro_magix;
};

enum {
        M0_RM_LOAN_SELF_ID = 1
};

struct m0_rm_loan {
        struct m0_rm_credit  rl_credit;
        struct m0_rm_remote *rl_other;
        struct m0_cookie     rl_cookie;
        uint64_t             rl_id;
        uint64_t             rl_magix;
};

enum m0_rm_incoming_state {
        RI_INITIALISED = 1,
        RI_CHECK,
        RI_SUCCESS,
        RI_FAILURE,
        RI_WAIT,
        RI_RELEASED,
        RI_FINAL
};

enum m0_rm_incoming_policy {
        RIP_NONE = 1,
        RIP_INPLACE,
        RIP_STRICT,
        RIP_JOIN,
        RIP_MAX,
        RIP_NR
};

enum m0_rm_incoming_flags {
        RIF_MAY_REVOKE = (1 << 0),
        RIF_MAY_BORROW = (1 << 1),
        RIF_LOCAL_WAIT = (1 << 2),
        RIF_LOCAL_TRY  = (1 << 3),
        RIF_RESERVE    = (1 << 4),
};

struct m0_rm_reserve_prio {
        m0_time_t     rrp_time;
        struct m0_fid rrp_owner;
        uint64_t      rrp_seq;
};


struct m0_rm_incoming {
        enum m0_rm_incoming_type         rin_type;
        struct m0_sm                     rin_sm;
        int32_t                          rin_rc;
        enum m0_rm_incoming_policy       rin_policy;
        uint64_t                         rin_flags;
        struct m0_rm_credit              rin_want;
        struct m0_tl                     rin_pins;
        int                              rin_priority;
        const struct m0_rm_incoming_ops *rin_ops;
        m0_time_t                        rin_req_time;
        struct m0_rm_reserve_prio        rin_reserve;
        struct m0_rm_remote             *rin_remote;
        uint64_t                         rin_magix;
};

struct m0_rm_incoming_ops {
        void (*rio_complete)(struct m0_rm_incoming *in, int32_t rc);
        void (*rio_conflict)(struct m0_rm_incoming *in);
};

enum m0_rm_outgoing_type {
        M0_ROT_BORROW = 1,
        M0_ROT_CANCEL,
        M0_ROT_REVOKE
};

struct m0_rm_outgoing {
        enum m0_rm_outgoing_type rog_type;
        /*
         * The error code (from reply or timeout) for this outgoing request.
         */
        int32_t                  rog_rc;
        struct m0_rm_loan        rog_want;
        bool                     rog_sent;
        uint64_t                 rog_magix;
};

enum m0_rm_pin_flags {
        M0_RPF_TRACK   = (1 << 0),
        M0_RPF_PROTECT = (1 << 1),
        M0_RPF_BARRIER = (1 << 2)
};

struct m0_rm_pin {
        uint32_t               rp_flags;
        struct m0_rm_credit   *rp_credit;
        struct m0_rm_incoming *rp_incoming;
        struct m0_tlink        rp_credit_linkage;
        struct m0_tlink        rp_incoming_linkage;
        uint64_t               rp_magix;
};

M0_INTERNAL void m0_rm_domain_init(struct m0_rm_domain *dom);
M0_INTERNAL void m0_rm_domain_fini(struct m0_rm_domain *dom);

M0_INTERNAL int m0_rm_type_register(struct m0_rm_domain *dom,
                                    struct m0_rm_resource_type *rt);

M0_INTERNAL void m0_rm_type_deregister(struct m0_rm_resource_type *rtype);

M0_INTERNAL struct m0_rm_resource_type *
m0_rm_resource_type_lookup(const struct m0_rm_domain *dom,
                           const uint64_t             rtype_id);

M0_INTERNAL struct m0_rm_resource *
m0_rm_resource_find(const struct m0_rm_resource_type *rt,
                    const struct m0_rm_resource      *res);

M0_INTERNAL void m0_rm_resource_add(struct m0_rm_resource_type *rtype,
                                    struct m0_rm_resource *res);
M0_INTERNAL void m0_rm_resource_del(struct m0_rm_resource *res);

M0_INTERNAL void m0_rm_resource_free(struct m0_rm_resource *res);

M0_INTERNAL int m0_rm_resource_encode(struct m0_rm_resource *res,
                                      struct m0_buf         *buf);

M0_INTERNAL void
m0_rm_resource_initial_credit(const struct m0_rm_resource *resource,
                              struct m0_rm_credit *credit);

M0_INTERNAL void m0_rm_owner_init(struct m0_rm_owner      *owner,
                                  struct m0_fid           *fid,
                                  const struct m0_uint128 *group,
                                  struct m0_rm_resource   *res,
                                  struct m0_rm_remote     *creditor);

M0_INTERNAL void m0_rm_owner_init_rfid(struct m0_rm_owner      *owner,
                                       const struct m0_uint128 *group,
                                       struct m0_rm_resource   *res,
                                       struct m0_rm_remote     *creditor);

M0_INTERNAL int m0_rm_owner_selfadd(struct m0_rm_owner *owner,
                                    struct m0_rm_credit *r);

M0_INTERNAL void m0_rm_owner_windup(struct m0_rm_owner *owner);

M0_INTERNAL void m0_rm_owner_creditor_reset(struct m0_rm_owner  *owner,
                                            struct m0_rm_remote *creditor);

M0_INTERNAL int m0_rm_owner_timedwait(struct m0_rm_owner *owner,
                                      uint64_t state,
                                      const m0_time_t abs_timeout);
M0_INTERNAL void m0_rm_owner_fini(struct m0_rm_owner *owner);

M0_INTERNAL void m0_rm_owner_lock(struct m0_rm_owner *owner);
M0_INTERNAL void m0_rm_owner_unlock(struct m0_rm_owner *owner);

M0_INTERNAL void m0_rm_credit_init(struct m0_rm_credit *credit,
                                   struct m0_rm_owner *owner);

M0_INTERNAL void m0_rm_credit_fini(struct m0_rm_credit *credit);

M0_INTERNAL int m0_rm_credit_dup(const struct m0_rm_credit *src_credit,
                                struct m0_rm_credit **dest_credit);

/*
 * Makes another copy of credit src.
 */
M0_INTERNAL int
m0_rm_credit_copy(struct m0_rm_credit *dst, const struct m0_rm_credit *src);

M0_INTERNAL void m0_rm_incoming_init(struct m0_rm_incoming *in,
                                     struct m0_rm_owner *owner,
                                     enum m0_rm_incoming_type type,
                                     enum m0_rm_incoming_policy policy,
                                     uint64_t flags);

M0_INTERNAL void m0_rm_incoming_fini(struct m0_rm_incoming *in);

M0_INTERNAL void m0_rm_remote_init(struct m0_rm_remote *rem,
                                   struct m0_rm_resource *res);

M0_INTERNAL void m0_rm_remote_fini(struct m0_rm_remote *rem);

#define M0_RM_REMOTE_GET(remote)                                        \
({                                                                      \
        struct m0_rm_remote *_r = (remote);                             \
        int                  _c = m0_ref_read(&_r->rem_refcnt);         \
        M0_LOG(M0_DEBUG, "rm_remote=%p ref: %d -> %d", _r, _c, _c + 1); \
        m0_ref_get(&_r->rem_refcnt);                                    \
})

#define M0_RM_REMOTE_PUT(remote)                                        \
({                                                                      \
        int                  _c;                                        \
        struct m0_rm_remote *_r = (remote);                             \
        struct m0_mutex     *_m = &_r->rem_resource->r_mutex;           \
        m0_mutex_lock(_m);                                              \
        _c = m0_ref_read(&_r->rem_refcnt);                              \
        M0_LOG(M0_DEBUG, "rm_remote=%p ref: %d -> %d", _r, _c, _c - 1); \
        m0_ref_put(&_r->rem_refcnt);                                    \
        m0_mutex_unlock(_m);                                            \
})

M0_INTERNAL void m0_rm_credit_get(struct m0_rm_incoming *in);

M0_INTERNAL void m0_rm_credit_put(struct m0_rm_incoming *in);

M0_INTERNAL int m0_rm_credit_encode(struct m0_rm_credit *credit,
                                    struct m0_buf *buf);

M0_INTERNAL int m0_rm_credit_decode(struct m0_rm_credit *credit,
                                   struct m0_buf *buf);


M0_INTERNAL int m0_rm_net_locate(struct m0_rm_credit *credit,
                                 struct m0_rm_remote *other);

M0_INTERNAL void m0_rm_remote_owner_set(struct m0_rm_remote *rem, uint64_t id);

/* __MOTR_RM_RM_H__ */
#endif

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