spiel.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2014-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_SPIEL_SPIEL_H__
#define __MOTR_SPIEL_SPIEL_H__

#include "fid/fid.h"           /* m0_fid */
#include "conf/schema.h"       /* m0_conf_service_type */
#include "conf/confc.h"        /* m0_confc */
#include "conf/rconfc.h"       /* m0_rconfc */
#include "conf/pvers.h"        /* m0_conf_pver_info */
#include "reqh/reqh_service.h" /* enum m0_service_health */
#include "sns/cm/cm.h"         /* m0_cm_status */

struct m0_rpc_machine;
struct m0_pdclust_attr;
struct m0_reqh;

struct m0_spiel_repreb_status {
        /* SNS or DIX(rep/reb) service fid */
        struct m0_fid     srs_fid;
        /* State of current repair/rebalance, see @ref m0_sns_cm_status*/
        enum m0_cm_status srs_state;
        /* Progress of current repair/rebalance in percent */
        unsigned int      srs_progress;
};

struct m0_spiel_sns_status {
        /* SNS service fid */
        struct m0_fid         sss_fid;
        /* State of current repair/rebalance, see @ref m0_sns_cm_status*/
        enum m0_sns_cm_status sss_state;
        /* Progress of current repair/rebalance in percent */
        unsigned int          sss_progress;
 };

enum m0_repreb_type {
        M0_REPREB_TYPE_SNS,
        M0_REPREB_TYPE_DIX,
        M0_REPREB_TYPE_NR
};

struct m0_spiel {
        struct m0_spiel_core {
                struct m0_rpc_machine *spc_rmachine;
                struct m0_fid          spc_profile;
                struct m0_confc       *spc_confc;
        }                          spl_core;
        struct m0_rconfc           spl_rconfc;
        struct m0_spiel_wlock_ctx *spl_wlock_ctx;
};

int m0_spiel_init(struct m0_spiel *spiel, struct m0_reqh *reqh);

void m0_spiel_fini(struct m0_spiel *spiel);

/**********************************************************/
/*              Configuration management                  */
/**********************************************************/

struct m0_spiel_tx {
        struct m0_spiel      *spt_spiel;
        struct m0_conf_cache  spt_cache;
        struct m0_mutex       spt_lock;
        char                 *spt_buffer;
};

void m0_spiel_tx_open(struct m0_spiel    *spiel,
                      struct m0_spiel_tx *tx);

void m0_spiel_tx_close(struct m0_spiel_tx *tx);

int m0_spiel_tx_commit(struct m0_spiel_tx  *tx);

int m0_spiel_tx_commit_forced(struct m0_spiel_tx  *tx,
                              bool                 forced,
                              uint64_t             ver_forced,
                              uint32_t            *rquorum);

int m0_spiel_root_add(struct m0_spiel_tx   *tx,
                      const struct m0_fid  *rootfid,
                      const struct m0_fid  *mdpool,
                      const struct m0_fid  *imeta_pver,
                      uint32_t              mdredundancy,
                      const char          **params);

int m0_spiel_node_add(struct m0_spiel_tx  *tx,
                      const struct m0_fid *fid,
                      uint32_t             memsize,
                      uint32_t             nr_cpu,
                      uint64_t             last_state,
                      uint64_t             flags);

int m0_spiel_process_add(struct m0_spiel_tx  *tx,
                         const struct m0_fid *fid,
                         const struct m0_fid *parent,
                         struct m0_bitmap    *cores,
                         uint64_t             memlimit_as,
                         uint64_t             memlimit_rss,
                         uint64_t             memlimit_stack,
                         uint64_t             memlimit_memlock,
                         const char          *endpoint);

struct m0_spiel_service_info {
        enum m0_conf_service_type svi_type;
        const char              **svi_endpoints;
};

int m0_spiel_service_add(struct m0_spiel_tx                 *tx,
                         const struct m0_fid                *fid,
                         const struct m0_fid                *parent,
                         const struct m0_spiel_service_info *service_info);

