node.c

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.
 *
 */


#include "lib/errno.h"          /* ETIMEDOUT */
#include "lib/misc.h"           /* M0_SET0 */
#include "lib/memory.h"         /* M0_ALLOC_PTR */
#include "lib/trace.h"          /* M0_LOG */

#include "net/test/node.h"      /* m0_net_test_node_ctx */
#include "net/test/node_stub.h" /* m0_net_test_node_stub_ops */
#include "net/test/node_ping.h" /* m0_net_test_node_ping_ops */
#include "net/test/node_bulk.h" /* m0_net_test_node_bulk_ops */

#define NET_TEST_MODULE_NAME node
#include "net/test/debug.h"

enum {
        NODE_WAIT_CMD_GRANULARITY_MS = 20,
};

static struct m0_net_test_service_ops *
service_ops_get(struct m0_net_test_cmd *cmd)
{
        M0_PRE(cmd->ntc_type == M0_NET_TEST_CMD_INIT);

        switch (cmd->ntc_init.ntci_type) {
        case M0_NET_TEST_TYPE_STUB:
                return &m0_net_test_node_stub_ops;
        case M0_NET_TEST_TYPE_PING:
                return &m0_net_test_node_ping_ops;
        case M0_NET_TEST_TYPE_BULK:
                return &m0_net_test_node_bulk_ops;
        default:
                return NULL;
        }
}

static int node_cmd_get(struct m0_net_test_cmd_ctx *cmd_ctx,
                        struct m0_net_test_cmd *cmd,
                        m0_time_t deadline)
{
        int rc = m0_net_test_commands_recv(cmd_ctx, cmd, deadline);
        if (rc == 0)
                rc = m0_net_test_commands_recv_enqueue(cmd_ctx,
                                                       cmd->ntc_buf_index);
        if (rc == 0) {
                LOGD("node_cmd_get: rc = %d", rc);
                LOGD("node_cmd_get: cmd->ntc_type = %d", cmd->ntc_type);
                LOGD("node_cmd_get: cmd->ntc_init.ntci_msg_nr = %lu",
                     (unsigned long) cmd->ntc_init.ntci_msg_nr);
        }
        return rc;
}

static int node_cmd_wait(struct m0_net_test_node_ctx *ctx,
                         struct m0_net_test_cmd *cmd,
                         enum m0_net_test_cmd_type type)
{
        m0_time_t deadline;
        const int TIME_ONE_MS = M0_TIME_ONE_SECOND / 1000;
        int       rc;

        M0_PRE(ctx != NULL);
        do {
                deadline = m0_time_from_now(0, NODE_WAIT_CMD_GRANULARITY_MS *
                                               TIME_ONE_MS);
                rc = node_cmd_get(&ctx->ntnc_cmd, cmd, deadline);
                if (rc != 0 && rc != -ETIMEDOUT)
                        return rc;      
                if (rc == 0 && cmd->ntc_type != type)
                        m0_net_test_commands_received_free(cmd);
        } while (!(rc == 0 && cmd->ntc_type == type) && !ctx->ntnc_exit_flag);
        return 0;
}

static void node_thread(struct m0_net_test_node_ctx *ctx)
{
        struct m0_net_test_service      svc;
        struct m0_net_test_service_ops *svc_ops;
        enum m0_net_test_service_state  svc_state;
        struct m0_net_test_cmd         *cmd;
        struct m0_net_test_cmd         *reply;
        int                             rc;
        bool                            skip_cmd_get;

        M0_PRE(ctx != NULL);

        M0_ALLOC_PTR(cmd);
        M0_ALLOC_PTR(reply);
        if (cmd == NULL || reply == NULL) {
                rc = -ENOMEM;
                goto done;
        }

        /* wait for INIT command */
        ctx->ntnc_errno = node_cmd_wait(ctx, cmd, M0_NET_TEST_CMD_INIT);
        if (ctx->ntnc_exit_flag) {
                rc = 0;
                m0_net_test_commands_received_free(cmd);
                goto done;
        }
        if (ctx->ntnc_errno != 0) {
                rc = ctx->ntnc_errno;
                goto done;
        }
        /* we have configuration; initialize test service */
        svc_ops = service_ops_get(cmd);
        if (svc_ops == NULL) {
                rc = -ENODATA;
                m0_net_test_commands_received_free(cmd);
                goto done;
        }
        rc = m0_net_test_service_init(&svc, svc_ops);
        if (rc != 0) {
                m0_net_test_commands_received_free(cmd);
                goto done;
        }
        /* handle INIT command inside main loop */
        skip_cmd_get = true;
        /* test service is initialized. start main loop */
        do {
                /* get command */
                if (rc == 0 && !skip_cmd_get)
                        rc = node_cmd_get(&ctx->ntnc_cmd, cmd,
                                          m0_time_from_now(0, 25000000));
                                          // m0_time_now());
                else
                        skip_cmd_get = false;
                if (rc == 0)
                        LOGD("node_thread: cmd_get, "
                             "rc = %d, cmd.ntc_ep_index = %lu",
                             rc, cmd->ntc_ep_index);
                if (rc == 0 && cmd->ntc_ep_index >= 0) {
                        LOGD("node_thread: have command");
                        /* we have command. handle it */
                        rc = m0_net_test_service_cmd_handle(&svc, cmd, reply);
                        LOGD("node_thread: cmd handle: rc = %d", rc);
                        reply->ntc_ep_index = cmd->ntc_ep_index;
                        m0_net_test_commands_received_free(cmd);
                        /* send reply */
                        LOGD("node_thread: reply.ntc_ep_index = %lu",
                             reply->ntc_ep_index);
                        m0_net_test_commands_send_wait_all(&ctx->ntnc_cmd);
                        rc = m0_net_test_commands_send(&ctx->ntnc_cmd, reply);
                        LOGD("node_thread: send reply: rc = %d", rc);
                        M0_SET0(cmd);
                } else if (rc == -ETIMEDOUT) {
                        /* we haven't command. take a step. */
                        rc = m0_net_test_service_step(&svc);
                } else {
                        break;
                }
                svc_state = m0_net_test_service_state_get(&svc);
        } while (svc_state != M0_NET_TEST_SERVICE_FAILED &&
                 svc_state != M0_NET_TEST_SERVICE_FINISHED &&
                 !ctx->ntnc_exit_flag &&
                 rc == 0);

        /* finalize test service */
        m0_net_test_service_fini(&svc);

done:
        m0_free(cmd);
        m0_free(reply);
        LOGD("rc = %d", rc);
        ctx->ntnc_errno = rc;
        m0_semaphore_up(&ctx->ntnc_thread_finished_sem);
}

