m0t1fs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013-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_M0T1FS_M0T1FS_H__
#define __MOTR_M0T1FS_M0T1FS_H__

#include <linux/fs.h>
#include <linux/version.h>        /* LINUX_VERSION_CODE */
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
#include <linux/backing-dev.h>
#endif
#include <linux/pagemap.h>

#include "lib/tlist.h"
#include "lib/hash.h"
#include "lib/mutex.h"
#include "lib/semaphore.h"
#include "net/net.h"             /* m0_net_domain */
#include "rpc/rpc.h"
#include "reqh/reqh.h"
#include "pool/pool.h"           /* m0_pool, m0_pool_version, m0_pools_common */
#include "net/buffer_pool.h"
#include "fid/fid.h"
#include "cob/cob.h"             /* m0_cob_domain_id */
#include "layout/layout.h"
#include "ioservice/io_fops.h"   /* m0_fop_cob_create_fopt */
#include "mdservice/md_fops.h"   /* m0_fop_create_fopt */
#include "file/file.h"           /* m0_file */
#include "be/ut/helper.h"
#include "spiel/spiel.h"         /* m0_spiel */
#include "m0t1fs/linux_kernel/m0t1fs_addb2.h"
#include "motr/ha.h"             /* m0_motr_ha */
#include "conf/confc.h"          /* m0_conf_state */

struct m0_pdclust_layout;

M0_INTERNAL int m0t1fs_init(void);
M0_INTERNAL void m0t1fs_fini(void);

enum {
        M0T1FS_RPC_TIMEOUT              = 100,   /* seconds */
        M0T1FS_RPC_MAX_RETRIES          =  10,
        M0T1FS_RPC_RESEND_INTERVAL      = M0_MKTIME(M0T1FS_RPC_TIMEOUT, 0) /
                                          M0T1FS_RPC_MAX_RETRIES,
        M0T1FS_MAX_NR_RPC_IN_FLIGHT     = 100,
        M0T1FS_DEFAULT_NR_DATA_UNITS    = 1,
        M0T1FS_DEFAULT_NR_PARITY_UNITS  = 1,
        M0T1FS_DEFAULT_STRIPE_UNIT_SIZE = PAGE_SIZE,
        M0T1FS_MAX_NR_CONTAINERS        = 4096,
        M0T1FS_COB_ID_STRLEN            = 34,
};

enum io_req_type {
        IRT_READ,
        IRT_WRITE,
        IRT_TYPE_NR,
};

struct m0t1fs_sb {
        struct m0_pools_common                  csb_pools_common;

        uint32_t                                csb_nr_containers;

        uint64_t                                csb_next_key;

        struct m0_mutex                         csb_mutex;

        bool                                    csb_active;

        struct m0_atomic64                      csb_pending_io_nr;

        struct m0_thread                        csb_astthread;

        struct m0_chan                          csb_iowait;

        struct m0_sm_group                      csb_iogroup;

        struct m0_fid                           csb_root_fid;

        int                                     csb_namelen;

        struct m0_net_xprt                     *csb_xprt;
        char                                   *csb_laddr;
        struct m0_net_domain                    csb_ndom;
        struct m0_rpc_machine                   csb_rpc_machine;
        struct m0_reqh                          csb_reqh;
        struct m0_net_buffer_pool               csb_buffer_pool;

        struct m0_be_ut_backend                 csb_ut_be;
        struct m0_be_ut_seg                     csb_ut_seg;

        size_t                                  csb_tmid;

        struct dentry                          *csb_motr_dentry;

        struct dentry                          *csb_fid_dentry;

        struct super_block                     *csb_sb;
        struct m0_fop_cob                       csb_virt_body;

        bool                                    csb_oostore;
        bool                                    csb_verify;

        struct m0_reqh_service_ctx             *csb_ha_rsctx;

        struct m0_motr_ha                       csb_motr_ha;

        struct m0_tl                            csb_inodes;
        struct m0_mutex                         csb_inodes_lock;

        struct m0_htable                        csb_service_pending_txid_map;
        struct m0_mutex                         csb_service_pending_txid_map_lock;

        struct m0_clink                         csb_conf_exp;
        struct m0_clink                         csb_conf_ready;
        struct m0_clink                         csb_conf_ready_async;

        struct m0_chan                          csb_conf_ready_chan;