int m0_spiel_device_add(struct m0_spiel_tx                        *tx,
                        const struct m0_fid                       *fid,
                        const struct m0_fid                       *parent,
                        const struct m0_fid                       *drive,
                        uint32_t                                   dev_idx,
                        enum m0_cfg_storage_device_interface_type  iface,
                        enum m0_cfg_storage_device_media_type      media,
                        uint32_t                                   bsize,
                        uint64_t                                   size,
                        uint64_t                                   last_state,
                        uint64_t                                   flags,
                        const char                                *filename);

int m0_spiel_site_add(struct m0_spiel_tx  *tx,
                      const struct m0_fid *fid);

int m0_spiel_rack_add(struct m0_spiel_tx  *tx,
                      const struct m0_fid *fid,
                      const struct m0_fid *parent);

int m0_spiel_enclosure_add(struct m0_spiel_tx  *tx,
                           const struct m0_fid *fid,
                           const struct m0_fid *parent,
                           const struct m0_fid *node);

int m0_spiel_controller_add(struct m0_spiel_tx  *tx,
                            const struct m0_fid *fid,
                            const struct m0_fid *parent);

int m0_spiel_drive_add(struct m0_spiel_tx  *tx,
                       const struct m0_fid *fid,
                       const struct m0_fid *parent);

int m0_spiel_pool_add(struct m0_spiel_tx  *tx,
                      const struct m0_fid *fid,
                      uint32_t             pver_policy);

int m0_spiel_pver_actual_add(struct m0_spiel_tx           *tx,
                             const struct m0_fid          *fid,
                             const struct m0_fid          *parent,
                             const struct m0_pdclust_attr *attrs,
                             uint32_t                     *tolerance,
                             uint32_t                      tolerance_len);
int m0_spiel_pver_formulaic_add(struct m0_spiel_tx  *tx,
                                const struct m0_fid *fid,
                                const struct m0_fid *parent,
                                uint32_t             index,
                                const struct m0_fid *base_pver,
                                uint32_t            *allowance,
                                uint32_t             allowance_len);

int m0_spiel_site_v_add(struct m0_spiel_tx  *tx,
                        const struct m0_fid *fid,
                        const struct m0_fid *parent,
                        const struct m0_fid *real);

int m0_spiel_rack_v_add(struct m0_spiel_tx  *tx,
                        const struct m0_fid *fid,
                        const struct m0_fid *parent,
                        const struct m0_fid *real);

int m0_spiel_enclosure_v_add(struct m0_spiel_tx  *tx,
                             const struct m0_fid *fid,
                             const struct m0_fid *parent,
                             const struct m0_fid *real);

int m0_spiel_controller_v_add(struct m0_spiel_tx  *tx,
                              const struct m0_fid *fid,
                              const struct m0_fid *parent,
                              const struct m0_fid *real);

int m0_spiel_drive_v_add(struct m0_spiel_tx  *tx,
                         const struct m0_fid *fid,
                         const struct m0_fid *parent,
                         const struct m0_fid *real);
int m0_spiel_pool_version_done(struct m0_spiel_tx  *tx,
                               const struct m0_fid *fid);

int m0_spiel_profile_add(struct m0_spiel_tx *tx, const struct m0_fid *fid);

int m0_spiel_profile_pool_add(struct m0_spiel_tx  *tx,
                              const struct m0_fid *profile,
                              const struct m0_fid *pool);

int m0_spiel_element_del(struct m0_spiel_tx *tx, const struct m0_fid *fid);

int m0_spiel_tx_validate(struct m0_spiel_tx *tx);

int m0_spiel_tx_to_str(struct m0_spiel_tx *tx,
                       uint64_t            ver_forced,
                       char              **str);

void m0_spiel_tx_str_free(char *str);

int m0_spiel_tx_dump(struct m0_spiel_tx *tx, uint64_t ver_forced,
                     const char *filename);
int m0_spiel_tx_dump_debug(struct m0_spiel_tx *tx, uint64_t ver_forced,
                           const char *filename);

/**********************************************************/
/*                 Command interface                      */
/**********************************************************/
int m0_spiel_rconfc_start(struct m0_spiel *spiel,
                          m0_rconfc_cb_t   expired_cb);