static int node_init_fini(struct m0_net_test_node_ctx *ctx,
                          struct m0_net_test_node_cfg *cfg)
{
        struct m0_net_test_slist ep_list;
        int                      rc;

        M0_PRE(ctx != NULL);
        if (cfg == NULL)
                goto fini;

        M0_SET0(ctx);

        rc = m0_net_test_slist_init(&ep_list, cfg->ntnc_addr_console, '`');
        if (rc != 0)
                goto failed;
        rc = m0_net_test_commands_init(&ctx->ntnc_cmd,
                                       cfg->ntnc_addr,
                                       cfg->ntnc_send_timeout,
                                       NULL,
                                       &ep_list);
        m0_net_test_slist_fini(&ep_list);
        if (rc != 0)
                goto failed;
        rc = m0_semaphore_init(&ctx->ntnc_thread_finished_sem, 0);
        if (rc != 0)
                goto commands_fini;

        return 0;
fini:
        rc = 0;
        m0_semaphore_fini(&ctx->ntnc_thread_finished_sem);
commands_fini:
        m0_net_test_commands_fini(&ctx->ntnc_cmd);
failed:
        return rc;
}

int m0_net_test_node_init(struct m0_net_test_node_ctx *ctx,
                          struct m0_net_test_node_cfg *cfg)
{
        return node_init_fini(ctx, cfg);
}

void m0_net_test_node_fini(struct m0_net_test_node_ctx *ctx)
{
        int rc = node_init_fini(ctx, NULL);
        M0_ASSERT(rc == 0);
}

int m0_net_test_node_start(struct m0_net_test_node_ctx *ctx)
{
        M0_PRE(ctx != NULL);

        ctx->ntnc_exit_flag = false;
        ctx->ntnc_errno     = 0;

        return M0_THREAD_INIT(&ctx->ntnc_thread, struct m0_net_test_node_ctx *,
                              NULL, &node_thread, ctx, "net_test_node");
}

void m0_net_test_node_stop(struct m0_net_test_node_ctx *ctx)
{
        int rc;

        M0_PRE(ctx != NULL);

        ctx->ntnc_exit_flag = true;
        m0_net_test_commands_send_wait_all(&ctx->ntnc_cmd);
        rc = m0_thread_join(&ctx->ntnc_thread);
        /*
         * In either case when rc != 0 there is an unmatched
         * m0_net_test_node_start() and m0_net_test_node_stop()
         * or deadlock. If non-zero rc is returned as result of this function,
         * then m0_net_test_node_stop() leaves m0_net_test_node_ctx in
         * inconsistent state (also possible resource leak).
         */
        M0_ASSERT(rc == 0);
        m0_thread_fini(&ctx->ntnc_thread);
}

static struct m0_net_test_node_ctx *m0_net_test_node_module_ctx = NULL;

int m0_net_test_node_module_initfini(struct m0_net_test_node_cfg *cfg)
{
        int rc = 0;

        if (cfg == NULL)
                goto fini;
        if (cfg->ntnc_addr == NULL ||
            cfg->ntnc_addr_console == NULL ||
            cfg->ntnc_send_timeout == 0) {
                rc = -EINVAL;
                goto fail;
        }

        M0_ALLOC_PTR(m0_net_test_node_module_ctx);
        if (m0_net_test_node_module_ctx == NULL) {
                rc = -ENOMEM;
                goto fail;
        }
        rc = m0_net_test_node_init(m0_net_test_node_module_ctx, cfg);
        if (rc != 0)
                goto free_ctx;
        rc = m0_net_test_node_start(m0_net_test_node_module_ctx);
        if (rc != 0)
                goto fini_node;

        goto success;
fini:
        m0_net_test_node_stop(m0_net_test_node_module_ctx);
fini_node:
        m0_net_test_node_fini(m0_net_test_node_module_ctx);
free_ctx:
        m0_free(m0_net_test_node_module_ctx);
fail:
success:
        return rc;
}
M0_EXPORTED(m0_net_test_node_module_initfini);

#undef NET_TEST_MODULE_NAME

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