        struct m0_confc_update_state            csb_confc_state;

        uint64_t                                csb_reqs_nr;

        struct m0_fid                           csb_process_fid;
        struct m0_fid                           csb_profile_fid;

        struct m0_reqh_service                 *csb_rm_service;

#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
        struct backing_dev_info                 csb_backing_dev_info;
#endif
};

struct m0t1fs_filedata {
        int                        fd_direof;
        struct m0_bitstring       *fd_dirpos;
        uint32_t                   fd_mds_index;
};

struct m0t1fs_mdop {
        struct m0_cob_attr    mo_attr;
        enum m0_cob_type      mo_cob_type;
        struct m0_layout     *mo_layout;
        bool                  mo_use_hint; 
        uint32_t              mo_hash_hint;
};

M0_TL_DESCR_DECLARE(ispti, extern);
M0_TL_DECLARE(ispti, extern, struct m0_reqh_service_txid);

struct m0t1fs_inode {
        struct inode               ci_inode;
        struct m0_fid              ci_fid;
        struct m0_layout_instance *ci_layout_instance;
        struct m0_mutex            ci_layout_lock;
        struct m0_file             ci_flock;
        struct m0_rm_owner         ci_fowner;
        struct m0_rm_remote        ci_creditor;
        struct m0_fid              ci_pver;
        uint64_t                   ci_layout_id;
        struct m0_tl               ci_pending_tx;
        struct m0_mutex            ci_pending_tx_lock;

        uint64_t                   ci_magic;
        struct m0_tlink            ci_sb_linkage;
        /* Has layout been changed via setfattr? */
        bool                       ci_layout_changed;
};

M0_TL_DESCR_DECLARE(csb_inodes, M0_EXTERN);
M0_TL_DECLARE(csb_inodes, M0_EXTERN, struct m0t1fs_inode);

extern struct m0_semaphore m0t1fs_cpus_sem;

static inline struct m0t1fs_sb *M0T1FS_SB(const struct super_block *sb)
{
        return sb->s_fs_info;
}

static inline struct m0t1fs_inode *M0T1FS_I(const struct inode *inode)
{
        return container_of(inode, struct m0t1fs_inode, ci_inode);
}

extern const struct file_operations m0t1fs_dir_file_operations;
extern const struct file_operations m0t1fs_fid_dir_file_operations;
extern const struct file_operations m0t1fs_reg_file_operations;

extern const struct inode_operations m0t1fs_dir_inode_operations;
extern const struct inode_operations m0t1fs_fid_dir_inode_operations;
extern const struct inode_operations m0t1fs_reg_inode_operations;

extern const struct address_space_operations m0t1fs_aops;

/* super.c */

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
M0_INTERNAL struct dentry *m0t1fs_mount(struct file_system_type *fstype,
                                        int flags, const char *devname,
                                        void *data);
#else
M0_INTERNAL int m0t1fs_get_sb(struct file_system_type *fstype,
                              int flags,
                              const char *devname,
                              void *data, struct vfsmount *mnt);
#endif

M0_INTERNAL void m0t1fs_sb_init(struct m0t1fs_sb *csb);
M0_INTERNAL void m0t1fs_sb_fini(struct m0t1fs_sb *csb);

M0_INTERNAL void m0t1fs_kill_sb(struct super_block *sb);

M0_INTERNAL void m0t1fs_fs_lock(struct m0t1fs_sb *csb);
M0_INTERNAL void m0t1fs_fs_unlock(struct m0t1fs_sb *csb);
M0_INTERNAL bool m0t1fs_fs_is_locked(const struct m0t1fs_sb *csb);

M0_INTERNAL int m0t1fs_fs_conf_lock(struct m0t1fs_sb *csb);
M0_INTERNAL void m0t1fs_fs_conf_unlock(struct m0t1fs_sb *csb);

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)
M0_INTERNAL int m0t1fs_getattr(const struct path *path, struct kstat *stat,
                               uint32_t request_mask, uint32_t query_flags);
M0_INTERNAL int m0t1fs_fid_getattr(const struct path *path, struct kstat *stat,
                                   uint32_t request_mask, uint32_t query_flags);
#else
M0_INTERNAL int m0t1fs_getattr(struct vfsmount *mnt, struct dentry *de,
                               struct kstat *stat);
M0_INTERNAL int m0t1fs_fid_getattr(struct vfsmount *mnt, struct dentry *de,
                                   struct kstat *stat);