void m0_spiel_rconfc_stop(struct m0_spiel *spiel);

int m0_spiel_cmd_profile_set(struct m0_spiel *spiel, const char *profile_str);

int m0_spiel_service_init(struct m0_spiel *spl, const struct m0_fid *svc_fid);

int m0_spiel_service_start(struct m0_spiel *spl, const struct m0_fid *svc_fid);

int m0_spiel_service_stop(struct m0_spiel *spl, const struct m0_fid *svc_fid);

int m0_spiel_service_health(struct m0_spiel *spl, const struct m0_fid *svc_fid);

int m0_spiel_service_status(struct m0_spiel *spl, const struct m0_fid *svc_fid,
                           int *status);

int m0_spiel_service_quiesce(struct m0_spiel     *spl,
                             const struct m0_fid *svc_fid);

int m0_spiel_device_attach(struct m0_spiel *spl, const struct m0_fid *dev_fid);

int m0_spiel_device_attach_state(struct m0_spiel     *spl,
                                 const struct m0_fid *dev_fid,
                                 uint32_t            *ha_state);

int m0_spiel_device_detach(struct m0_spiel *spl, const struct m0_fid *dev_fid);

int m0_spiel_device_format(struct m0_spiel *spl, const struct m0_fid *dev_fid);

int m0_spiel_process_stop(struct m0_spiel *spl, const struct m0_fid *proc_fid);

int m0_spiel_process_reconfig(struct m0_spiel     *spl,
                              const struct m0_fid *proc_fid);

int m0_spiel_process_health(struct m0_spiel     *spl,
                            const struct m0_fid *proc_fid);

int m0_spiel_process_quiesce(struct m0_spiel     *spl,
                             const struct m0_fid *proc_fid);

struct m0_spiel_running_svc {
        /* Service FID */
        struct m0_fid  spls_fid;
        /* Service type name */
        char          *spls_name;
};

int m0_spiel_process_list_services(struct m0_spiel              *spl,
                                   const struct m0_fid          *proc_fid,
                                   struct m0_spiel_running_svc **services);

int m0_spiel_process_lib_load(struct m0_spiel     *spl,
                              const struct m0_fid *proc_fid,
                              const char          *libname);

int m0_spiel_sns_repair_start(struct m0_spiel     *spl,
                              const struct m0_fid *pool_fid);
int m0_spiel_dix_repair_start(struct m0_spiel     *spl,
                              const struct m0_fid *pool_fid);

int m0_spiel_pool_repair_start(struct m0_spiel     *spl,
                               const struct m0_fid *pool_fid);

int m0_spiel_sns_repair_continue(struct m0_spiel     *spl,
                                 const struct m0_fid *pool_fid);
int m0_spiel_dix_repair_continue(struct m0_spiel     *spl,
                                 const struct m0_fid *pool_fid);

int m0_spiel_pool_repair_continue(struct m0_spiel     *spl,
                                  const struct m0_fid *pool_fid);

int m0_spiel_sns_repair_quiesce(struct m0_spiel     *spl,
                                const struct m0_fid *pool_fid);
int m0_spiel_dix_repair_quiesce(struct m0_spiel     *spl,
                                const struct m0_fid *pool_fid);

int m0_spiel_pool_repair_quiesce(struct m0_spiel     *spl,
                                 const struct m0_fid *pool_fid);

int m0_spiel_sns_repair_abort(struct m0_spiel     *spl,
                              const struct m0_fid *pool_fid);
int m0_spiel_dix_repair_abort(struct m0_spiel     *spl,
                              const struct m0_fid *pool_fid);

int m0_spiel_pool_repair_abort(struct m0_spiel     *spl,
                               const struct m0_fid *pool_fid);

int m0_spiel_sns_repair_status(struct m0_spiel                *spl,
                               const struct m0_fid            *pool_fid,
                               struct m0_spiel_repreb_status **statuses);
int m0_spiel_dix_repair_status(struct m0_spiel                *spl,
                               const struct m0_fid            *pool_fid,
                               struct m0_spiel_repreb_status **statuses);

