balloc.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-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_BALLOC_BALLOC_H__
#define __MOTR_BALLOC_BALLOC_H__

#include "lib/ext.h"
#include "lib/types.h"
#include "lib/list.h"
#include "lib/mutex.h"
#include "be/btree.h"
#include "be/btree_xc.h"
#include "format/format.h"
#include "stob/ad.h"
#include "stob/ad_xc.h"

struct m0_balloc_group_desc {
        struct m0_format_header bgd_header;
        m0_bindex_t             bgd_groupno;
        m0_bcount_t             bgd_freeblocks;
        m0_bcount_t             bgd_fragments;
        m0_bcount_t             bgd_maxchunk;
#ifdef __SPARE_SPACE__

        m0_bcount_t             bgd_spare_frags;
        m0_bcount_t             bgd_spare_freeblocks;
        m0_bcount_t             bgd_sparestart;
        m0_bcount_t             bgd_spare_maxchunk;
#endif
        struct m0_format_footer bgd_footer;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum m0_balloc_group_desc_format_version {
        M0_BALLOC_GROUP_DESC_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_BALLOC_GROUP_DESC_FORMAT_VERSION */
        /*M0_BALLOC_GROUP_DESC_FORMAT_VERSION_2,*/
        /*M0_BALLOC_GROUP_DESC_FORMAT_VERSION_3,*/

        M0_BALLOC_GROUP_DESC_FORMAT_VERSION = M0_BALLOC_GROUP_DESC_FORMAT_VERSION_1
};

enum m0_balloc_allocation_flag {
        M0_BALLOC_HINT_MERGE              = 1 << 0,

        M0_BALLOC_HINT_RESERVED           = 1 << 1,

        M0_BALLOC_HINT_METADATA           = 1 << 2,

        M0_BALLOC_HINT_FIRST              = 1 << 3,

        M0_BALLOC_HINT_BEST               = 1 << 4,

        M0_BALLOC_HINT_DATA               = 1 << 5,

        M0_BALLOC_HINT_NOPREALLOC         = 1 << 6,

        M0_BALLOC_HINT_GROUP_ALLOC        = 1 << 7,

        M0_BALLOC_HINT_GOAL_ONLY          = 1 << 8,

        M0_BALLOC_HINT_TRY_GOAL           = 1 << 9,

        M0_BALLOC_DELALLOC_RESERVED       = 1 << 10,

        M0_BALLOC_STREAM_ALLOC            = 1 << 11,

        M0_BALLOC_SPARE_ZONE              = 1 << 12,

        M0_BALLOC_NORMAL_ZONE             = 1 << 13,
};

struct m0_balloc_zone_param {
        enum m0_balloc_allocation_flag  bzp_type;
        struct m0_ext                   bzp_range;
        m0_bcount_t                     bzp_freeblocks;
        m0_bcount_t                     bzp_fragments;
        m0_bcount_t                     bzp_maxchunk;
        struct m0_list                  bzp_extents;
};

struct m0_lext {
        bool                le_is_alloc;
        struct m0_list_link le_link;
        struct m0_ext       le_ext;
};

struct m0_balloc_group_info {
        uint64_t                     bgi_state;
        m0_bindex_t                  bgi_groupno;
        struct m0_balloc_zone_param  bgi_normal;
        struct m0_balloc_zone_param  bgi_spare;
        struct m0_lext              *bgi_extents;
        struct m0_be_mutex           bgi_mutex;
};

enum m0_balloc_group_info_state {
        M0_BALLOC_GROUP_INFO_INIT = 1 << 0,
        M0_BALLOC_GROUP_INFO_DIRTY = 1 << 1,
};

struct m0_balloc_super_block {
        uint64_t        bsb_magic;
        uint64_t        bsb_state;
        uint64_t        bsb_version;
        uint8_t         bsb_uuid[128];

        m0_bcount_t     bsb_totalsize;        
        m0_bcount_t     bsb_freeblocks;       
#ifdef __SPARE_SPACE__
        m0_bcount_t     bsb_freespare;        
        m0_bcount_t     bsb_sparesize;        
#endif
        m0_bcount_t     bsb_blocksize;        
        m0_bcount_t     bsb_groupsize;        
        uint32_t        bsb_bsbits;           
        uint32_t        bsb_gsbits;           
        m0_bcount_t     bsb_groupcount;       
        m0_bcount_t     bsb_prealloc_count;   
        uint64_t        bsb_format_time;
        uint64_t        bsb_write_time;
        uint64_t        bsb_mnt_time;
        uint64_t        bsb_last_check_time;

        uint64_t        bsb_mnt_count;
        uint64_t        bsb_max_mnt_count;

        m0_bcount_t     bsb_stripe_size;      
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum m0_balloc_super_block_state {
        M0_BALLOC_SB_DIRTY =  1 << 0,
};

enum m0_balloc_super_block_version {
        M0_BALLOC_SB_VERSION = 1ULL,
};

enum {
        M0_BALLOC_BUDDY_LOOKUP_MAX = 10,
};

struct m0_balloc {
        struct m0_format_header      cb_header;

