confd.c

Go to the documentation of this file.

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


#define M0_TRACE_SUBSYSTEM M0_TRACE_SUBSYS_CONF
#include "lib/trace.h"

#include "conf/confd.h"
#include "conf/obj_ops.h"  /* m0_conf_obj_find */
#include "conf/onwire.h"   /* m0_confx, m0_confx_obj */
#include "conf/preload.h"  /* m0_confx_free */
#include "conf/dir.h"      /* m0_conf_dir_tl */
#include "lib/errno.h"     /* ENOMEM */
#include "lib/memory.h"    /* M0_ALLOC_PTR */
#include "lib/string.h"    /* m0_strdup */
#include "lib/fs.h"        /* m0_file_read */
#include "motr/magic.h"    /* M0_CONFD_MAGIC */
#include "motr/setup.h"    /* m0_reqh_context */


static int confd_allocate(struct m0_reqh_service **service,
                          const struct m0_reqh_service_type *stype);
static int confd_cache_preload(struct m0_conf_cache *cache, const char *str);

const struct m0_bob_type m0_confd_bob = {
        .bt_name         = "m0_confd",
        .bt_magix_offset = M0_MAGIX_OFFSET(struct m0_confd, d_magic),
        .bt_magix        = M0_CONFD_MAGIC
};

static const struct m0_reqh_service_type_ops confd_stype_ops = {
        .rsto_service_allocate = confd_allocate
};

struct m0_reqh_service_type m0_confd_stype = {
        .rst_name     = "M0_CST_CONFD",
        .rst_ops      = &confd_stype_ops,
        .rst_level    = M0_RS_LEVEL_NORMAL,
        .rst_typecode = M0_CST_CONFD,
};

M0_INTERNAL int m0_confd_register(void)
{
        return m0_reqh_service_type_register(&m0_confd_stype);
}

M0_INTERNAL void m0_confd_unregister(void)
{
        m0_reqh_service_type_unregister(&m0_confd_stype);
}

static int confd_start(struct m0_reqh_service *service);
static void confd_stop(struct m0_reqh_service *service);
static void confd_fini(struct m0_reqh_service *service);

static const struct m0_reqh_service_ops confd_ops = {
        .rso_start       = confd_start,
        .rso_start_async = m0_reqh_service_async_start_simple,
        .rso_stop        = confd_stop,
        .rso_fini        = confd_fini
};

static int confd_allocate(struct m0_reqh_service            **service,
                          const struct m0_reqh_service_type  *stype)
{
        struct m0_confd *confd;

        M0_ENTRY();
        M0_PRE(stype == &m0_confd_stype);

        M0_ALLOC_PTR(confd);
        if (confd == NULL)
                return M0_ERR(-ENOMEM);

        m0_bob_init(&m0_confd_bob, confd);
        *service = &confd->d_reqh;
        (*service)->rs_ops = &confd_ops;
        return M0_RC(0);
}

static void confd_fini(struct m0_reqh_service *service)
{
        struct m0_confd *confd = bob_of(service, struct m0_confd, d_reqh,
                                        &m0_confd_bob);
        M0_ENTRY();

        m0_bob_fini(&m0_confd_bob, confd);
        m0_free(confd);

        M0_LEAVE();
}

M0_INTERNAL int m0_confd_cache_create(struct m0_conf_cache **out,
                                      struct m0_mutex       *cache_lock,
                                      const char            *confstr)
{
        int rc;

        M0_ENTRY();
        M0_PRE(confstr != NULL);

        M0_ALLOC_PTR(*out);
        if (*out == NULL)
                return M0_ERR(-ENOMEM);
        m0_conf_cache_init(*out, cache_lock);
        m0_conf_cache_lock(*out);
        rc = confd_cache_preload(*out, confstr);
        m0_conf_cache_unlock(*out);
        if (rc == 0)
                return M0_RC(0);
        m0_conf_cache_fini(*out);
        m0_free0(out);
        return M0_ERR(rc);
}