int m0_spiel_pool_repair_status(struct m0_spiel             *spl,
                                const struct m0_fid         *pool_fid,
                                struct m0_spiel_sns_status **statuses);

int m0_spiel_sns_rebalance_start(struct m0_spiel     *spl,
                                 const struct m0_fid *pool_fid);
int m0_spiel_dix_rebalance_start(struct m0_spiel     *spl,
                                 const struct m0_fid *pool_fid);

int m0_spiel_pool_rebalance_start(struct m0_spiel     *spl,
                                  const struct m0_fid *pool_fid);

int m0_spiel_node_direct_rebalance_start(struct m0_spiel     *spl,
                                         const struct m0_fid *node);
int m0_spiel_sns_rebalance_continue(struct m0_spiel     *spl,
                                    const struct m0_fid *pool_fid);
int m0_spiel_dix_rebalance_continue(struct m0_spiel     *spl,
                                    const struct m0_fid *pool_fid);

int m0_spiel_pool_rebalance_continue(struct m0_spiel     *spl,
                                     const struct m0_fid *pool_fid);

int m0_spiel_sns_rebalance_quiesce(struct m0_spiel     *spl,
                                   const struct m0_fid *pool_fid);
int m0_spiel_dix_rebalance_quiesce(struct m0_spiel     *spl,
                                   const struct m0_fid *pool_fid);

int m0_spiel_pool_rebalance_quiesce(struct m0_spiel     *spl,
                                    const struct m0_fid *pool_fid);

int m0_spiel_sns_rebalance_status(struct m0_spiel                *spl,
                                  const struct m0_fid            *pool_fid,
                                  struct m0_spiel_repreb_status **statuses);
int m0_spiel_dix_rebalance_status(struct m0_spiel                *spl,
                                  const struct m0_fid            *pool_fid,
                                  struct m0_spiel_repreb_status **statuses);

int m0_spiel_pool_rebalance_status(struct m0_spiel             *spl,
                                   const struct m0_fid         *pool_fid,
                                   struct m0_spiel_sns_status **statuses);

int m0_spiel_sns_rebalance_abort(struct m0_spiel     *spl,
                                 const struct m0_fid *pool_fid);
int m0_spiel_dix_rebalance_abort(struct m0_spiel     *spl,
                                 const struct m0_fid *pool_fid);

int m0_spiel_pool_rebalance_abort(struct m0_spiel     *spl,
                                  const struct m0_fid *pool_fid);

struct m0_spiel_bckey {
        struct m0_fid sbk_fid;      
        uint64_t      sbk_user_id;  
};

struct m0_spiel_bcrec {
        uint64_t  sbr_byte_count;   
        uint64_t  sbr_object_count; 
};

struct m0_proc_counter {
        int                     pc_rc;
        uint32_t                pc_cnt; 
        struct m0_fid           pc_proc_fid;
        struct m0_spiel_bckey **pc_bckey;
        struct m0_spiel_bcrec **pc_bcrec;
};

int m0_spiel_proc_counters_fetch(struct m0_spiel        *spl,
                                 struct m0_fid          *proc_fid,
                                 struct m0_proc_counter *count_stats);

struct m0_fs_stats {
        m0_bcount_t fs_free_seg;    
        m0_bcount_t fs_total_seg;   
        m0_bcount_t fs_free_disk;   
        m0_bcount_t fs_avail_disk;  
        m0_bcount_t fs_total_disk;  
        uint32_t    fs_svc_total;   
        uint32_t    fs_svc_replied; 
};

int m0_spiel_filesystem_stats_fetch(struct m0_spiel    *spl,
                                    struct m0_fs_stats *stats);

M0_INTERNAL int m0_spiel__fs_stats_fetch(struct m0_spiel_core *spc,
                                         struct m0_fs_stats   *stats);

int m0_spiel_confstr(struct m0_spiel *spl, char **out);

int m0_spiel_conf_pver_status(struct m0_spiel          *spl,
                              struct m0_fid            *fid,
                              struct m0_conf_pver_info *out_info);

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