coroutine.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2017-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_COROUTINE_H__
#define __MOTR_LIB_COROUTINE_H__

#include "lib/types.h"
#include "lib/errno.h"

enum {
        M0_MCC_STACK_NR            = 0x20,
        M0_MCC_LOCALS_ALLOC_SZ     = 4096,
        M0_MCC_LOCALS_ALLOC_SHIFT  = 3,
        M0_MCC_LOCALS_ALLOC_ALIGN  = 1ULL << M0_MCC_LOCALS_ALLOC_SHIFT,
        M0_MCC_LOCALS_ALLOC_PAD_SZ = 2 * M0_MCC_LOCALS_ALLOC_ALIGN,
};

struct m0_co_la_item {
        void     *lai_addr;
        uint64_t  lai_size;
};

struct m0_co_locals_allocator {
        struct m0_co_la_item la_items[M0_MCC_STACK_NR];

        uint64_t             la_frame;

        void                *la_pool;
        uint64_t             la_total;
};

struct m0_co_context {
        void                         *mc_stack[M0_MCC_STACK_NR];
        void                         *mc_locals[M0_MCC_STACK_NR];
        uint64_t                      mc_frame;
        bool                          mc_yield;
        int                           mc_co_end_ret;
        uint64_t                      mc_yield_frame;
        struct m0_co_locals_allocator mc_alloc;
};

#define M0_CO_START(context)                                              \
({                                                                        \
        M0_ASSERT((context)->mc_yield_frame == 0);                        \
})

#define M0_CO_END(context)                                                \
({                                                                        \
        int rc = ((context)->mc_yield ? (context)->mc_co_end_ret : 0);    \
        if (rc == 0) {                                                    \
                M0_ASSERT((context)->mc_frame == 0);                      \
                M0_ASSERT((context)->mc_yield_frame == 0);                \
                m0_co_context_locals_free((context));                     \
        }                                                                 \
        rc;                                                               \
})

#define M0_CO_FUN(context, function)                                      \
({                                                                        \
        __label__ save;                                                   \
        M0_LOG(M0_DEBUG, "M0_CO_FUN: context=%p yeild=%d",                 \
               context, !!context->mc_yield);                             \
        M0_ASSERT(context->mc_frame < M0_MCC_STACK_NR);                   \
        context->mc_stack[context->mc_frame++] = &&save;                  \
save:   (function);                                                       \
        if (context->mc_yield) {                                          \
                return;                                                   \
        } else {                                                          \
                m0_co_context_locals_free(context);                       \
                context->mc_frame--;                                      \
        }                                                                 \
})

#define M0_CO_FRAME_DATA(field) (__frame_data__->field)

#define M0_CO_REENTER(context, ...)                                       \
        struct foo_context {                                              \
                __VA_ARGS__                                               \
        };                                                                \
        struct foo_context *__frame_data__;                               \
        M0_CO__REENTER((context), __frame_data__);

#define M0_CO__REENTER(context, frame_data)                               \
({                                                                        \
        uint64_t size = sizeof(*frame_data);                              \
        M0_LOG(M0_DEBUG, "M0_CO_REENTER: context=%p yeild=%d",             \
               context, !!context->mc_yield);                             \
        if (!context->mc_yield) {                                         \
                m0_co_context_locals_alloc(context, (size));              \
                frame_data = m0_co_context_locals(context);               \
        } else {                                                          \
                M0_ASSERT(context->mc_yield_frame < M0_MCC_STACK_NR);     \
                frame_data = m0_co_context_locals(context);               \
                goto *context->mc_stack[context->mc_yield_frame++];       \
        }                                                                 \
})

#define M0_CO_YIELD_RC(context, rc)                                       \
({                                                                        \
        __label__ save;                                                   \
        M0_LOG(M0_DEBUG, "M0_CO_YIELD: context=%p yeild=%d",               \
               context, !!context->mc_yield);                             \
        context->mc_yield = true;                                         \
        context->mc_co_end_ret = (rc);                                    \
        M0_ASSERT(context->mc_frame < M0_MCC_STACK_NR);                   \
        context->mc_stack[context->mc_frame++] = &&save;                  \
        return;                                                           \
save:                                                                     \
        M0_ASSERT(context->mc_yield);                                     \
        M0_ASSERT(context->mc_frame == context->mc_yield_frame);          \
        context->mc_yield = false;                                        \
        context->mc_yield_frame = 0;                                      \
        context->mc_frame--;                                              \
})

#define M0_CO_YIELD(context) M0_CO_YIELD_RC(context, -EAGAIN)


M0_INTERNAL int m0_co_context_init(struct m0_co_context *context);
M0_INTERNAL void m0_co_context_fini(struct m0_co_context *context);

/* internal */
M0_INTERNAL void *m0_co_context_locals(struct m0_co_context *context);
M0_INTERNAL void m0_co_context_locals_alloc(struct m0_co_context *context,
                                            uint64_t size);
M0_INTERNAL void m0_co_context_locals_free(struct m0_co_context *context);

#include "sm/sm.h"         /* m0_sm_group */

struct m0_fom;

struct m0_co_op {
        struct m0_sm       co_sm;
        /* MOTR-787: get rid of explicit locking here, use locality lock! */
        struct m0_sm_group co_sm_group;
};

M0_INTERNAL void m0_co_op_init(struct m0_co_op *op);
M0_INTERNAL void m0_co_op_fini(struct m0_co_op *op);

M0_INTERNAL void m0_co_op_reset(struct m0_co_op *op);
M0_INTERNAL void m0_co_op_active(struct m0_co_op *op);
M0_INTERNAL void m0_co_op_done(struct m0_co_op *op);

/* Don't introduce co_op_wait()! co_op intended to be used inside foms. */
M0_INTERNAL int m0_co_op_tick_ret(struct m0_co_op *op,
                                  struct m0_fom   *fom,
                                  int              next_state);

#endif /* __MOTR_LIB_COROUTINE_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
 */