        uint64_t                     cb_container_id;
        struct m0_balloc_super_block cb_sb;

        m0_bindex_t                  cb_last;

        struct m0_ad_balloc          cb_ballroom;
        struct m0_format_footer      cb_footer;

        /*
         * m0_be_btree has it's own volatile-only fields, so it can't be placed
         * before the m0_format_footer, where only persistent fields allowed
         */
        struct m0_be_btree           cb_db_group_extents;
        struct m0_be_btree           cb_db_group_desc;

        /*
         * volatile-only fields
         */

        struct m0_balloc_group_info *cb_group_info;
        struct m0_be_mutex           cb_sb_mutex;
        struct m0_be_seg            *cb_be_seg;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum m0_balloc_format_version {
        M0_BALLOC_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_BALLOC_FORMAT_VERSION */
        /*M0_BALLOC_FORMAT_VERSION_2,*/
        /*M0_BALLOC_FORMAT_VERSION_3,*/

        M0_BALLOC_FORMAT_VERSION = M0_BALLOC_FORMAT_VERSION_1
};

static inline struct m0_balloc *b2m0(const struct m0_ad_balloc *ballroom)
{
        return container_of(ballroom, struct m0_balloc, cb_ballroom);
}

struct m0_balloc_format_req {
        m0_bcount_t     bfr_totalsize;
        m0_bcount_t     bfr_blocksize;
        m0_bcount_t     bfr_groupsize;
        m0_bcount_t     bfr_spare_reserved_blocks;
};

struct m0_balloc_free_extent {
        m0_bindex_t bfe_logical;       /*< logical offset within the object */
        m0_bindex_t bfe_groupno;       /*< goal group # */
        m0_bindex_t bfe_start;         /*< relative start offset */
        m0_bindex_t bfe_end;           /*< relative start offset */
};

struct m0_balloc_allocate_req {
        m0_bindex_t     bar_logical; /*< [in]logical offset within the object */
        m0_bcount_t     bar_len;     /*< [in]count of blocks, */
        m0_bindex_t     bar_goal;    /*< [in]prefered physical block number */
        uint64_t        bar_flags;   /*< [in]allocation flags from
                                      * m0_balloc_allocation_flag */
        struct m0_ext   bar_result;  /*< [out]physical offset, result */

        void           *bar_prealloc;/*< [in][out]User opaque prealloc result */
};

struct m0_balloc_free_req {
        m0_bindex_t     bfr_logical;  /*< logical offset within the object */
        m0_bcount_t     bfr_len;      /*< count of blocks */
        m0_bindex_t     bfr_physical; /*< physical block number */
        uint32_t        bfr_flags;    /*< free flags */
};

struct m0_balloc_discard_req {
        void           *bdr_prealloc; /*< User opaque prealloc result */
};

/*
 * BALLOC_DEF_BLOCKS_PER_GROUP * (1 << BALLOC_DEF_BLOCK_SHIFT) = 128 MB -->
 * which equals group size in ext4
 */
enum {
        BALLOC_DEF_CONTAINER_SIZE       = 4096ULL * 32 * 1024 * 1000,
        BALLOC_DEF_BLOCK_SHIFT          = 12,// 4K Blocks
        BALLOC_DEF_GROUPS_NR            = 64,
        BALLOC_DEF_BLOCKS_PER_GROUP     = 32768,
};

M0_INTERNAL void m0_balloc_init(struct m0_balloc *cb);

M0_INTERNAL int m0_balloc_create(uint64_t              cid,
                                 struct m0_be_seg     *seg,
                                 struct m0_sm_group   *grp,
                                 struct m0_balloc    **out,
                                 const struct m0_fid  *fid);

M0_INTERNAL void m0_balloc_group_desc_init(struct m0_balloc_group_desc *desc);

/* Interfaces for UT */
M0_INTERNAL void m0_balloc_debug_dump_sb(const char *tag,
                                         struct m0_balloc_super_block *sb);
M0_INTERNAL void m0_balloc_debug_dump_group_extent(const char *tag,
                                                   struct m0_balloc_group_info
                                                   *grp);

M0_INTERNAL int m0_balloc_release_extents(struct m0_balloc_group_info *grp);
M0_INTERNAL int m0_balloc_load_extents(struct m0_balloc *cb,
                                       struct m0_balloc_group_info *grp);
M0_INTERNAL struct m0_balloc_group_info *m0_balloc_gn2info(struct m0_balloc *cb,
                                                           m0_bindex_t groupno);
M0_INTERNAL void m0_balloc_debug_dump_group(const char *tag,
                                            struct m0_balloc_group_info *grp);
M0_INTERNAL void m0_balloc_lock_group(struct m0_balloc_group_info *grp);
M0_INTERNAL int m0_balloc_trylock_group(struct m0_balloc_group_info *grp);
M0_INTERNAL void m0_balloc_unlock_group(struct m0_balloc_group_info *grp);

#endif /*__MOTR_BALLOC_BALLOC_H__*/

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