#endif
M0_INTERNAL int m0t1fs_setattr(struct dentry *dentry, struct iattr *attr);
M0_INTERNAL int m0t1fs_fid_setattr(struct dentry *dentry, struct iattr *attr);
M0_INTERNAL void m0t1fs_inode_update(struct inode *inode,
                                     struct m0_fop_cob *body);
M0_INTERNAL int m0t1fs_ref_get_lock(struct m0t1fs_sb *csb);
M0_INTERNAL void m0t1fs_ref_put_lock(struct m0t1fs_sb *csb);

M0_INTERNAL struct m0_rpc_session *
m0t1fs_container_id_to_session(const struct m0_pool_version *pver,
                               uint64_t container_id);

M0_INTERNAL struct m0_rpc_session *
m0t1fs_filename_to_mds_session(const struct m0t1fs_sb *csb,
                               const unsigned char *filename,
                               unsigned int nlen,
                               bool use_hint,
                               uint32_t hash_hint);

/* inode.c */

M0_INTERNAL int m0t1fs_inode_cache_init(void);
M0_INTERNAL void m0t1fs_inode_cache_fini(void);

M0_INTERNAL bool m0t1fs_inode_is_root(const struct inode *inode);
M0_INTERNAL bool m0t1fs_inode_is_dot_motr(const struct inode *inode);
M0_INTERNAL bool m0t1fs_inode_is_dot_motr_fid(const struct inode *inode);

M0_INTERNAL struct inode *m0t1fs_root_iget(struct super_block *sb,
                                           const struct m0_fid *root_fid);
M0_INTERNAL struct inode *m0t1fs_iget(struct super_block *sb,
                                      const struct m0_fid *fid,
                                      struct m0_fop_cob *body);

M0_INTERNAL struct inode *m0t1fs_alloc_inode(struct super_block *sb);
M0_INTERNAL void m0t1fs_destroy_inode(struct inode *inode);

M0_INTERNAL int m0t1fs_inode_layout_init(struct m0t1fs_inode *ci);
M0_INTERNAL int m0t1fs_inode_layout_rebuild(struct m0t1fs_inode *ci,
                                            struct m0_fop_cob *body);
M0_INTERNAL int m0t1fs_inode_test(struct inode *inode, void *opaque);

/* dir.c */

M0_INTERNAL struct m0_rm_domain *m0t1fs_rm_domain_get(struct m0t1fs_sb *sb);

M0_INTERNAL void m0t1fs_file_lock_init(struct m0t1fs_inode    *ci,
                                       struct m0t1fs_sb *csb);

M0_INTERNAL void m0t1fs_file_lock_fini(struct m0t1fs_inode *ci);

struct io_mem_stats {
        uint64_t a_ioreq_nr;
        uint64_t d_ioreq_nr;
        uint64_t a_pargrp_iomap_nr;
        uint64_t d_pargrp_iomap_nr;
        uint64_t a_target_ioreq_nr;
        uint64_t d_target_ioreq_nr;
        uint64_t a_io_req_fop_nr;
        uint64_t d_io_req_fop_nr;
        uint64_t a_data_buf_nr;
        uint64_t d_data_buf_nr;
        uint64_t a_page_nr;
        uint64_t d_page_nr;
};

