cob.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2011-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_COB_COB_H__
#define __MOTR_COB_COB_H__

#include "file/file.h"
#include "lib/atomic.h"
#include "lib/rwlock.h"
#include "lib/refs.h"
#include "lib/bitstring.h"
#include "lib/bitstring_xc.h"
#include "fid/fid.h"
#include "mdservice/md_fid.h"
#include "be/btree.h"
#include "be/btree_xc.h"

/* import */
struct m0_be_tx;
struct m0_be_btree;
struct m0_be_domain;
struct m0_stob;

struct m0_cob;
struct m0_fid;
struct m0_cob_id;
struct m0_cob_domain;
struct m0_cob_domain_id;

/*
 * This is used to separate the range of COB IDs for IOS-es and MDS-es, which is
 * needed to do correct restart and match cob domains by id for each service
 * which uses its own cob-domain.
 */
enum {
        M0_MDS_COB_ID_START = 0,
        M0_IOS_COB_ID_START = 1000,
};

struct m0_cob_domain_id {
        uint64_t id;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_domain {
        struct m0_format_header cd_header;
        struct m0_cob_domain_id cd_id;
        struct m0_format_footer cd_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      cd_object_index;
        struct m0_be_btree      cd_namespace;
        struct m0_be_btree      cd_fileattr_basic;
        struct m0_be_btree      cd_fileattr_omg;
        struct m0_be_btree      cd_fileattr_ea;
        struct m0_be_btree      cd_bytecount;
        struct m0_be_rwlock     cd_lock;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum m0_cob_domain_format_version {
        M0_COB_DOMAIN_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_COB_DOMAIN_FORMAT_VERSION */
        /*M0_COB_DOMAIN_FORMAT_VERSION_2,*/
        /*M0_COB_DOMAIN_FORMAT_VERSION_3,*/

        M0_COB_DOMAIN_FORMAT_VERSION = M0_COB_DOMAIN_FORMAT_VERSION_1
};

int m0_cob_domain_init(struct m0_cob_domain *dom,
                       struct m0_be_seg     *seg);
void m0_cob_domain_fini(struct m0_cob_domain *dom);

int m0_cob_domain_create(struct m0_cob_domain          **dom,
                         struct m0_sm_group             *grp,
                         const struct m0_cob_domain_id  *cdid,
                         struct m0_be_domain            *bedom,
                         struct m0_be_seg               *seg);

int m0_cob_domain_destroy(struct m0_cob_domain *dom,
                          struct m0_sm_group   *grp,
                          struct m0_be_domain  *bedom);

M0_INTERNAL int m0_cob_domain_credit_add(struct m0_cob_domain          *dom,
                                         struct m0_be_domain           *bedom,
                                         struct m0_be_seg              *seg,
                                         const struct m0_cob_domain_id *cdid,
                                         struct m0_be_tx_credit        *cred);

M0_INTERNAL
int m0_cob_domain_create_prepared(struct m0_cob_domain          **dom,
                                  struct m0_sm_group             *grp,
                                  const struct m0_cob_domain_id  *cdid,
                                  struct m0_be_domain            *bedom,
                                  struct m0_be_seg               *seg,
                                  struct m0_be_tx                *tx);

M0_INTERNAL int m0_cob_domain_mkfs(struct m0_cob_domain *dom,
                                   const struct m0_fid *rootfid,
                                   struct m0_be_tx *tx);

enum m0_cob_valid_flags {
        M0_COB_ATIME   = 1 << 0,
        M0_COB_MTIME   = 1 << 1,
        M0_COB_CTIME   = 1 << 2,
        M0_COB_SIZE    = 1 << 3,
        M0_COB_MODE    = 1 << 4,
        M0_COB_UID     = 1 << 5,
        M0_COB_GID     = 1 << 6,
        M0_COB_BLOCKS  = 1 << 7,
        M0_COB_TYPE    = 1 << 8,
        M0_COB_FLAGS   = 1 << 9,
        M0_COB_NLINK   = 1 << 10,
        M0_COB_RDEV    = 1 << 11,
        M0_COB_BLKSIZE = 1 << 12,
        M0_COB_LID     = 1 << 13,
        M0_COB_PVER    = 1 << 14
};

#define M0_COB_ALL (M0_COB_ATIME | M0_COB_MTIME | M0_COB_CTIME |               \
                    M0_COB_SIZE | M0_COB_MODE | M0_COB_UID | M0_COB_GID |      \
                    M0_COB_BLOCKS | M0_COB_TYPE | M0_COB_FLAGS | M0_COB_NLINK |\
                    M0_COB_RDEV | M0_COB_BLKSIZE | M0_COB_LID | M0_COB_PVER)

struct m0_cob_attr {
        struct m0_fid ca_pfid;    
        struct m0_fid ca_tfid;    
        struct m0_fid ca_pver;    
        uint32_t      ca_valid;   
        uint32_t      ca_mode;    
        uint32_t      ca_uid;     
        uint32_t      ca_gid;     
        uint64_t      ca_atime;   
        uint64_t      ca_mtime;   
        uint64_t      ca_ctime;   
        uint64_t      ca_rdev;    
        uint32_t      ca_nlink;   
        uint64_t      ca_size;    
        uint64_t      ca_blksize; 
        uint64_t      ca_blocks;  
        uint64_t      ca_version; 
        uint64_t      ca_lid;     
        struct m0_buf ca_name;    
        struct m0_buf ca_link;    
        struct m0_buf ca_eakey;   
        struct m0_buf ca_eaval;   
};

struct m0_cob_nskey {
        struct m0_fid       cnk_pfid;
        struct m0_bitstring cnk_name;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

M0_INTERNAL size_t m0_cob_nskey_size(const struct m0_cob_nskey *nskey);

M0_INTERNAL int m0_cob_nskey_cmp(const struct m0_cob_nskey *k0,
                                 const struct m0_cob_nskey *k1);

M0_INTERNAL void m0_cob_init(struct m0_cob_domain *dom, struct m0_cob *cob);

struct m0_cob_nsrec {
        struct m0_format_header cnr_header;
        struct m0_fid           cnr_fid;     
        uint32_t                cnr_linkno;  
        uint32_t                cnr_nlink;     
        uint32_t                cnr_cntr;      
        char                    cnr_pad[4];
        uint64_t                cnr_omgid;     
        uint64_t                cnr_size;      
        uint64_t                cnr_bytecount; 
        uint64_t                cnr_blksize;   
        uint64_t                cnr_blocks;    
        uint64_t                cnr_atime;     
        uint64_t                cnr_mtime;     
        uint64_t                cnr_ctime;     
        uint64_t                cnr_lid;       
        struct m0_fid           cnr_pver;      
        struct m0_format_footer cnr_footer;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum m0_cob_nsrec_format_version {
        M0_COB_NSREC_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_COB_NSREC_FORMAT_VERSION */
        /*M0_COB_NSREC_FORMAT_VERSION_2,*/
        /*M0_COB_NSREC_FORMAT_VERSION_3,*/

