rwlock_helper.c

Go to the documentation of this file.

/*
 * Copyright (c) 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 <unistd.h>

#include "lib/trace.h"
#include "lib/user_space/getopts.h"
#include "motr/init.h"
#include "module/instance.h"
#include "rm/rm.h"
#include "rm/rm_rwlock.h"
#include "rm/rm_service.h"
#include "rpc/rpclib.h"        /* m0_rpc_client_connect */
#include "rm/st/wlock_helper.h"

int main(int argc, char **argv)
{
        static struct m0           instance;
        struct m0_net_domain       domain;
        struct m0_net_buffer_pool  buffer_pool;
        struct m0_reqh             reqh;
        struct m0_reqh_service    *rm_service;
        struct m0_fid              process_fid = M0_FID_TINIT('r', 1, 5);
        struct m0_fid              rms_fid = M0_FID_TINIT('s', 3, 10);
        struct m0_rpc_machine      rpc_mach;
        const char                *rm_ep;
        const char                *c_ep;
        int                        delay;
        int                        rc;

        rc = m0_init(&instance);
        M0_SET0(&domain);
        if (rc != 0)
                return M0_ERR(rc);
        M0_SET0(&domain);
        rc = M0_GETOPTS("m0rwlock", argc, argv,
                            M0_STRINGARG('s',
                                         "server endpoint (RM)",
                                       LAMBDA(void, (const char *string) {
                                               rm_ep = string; })),
                            M0_STRINGARG('c',
                                         "client endpoint",
                                       LAMBDA(void, (const char *string) {
                                               c_ep = string; })),
                            M0_FORMATARG('d',
                                         "delay between write lock get and put",
                                         "%i", &delay));
        if (rc != 0)
                return M0_ERR(rc);
        printf("s %s, c %s, d %d\n", rm_ep, c_ep, delay);
        rc = m0_net_domain_init(&domain, m0_net_xprt_default_get());
        if (rc != 0)
                goto m0_fini;
        rc = m0_rpc_net_buffer_pool_setup(&domain, &buffer_pool, 2, 1);
        if (rc != 0)
                goto domain_fini;
        rc = M0_REQH_INIT(&reqh,
                          .rhia_dtm     = (void *)1,
                          .rhia_mdstore = (void *)1,
                          .rhia_fid     = &process_fid);
        if (rc != 0)
                goto buffer_cleanup;
        m0_reqh_start(&reqh);
        rc = m0_reqh_service_setup(&rm_service, &m0_rms_type, &reqh, NULL,
                                   &rms_fid);
        if (rc != 0)
                goto reqh_fini;
        rc = m0_rpc_machine_init(&rpc_mach, &domain, c_ep, &reqh, &buffer_pool,
                                 ~(uint32_t)0, 1 << 17, 2);
        if (rc != 0)
                goto services_terminate;
        rc = rm_write_lock_get(&rpc_mach, rm_ep);
        if (rc != 0)
                goto mach_fini;
        else
                m0_console_printf("Got write lock\n");
        sleep(delay);
        rm_write_lock_put();
        m0_console_printf("Released write lock\n");
mach_fini:
        m0_rpc_machine_fini(&rpc_mach);
services_terminate:
        m0_reqh_services_terminate(&reqh);
reqh_fini:
        m0_reqh_fini(&reqh);
buffer_cleanup:
        m0_rpc_net_buffer_pool_cleanup(&buffer_pool);
domain_fini:
        m0_net_domain_fini(&domain);
m0_fini:
        m0_fini();
        return M0_RC(rc);
}