M0_INTERNAL int m0t1fs_mds_cob_create(struct m0t1fs_sb          *csb,
                                      const struct m0t1fs_mdop  *mo,
                                      struct m0_fop            **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_unlink(struct m0t1fs_sb          *csb,
                                      const struct m0t1fs_mdop  *mo,
                                      struct m0_fop            **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_link(struct m0t1fs_sb          *csb,
                                    const struct m0t1fs_mdop  *mo,
                                    struct m0_fop            **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_lookup(struct m0t1fs_sb          *csb,
                                      const struct m0t1fs_mdop  *mo,
                                      struct m0_fop            **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_getattr(struct m0t1fs_sb           *csb,
                                       const struct m0t1fs_mdop   *mo,
                                       struct m0_fop             **rep_fop);

M0_INTERNAL int m0t1fs_mds_statfs(struct m0t1fs_sb                *csb,
                                  struct m0_fop                  **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_setattr(struct m0t1fs_sb           *csb,
                                       const struct m0t1fs_mdop   *mo,
                                       struct m0_fop             **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_readdir(struct m0t1fs_sb           *csb,
                                       const struct m0t1fs_mdop   *mo,
                                       struct m0_fop             **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_setxattr(struct m0t1fs_sb            *csb,
                                        const struct m0t1fs_mdop    *mo,
                                        struct m0_fop              **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_getxattr(struct m0t1fs_sb            *csb,
                                        const struct m0t1fs_mdop    *mo,
                                        struct m0_fop              **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_listxattr(struct m0t1fs_sb             *csb,
                                         const struct m0t1fs_mdop     *mo,
                                         struct m0_fop               **rep_fop);

M0_INTERNAL int m0t1fs_mds_cob_delxattr(struct m0t1fs_sb            *csb,
                                        const struct m0t1fs_mdop    *mo,
                                        struct m0_fop              **rep_fop);

M0_INTERNAL int m0t1fs_size_update(struct dentry *dentry,
                                   uint64_t newsize);

M0_INTERNAL int m0t1fs_inode_set_layout_id(struct m0t1fs_inode *ci,
                                           struct m0t1fs_mdop *mo,
                                           int layout_id);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,9,0)
extern const struct xattr_handler *m0t1fs_xattr_handlers[];
M0_INTERNAL int m0t1fs_setxattr(const struct xattr_handler *handler,
                                struct dentry *dentry, struct inode *inode,
                                const char *name, const void *value,
                                size_t size, int flags);
M0_INTERNAL int m0t1fs_fid_setxattr(const struct xattr_handler *handler,
                                    struct dentry *dentry, struct inode *inode,
                                    const char *name, const void *value,
                                    size_t size, int flags);
M0_INTERNAL int m0t1fs_getxattr(const struct xattr_handler *handler,
                                struct dentry *dentry, struct inode *inode,
                                const char *name, void *buffer,
                                size_t size);
M0_INTERNAL int m0t1fs_fid_getxattr(const struct xattr_handler *handler,
                                    struct dentry *dentry, struct inode *inode,
                                    const char *name, void *buffer,
                                    size_t size);
#else
M0_INTERNAL int m0t1fs_setxattr(struct dentry *dentry, const char *name,
                                const void *value, size_t size, int flags);

M0_INTERNAL int m0t1fs_fid_setxattr(struct dentry *dentry, const char *name,
                                    const void *value, size_t size, int flags);

M0_INTERNAL ssize_t m0t1fs_getxattr(struct dentry *dentry, const char *name,
                                    void *buffer, size_t size);

M0_INTERNAL ssize_t m0t1fs_fid_getxattr(struct dentry *dentry, const char *name,
                                        void *buffer, size_t size);
#endif
M0_INTERNAL int m0t1fs_removexattr(struct dentry *dentry, const char *name);
M0_INTERNAL int m0t1fs_fid_removexattr(struct dentry *dentry, const char *name);

M0_INTERNAL ssize_t m0t1fs_listxattr(struct dentry *dentry, char *buffer,
                                     size_t size);
M0_INTERNAL ssize_t m0t1fs_fid_listxattr(struct dentry *dentry, char *buffer,
                                     size_t size);

M0_INTERNAL const struct m0_fid *
                m0t1fs_inode_fid(const struct m0t1fs_inode *ci);

void m0t1fs_fid_alloc(struct m0t1fs_sb *csb, struct m0_fid *out);

void m0t1fs_fid_accept(struct m0t1fs_sb *csb, const struct m0_fid *fid);

unsigned long fid_hash(const struct m0_fid *fid);
M0_INTERNAL struct m0t1fs_sb *m0_fop_to_sb(struct m0_fop *fop);
M0_INTERNAL struct m0_file *m0_fop_to_file(struct m0_fop *fop);

M0_INTERNAL int m0t1fs_cob_getattr(struct inode *inode);
M0_INTERNAL int m0t1fs_cob_setattr(struct inode *inode, struct m0t1fs_mdop *mo);
M0_INTERNAL int m0t1fs_fill_cob_attr(struct m0_fop_cob *cob);
M0_INTERNAL struct m0_confc *m0_csb2confc(struct m0t1fs_sb *csb);
M0_INTERNAL struct m0_rconfc *m0_csb2rconfc(struct m0t1fs_sb *csb);
#endif /* __MOTR_M0T1FS_M0T1FS_H__ */

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