        M0_COB_NSREC_FORMAT_VERSION = M0_COB_NSREC_FORMAT_VERSION_1
};

M0_INTERNAL void m0_cob_nsrec_init(struct m0_cob_nsrec *nsrec);

struct m0_cob_oikey {
        struct m0_fid     cok_fid;
        uint32_t          cok_linkno;  
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_fabkey {
        struct m0_fid     cfb_fid;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_fabrec {
        struct m0_fid     cfb_pver;     
        uint64_t          cfb_version;  
        uint64_t          cfb_layoutid; 
        uint32_t          cfb_linklen;  
        char              cfb_link[0];  
        /* add ACL, Besides ACL, no further metadata is needed for stat(2). */
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_omgkey {
        uint64_t          cok_omgid;   
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_omgrec {
        uint32_t          cor_uid;     
        uint32_t          cor_mode;    
        uint32_t          cor_gid;     
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_eakey {
        struct m0_fid       cek_fid;   
        struct m0_bitstring cek_name;  
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_earec {
        uint32_t          cer_size;    
        char              cer_body[0]; 
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_bckey {
        struct m0_fid     cbk_pfid;    
        uint64_t          cbk_user_id; 
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob_bcrec {
        uint64_t          cbr_bytecount;  
        uint64_t          cbr_cob_objects;  
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_cob {
        struct m0_cob_domain  *co_dom;
        struct m0_stob        *co_stob;     
        struct m0_ref          co_ref;      
        uint64_t               co_flags;    
        struct m0_file         co_file;     
        struct m0_cob_nskey   *co_nskey;    
        struct m0_cob_oikey    co_oikey;    
        struct m0_cob_nsrec    co_nsrec;    
        struct m0_cob_fabrec  *co_fabrec;   
        struct m0_cob_omgrec   co_omgrec;   
};

struct m0_dirent {
        uint32_t             d_namelen;
        uint32_t             d_reclen;
        char                 d_name[0];
};

struct m0_rdpg {
        struct m0_bitstring *r_pos;
        struct m0_buf        r_buf;
        struct m0_bitstring *r_end;
};

struct m0_cob_iterator {
        struct m0_cob            *ci_cob;      
        struct m0_be_btree_cursor ci_cursor;   
        struct m0_cob_nskey      *ci_key;      
};

struct m0_cob_ea_iterator {
        struct m0_cob            *ci_cob;      
        struct m0_be_btree_cursor ci_cursor;   
        struct m0_cob_eakey      *ci_key;      
        struct m0_cob_earec      *ci_rec;      
};

struct m0_cob_bc_iterator {
        struct m0_cob            *ci_cob;      
        struct m0_be_btree_cursor ci_cursor;   
        struct m0_cob_bckey      *ci_key;      
        struct m0_cob_bcrec      *ci_rec;      
};

enum m0_cob_flags {
        M0_CA_NSKEY      = (1 << 0),  
        M0_CA_NSKEY_FREE = (1 << 1),  
        M0_CA_NSREC      = (1 << 2),  
        M0_CA_FABREC     = (1 << 3),  
        M0_CA_OMGREC     = (1 << 4),  
        M0_CA_LAYOUT     = (1 << 5),  
        M0_CA_BCREC      = (1 << 6),  
};

M0_INTERNAL int m0_cob_lookup(struct m0_cob_domain *dom,
                              struct m0_cob_nskey *nskey,
                              uint64_t flags,
                              struct m0_cob **out);

M0_INTERNAL int m0_cob_locate(struct m0_cob_domain *dom,
                              struct m0_cob_oikey *oikey,
                              uint64_t flags,
                              struct m0_cob **out);

M0_INTERNAL int m0_cob_create(struct m0_cob *cob,
                              struct m0_cob_nskey *nskey,
                              struct m0_cob_nsrec *nsrec,
                              struct m0_cob_fabrec *fabrec,
                              struct m0_cob_omgrec *omgrec,
                              struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_delete(struct m0_cob *cob, struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_delete_put(struct m0_cob *cob, struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_update(struct m0_cob *cob,
                              struct m0_cob_nsrec *nsrec,
                              struct m0_cob_fabrec *fabrec,
                              struct m0_cob_omgrec *omgrec,
                              struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_name_add(struct m0_cob *cob,
                                struct m0_cob_nskey *nskey,
                                struct m0_cob_nsrec *nsrec,
                                struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_name_del(struct m0_cob *cob,
                                struct m0_cob_nskey *nskey,
                                struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_name_update(struct m0_cob *cob,
                                   struct m0_cob_nskey *srckey,
                                   struct m0_cob_nskey *tgtkey,
                                   struct m0_be_tx *tx);

M0_INTERNAL size_t m0_cob_max_earec_size(void);

M0_INTERNAL int m0_cob_eakey_make(struct m0_cob_eakey **keyh,
                                  const struct m0_fid *fid,
                                  const char *name,
                                  size_t namelen);

M0_INTERNAL int m0_cob_ea_get(struct m0_cob *cob,
                              struct m0_cob_eakey *eakey,
                              struct m0_cob_earec *out,
                              struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_ea_set(struct m0_cob *cob,
                              struct m0_cob_eakey *eakey,
                              struct m0_cob_earec *earec,
                              struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_ea_del(struct m0_cob *cob,
                              struct m0_cob_eakey *eakey,
                              struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_ea_iterator_init(struct m0_cob *cob,
                                        struct m0_cob_ea_iterator *it,
                                        struct m0_bitstring *name);

M0_INTERNAL int m0_cob_ea_iterator_next(struct m0_cob_ea_iterator *it);

M0_INTERNAL int m0_cob_ea_iterator_get(struct m0_cob_ea_iterator *it);

M0_INTERNAL void m0_cob_ea_iterator_fini(struct m0_cob_ea_iterator *it);

M0_INTERNAL int m0_cob_bc_lookup(struct m0_cob *cob,
                                 struct m0_cob_bckey *bc_key,
                                 struct m0_cob_bcrec *bc_rec);

M0_INTERNAL int m0_cob_bc_insert(struct m0_cob *cob,
                                 struct m0_cob_bckey *bc_key,
                                 struct m0_cob_bcrec *bc_val,
                                 struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_bc_update(struct m0_cob *cob,
                                 struct m0_cob_bckey *bc_key,
                                 struct m0_cob_bcrec *bc_val,
                                 struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_bc_iterator_init(struct m0_cob             *cob,
                                        struct m0_cob_bc_iterator *it,
                                        const struct m0_fid       *pver_fid,
                                        uint64_t                   user_id);

M0_INTERNAL int m0_cob_bc_iterator_next(struct m0_cob_bc_iterator *it);

M0_INTERNAL int m0_cob_bc_iterator_get(struct m0_cob_bc_iterator *it);

M0_INTERNAL int m0_cob_bc_entries_dump(struct m0_cob_domain *cdom,
                                       struct m0_buf       **out_keys,
                                       struct m0_buf       **out_recs,
                                       uint32_t             *out_count);

M0_INTERNAL void m0_cob_bc_iterator_fini(struct m0_cob_bc_iterator *it);

M0_INTERNAL int m0_cob_iterator_init(struct m0_cob *cob,
                                     struct m0_cob_iterator *it,
                                     struct m0_bitstring *name);

M0_INTERNAL int m0_cob_iterator_next(struct m0_cob_iterator *it);

M0_INTERNAL int m0_cob_iterator_get(struct m0_cob_iterator *it);

M0_INTERNAL void m0_cob_iterator_fini(struct m0_cob_iterator *it);

M0_INTERNAL int m0_cob_alloc(struct m0_cob_domain *dom, struct m0_cob **out);

M0_INTERNAL void m0_cob_get(struct m0_cob *obj);

M0_INTERNAL void m0_cob_put(struct m0_cob *obj);

M0_INTERNAL void m0_cob_oikey_make(struct m0_cob_oikey *oikey,
                                   const struct m0_fid *fid, int linkno);

M0_INTERNAL int m0_cob_nskey_make(struct m0_cob_nskey **keyh,
                                  const struct m0_fid *pfid,
                                  const char *name, size_t namelen);

M0_INTERNAL int m0_cob_fabrec_make(struct m0_cob_fabrec **rech,
                                   const char *link, size_t linklen);

M0_INTERNAL int m0_cob_setattr(struct m0_cob *cob,
                               struct m0_cob_attr *attr,
                               struct m0_be_tx *tx);

M0_INTERNAL int m0_cob_size_update(struct m0_cob *cob, uint64_t size,
                                   struct m0_be_tx *tx);
/* XXX move tx to the end of the declaration */
M0_INTERNAL int m0_cob_alloc_omgid(struct m0_cob_domain *dom,uint64_t * omgid);

enum m0_cob_op {
        M0_COB_OP_DOMAIN_MKFS,
        M0_COB_OP_LOOKUP,
        M0_COB_OP_LOCATE,
        M0_COB_OP_CREATE,
        M0_COB_OP_DELETE,
        M0_COB_OP_TRUNCATE,
        M0_COB_OP_DELETE_PUT,
        M0_COB_OP_UPDATE,
        M0_COB_OP_FEA_SET,
        M0_COB_OP_FEA_DEL,
        M0_COB_OP_NAME_ADD,
        M0_COB_OP_NAME_DEL,
        M0_COB_OP_NAME_UPDATE,
        M0_COB_OP_BYTECOUNT_SET,
        M0_COB_OP_BYTECOUNT_DEL,
        M0_COB_OP_BYTECOUNT_UPDATE,
} M0_XCA_ENUM;

M0_INTERNAL void m0_cob_tx_credit(struct m0_cob_domain *dom,
                                  enum m0_cob_op optype,
                                  struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_cob_ea_get_credit(struct m0_cob *cob,
                                      struct m0_cob_eakey *eakey,
                                      struct m0_cob_earec *out,
                                      struct m0_be_tx_credit *accum);
M0_INTERNAL void m0_cob_ea_set_credit(struct m0_cob *cob,
                                      struct m0_cob_eakey *eakey,
                                      struct m0_cob_earec *earec,
                                      struct m0_be_tx_credit *accum);
M0_INTERNAL void m0_cob_ea_del_credit(struct m0_cob *cob,
                                      struct m0_cob_eakey *eakey,
                                      struct m0_be_tx_credit *accum);
M0_INTERNAL void m0_cob_ea_iterator_init_credit(struct m0_cob *cob,
                                                struct m0_cob_ea_iterator *it,
                                                struct m0_bitstring *name,
                                                struct m0_be_tx_credit *accum);

M0_INTERNAL const struct m0_fid *m0_cob_fid(const struct m0_cob *cob);

M0_INTERNAL int m0_cob_mod_init(void);

M0_INTERNAL void m0_cob_mod_fini(void);

extern const struct m0_fid_type m0_cob_fid_type;
enum m0_cob_type {
        M0_COB_IO,
        M0_COB_MD,
};

extern const struct m0_fid_type m0_cob_fid_type;

#endif /* __MOTR_COB_COB_H__ */

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