M0_INTERNAL void m0_confd_cache_destroy(struct m0_conf_cache *cache)
{
        M0_ENTRY();
        m0_conf_cache_fini(cache);
        m0_free(cache);
        M0_LEAVE();
}

static int confd_start(struct m0_reqh_service *service)
{
        struct m0_confd *confd = bob_of(service, struct m0_confd, d_reqh,
                                        &m0_confd_bob);
        char            *path = NULL;
        char            *confstr = NULL;
        int              rc;

        M0_ENTRY();
        m0_mutex_init(&confd->d_cache_lock);
        rc = m0_confd_service_to_filename(service, &path) ?:
             m0_file_read(path, &confstr) ?:
             m0_confd_cache_create(&confd->d_cache, &confd->d_cache_lock,
                                   confstr);
        m0_free(confstr);
        m0_free(path);
        if (rc != 0) {
                m0_mutex_fini(&confd->d_cache_lock);
                return M0_ERR(rc);
        }
        return M0_RC(0);
}

static void confd_stop(struct m0_reqh_service *service)
{
        struct m0_confd *confd = bob_of(service, struct m0_confd, d_reqh,
                                        &m0_confd_bob);
        M0_ENTRY();
        M0_PRE(confd->d_cache != NULL);
        m0_confd_cache_destroy(confd->d_cache);
        m0_mutex_fini(&confd->d_cache_lock);
        M0_LEAVE();
}

static int confd_cache_preload(struct m0_conf_cache *cache, const char *str)
{
        struct m0_confx    *enc;
        int                 i;
        int                 rc;
        struct m0_conf_obj *obj;

        M0_ENTRY();
        M0_PRE(m0_mutex_is_locked(cache->ca_lock));

        rc = m0_confstr_parse(str, &enc);
        if (rc != 0)
                return M0_ERR(rc);

        for (i = 0; i < enc->cx_nr && rc == 0; ++i) {
                struct m0_conf_obj        *obj;
                const struct m0_confx_obj *xobj = M0_CONFX_AT(enc, i);

                rc = m0_conf_obj_find(cache, m0_conf_objx_fid(xobj), &obj) ?:
                        m0_conf_obj_fill(obj, xobj);
        }

        /* Check for orphan configuration object. */
        m0_tl_for(m0_conf_cache, &cache->ca_registry, obj) {
                M0_ASSERT_INFO(((m0_conf_obj_type(obj)== &M0_CONF_ROOT_TYPE) ||
                                obj->co_parent != NULL ||
                                m0_tlink_is_in(&m0_conf_dir_tl, obj)),
                               FID_F" is not part of configuration tree.",
                               FID_P(&obj->co_id));
        } m0_tlist_endfor;

        /*
         * Now having cache updated, reset version number to M0_CONF_VER_UNKNOWN
         * to let confd update it properly somewhat later when processing next
         * configuration read request. See confx_populate().
         */
        cache->ca_ver = M0_CONF_VER_UNKNOWN;
        m0_confx_free(enc);
        return M0_RC(rc);
}

static bool nil(const char *s)
{
        return s == NULL || *s == '\0';
}

M0_INTERNAL int m0_confd_service_to_filename(struct m0_reqh_service *service,
                                             char                  **dbpath)
{
        M0_ENTRY();

        *dbpath = NULL;
        if (m0_buf_is_set(&service->rs_ss_param))
                *dbpath = m0_buf_strdup(&service->rs_ss_param);
        if (nil(*dbpath)) {
                m0_free(*dbpath);
                *dbpath = m0_strdup((char*)service->rs_reqh_ctx->rc_confdb);
        }

        if (*dbpath == NULL)
                return M0_ERR(-ENOMEM);
        if (**dbpath == '\0')
                return M0_ERR(-EPROTO);
        return M0_RC(0);
}

#undef M0_TRACE_SUBSYSTEM