rm_internal.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_INTERNAL_H__
#define __MOTR_RM_RM_INTERNAL_H__

#include "lib/bob.h"
#include "lib/cookie.h"
#include "rm/rm.h"

enum m0_file_credit {
        RM_FILE_LOCK = 1
};

enum m0_rwlock_credit {
        RM_RW_READ_LOCK  = 1,
        RM_RW_WRITE_LOCK = ~0ULL
};

enum {
        WAIT_TRY_FLAGS = RIF_LOCAL_WAIT | RIF_LOCAL_TRY,
};

struct m0_rm_remote_incoming {
        struct m0_rm_incoming ri_incoming;
        struct m0_cookie      ri_owner_cookie;
        struct m0_cookie      ri_rem_owner_cookie;
        struct m0_cookie      ri_loan_cookie;
        struct m0_uint128     ri_group_id;
};

M0_INTERNAL int m0_rm_pin_add(struct m0_rm_incoming *in,
                              struct m0_rm_credit   *credit,
                              uint32_t               flags);

M0_INTERNAL int granted_maybe_reserve(struct m0_rm_credit *granted,
                                      struct m0_rm_credit *to_cache);

M0_INTERNAL int m0_rm_borrow_commit(struct m0_rm_remote_incoming *bor);

M0_INTERNAL int m0_rm_revoke_commit(struct m0_rm_remote_incoming *rvk);

M0_INTERNAL int m0_rm_borrow_done(struct m0_rm_outgoing *out,
                                  struct m0_rm_loan *loan);

int m0_rm_revoke_done(struct m0_rm_outgoing *out);

int m0_rm_resource_owner_find(const struct m0_rm_resource *resource,
                              struct m0_rm_owner **owner);

M0_INTERNAL int m0_rm_request_out(enum m0_rm_outgoing_type otype,
                                  struct m0_rm_incoming *in,
                                  struct m0_rm_loan *loan,
                                  struct m0_rm_credit *credit,
                                  struct m0_rm_remote *remote);

M0_INTERNAL void m0_rm_outgoing_send(struct m0_rm_outgoing *outgoing);

M0_INTERNAL int m0_rm_outgoing_init(struct m0_rm_outgoing    *out,
                                    enum m0_rm_outgoing_type  req_type,
                                    struct m0_rm_remote      *other,
                                    struct m0_rm_credit      *credit);

M0_INTERNAL void m0_rm_outgoing_fini(struct m0_rm_outgoing *out);

M0_INTERNAL int m0_rm_loan_init(struct m0_rm_loan         *loan,
                                const struct m0_rm_credit *credit,
                                struct m0_rm_remote       *creditor);

M0_INTERNAL void m0_rm_loan_fini(struct m0_rm_loan *loan);

M0_INTERNAL int m0_rm_loan_alloc(struct m0_rm_loan         **loan,
                                 const struct m0_rm_credit  *credit,
                                 struct m0_rm_remote        *creditor);

M0_INTERNAL int m0_rm_owner_loan_debit(struct m0_rm_owner *owner,
                                       struct m0_rm_loan  *paid_loan,
                                       struct m0_tl       *list);
M0_INTERNAL int m0_rm_loan_settle(struct m0_rm_owner *owner,
                                  struct m0_rm_loan  *loan);

M0_INTERNAL void m0_rm_outgoing_complete(struct m0_rm_outgoing *og);

M0_INTERNAL int
m0_rm_reverse_session_get(struct m0_rm_remote_incoming *rem_in,
                          struct m0_rm_remote          *remote);

M0_TL_DESCR_DECLARE(res, extern);
M0_TL_DECLARE(res, M0_INTERNAL, struct m0_rm_resource);

M0_TL_DESCR_DECLARE(m0_rm_ur, extern);
M0_TL_DECLARE(m0_rm_ur, M0_INTERNAL, struct m0_rm_credit);

M0_TL_DESCR_DECLARE(m0_remotes, extern);
M0_TL_DECLARE(m0_remotes, M0_INTERNAL, struct m0_rm_remote);

M0_TL_DESCR_DECLARE(m0_owners, extern);
M0_TL_DECLARE(m0_owners, M0_INTERNAL, struct m0_rm_owner);

M0_TL_DESCR_DECLARE(pr, extern);
M0_TL_DECLARE(pr, M0_INTERNAL, struct m0_rm_pin);

M0_TL_DESCR_DECLARE(pi, extern);
M0_TL_DECLARE(pi, M0_INTERNAL, struct m0_rm_pin);

M0_EXTERN const struct m0_bob_type loan_bob;
M0_BOB_DECLARE(M0_INTERNAL, m0_rm_loan);

#define RM_OWNER_LISTS_FOR(owner, expr)                                 \
({                                                                      \
        struct m0_rm_owner *__o = (owner);                              \
        int                 __i;                                        \
        int                 __j;                                        \
                                                                        \
        (expr)(&__o->ro_borrowed);                                      \
        (expr)(&__o->ro_sublet);                                        \
                                                                        \
        for (__i = 0; __i < ARRAY_SIZE(__o->ro_owned); __i++)           \
                (expr)(&__o->ro_owned[__i]);                            \
                                                                        \
        for (__i = 0; __i < ARRAY_SIZE(__o->ro_incoming); __i++) {      \
                for (__j = 0; __j < ARRAY_SIZE(__o->ro_incoming[__i]); __j++) \
                        (expr)(&__o->ro_incoming[__i][__j]);            \
        }                                                               \
                                                                        \
        for (__i = 0; __i < ARRAY_SIZE(__o->ro_outgoing); __i++)        \
                (expr)(&__o->ro_outgoing[__i]);                         \
})

static inline enum m0_rm_incoming_state
incoming_state(const struct m0_rm_incoming *in)
{
        return (enum m0_rm_incoming_state)in->rin_sm.sm_state;
}

static inline struct m0_rm_resource *
incoming_to_resource(struct m0_rm_incoming *in)
{
        return in->rin_want.cr_owner->ro_resource;
}

static inline enum m0_rm_owner_state
owner_state(const struct m0_rm_owner *owner)
{
        return (enum m0_rm_owner_state)owner->ro_sm.sm_state;
}

static inline struct m0_sm_group *
resource_grp(const struct m0_rm_resource *res)
{
        return &res->r_type->rt_sm_grp;
}

static inline struct m0_sm_group *
owner_grp(const struct m0_rm_owner *owner)
{
        return resource_grp(owner->ro_resource);
}

M0_INTERNAL struct m0_rm_remote *
m0_rm_remote_find(struct m0_rm_remote_incoming *rem_in);

/* __MOTR_RM_RM_INTERNAL_H__ */
#endif

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