/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * RDMA Transport Layer
 *
 * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved.
 * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved.
 * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved.
 */

#ifndef RTRS_CLT_H
#define RTRS_CLT_H

#include <linux/device.h>
#include "rtrs-pri.h"

/**
 * enum rtrs_clt_state - Client states.
 */
enum rtrs_clt_state {
        RTRS_CLT_CONNECTING,
        RTRS_CLT_CONNECTING_ERR,
        RTRS_CLT_RECONNECTING,
        RTRS_CLT_CONNECTED,
        RTRS_CLT_CLOSING,
        RTRS_CLT_CLOSED,
        RTRS_CLT_DEAD,
};

enum rtrs_mp_policy {
        MP_POLICY_RR,
        MP_POLICY_MIN_INFLIGHT,
        MP_POLICY_MIN_LATENCY,
};

/* see Documentation/ABI/testing/sysfs-class-rtrs-client for details */
struct rtrs_clt_stats_reconnects {
        int successful_cnt;
        int fail_cnt;
};

/* see Documentation/ABI/testing/sysfs-class-rtrs-client for details */
struct rtrs_clt_stats_cpu_migr {
        atomic_t from;
        int to;
};

/* stats for Read and write operation.
 * see Documentation/ABI/testing/sysfs-class-rtrs-client for details
 */
struct rtrs_clt_stats_rdma {
        struct {
                u64 cnt;
                u64 size_total;
        } dir[2];

        u64 failover_cnt;
};

struct rtrs_clt_stats_pcpu {
        struct rtrs_clt_stats_cpu_migr          cpu_migr;
        struct rtrs_clt_stats_rdma              rdma;
};

struct rtrs_clt_stats {
        struct kobject                          kobj_stats;
        struct rtrs_clt_stats_pcpu    __percpu  *pcpu_stats;
        struct rtrs_clt_stats_reconnects        reconnects;
        atomic_t                                inflight;
};

struct rtrs_clt_con {
        struct rtrs_con c;
        struct rtrs_iu          *rsp_ius;
        u32                     queue_num;
        unsigned int            cpu;
        struct mutex            con_mutex;
        int                     cm_err;
};

/**
 * rtrs_permit - permits the memory allocation for future RDMA operation.
 *               Combine with irq pinning to keep IO on same CPU.
 */
struct rtrs_permit {
        enum rtrs_clt_con_type con_type;
        unsigned int cpu_id;
        unsigned int mem_id;
        unsigned int mem_off;
};

/**
 * rtrs_clt_io_req - describes one inflight IO request
 */
struct rtrs_clt_io_req {
        struct rtrs_iu          *iu;
        struct scatterlist      *sglist; /* list holding user data */
        unsigned int            sg_cnt;
        unsigned int            sg_size;
        unsigned int            data_len;
        unsigned int            usr_len;
        void                    *priv;
        bool                    in_use;
        enum rtrs_mp_policy     mp_policy;
        struct rtrs_clt_con     *con;
        struct ib_sge           *sge;
        struct rtrs_permit      *permit;
        enum dma_data_direction dir;
        void                    (*conf)(void *priv, int errno);

        struct ib_mr            *mr;
        struct ib_cqe           inv_cqe;
        struct completion       inv_comp;
        int                     inv_errno;
        bool                    need_inv_comp;
        refcount_t              ref;
};

struct rtrs_rbuf {
        u64 addr;
        u32 rkey;
};

struct rtrs_clt_path {
        struct rtrs_path        s;
        struct rtrs_clt_sess    *clt;
        wait_queue_head_t       state_wq;
        enum rtrs_clt_state     state;
        atomic_t                connected_cnt;
        struct mutex            init_mutex;
        struct rtrs_clt_io_req  *reqs;
        struct delayed_work     reconnect_dwork;
        struct work_struct      close_work;
        struct work_struct      err_recovery_work;
        unsigned int            reconnect_attempts;
        bool                    established;
        struct rtrs_rbuf        *rbufs;
        size_t                  max_io_size;
        u32                     max_hdr_size;
        u32                     chunk_size;
        size_t                  queue_depth;
        u32                     max_pages_per_mr;
        u32                     flags;
        struct kobject          kobj;
        u8                      for_new_clt;
        struct rtrs_clt_stats   *stats;
        /* cache hca_port and hca_name to display in sysfs */
        u8                      hca_port;
        char                    hca_name[IB_DEVICE_NAME_MAX];
        struct list_head __percpu
                                *mp_skip_entry;
};

struct rtrs_clt_sess {
        struct list_head        paths_list; /* rcu protected list */
        size_t                  paths_num;
        struct rtrs_clt_path
        __rcu * __percpu        *pcpu_path;
        uuid_t                  paths_uuid;
        int                     paths_up;
        struct mutex            paths_mutex;
        struct mutex            paths_ev_mutex;
        char                    sessname[NAME_MAX];
        u16                     port;
        unsigned int            max_reconnect_attempts;
        unsigned int            reconnect_delay_sec;
        unsigned int            max_segments;
        void                    *permits;
        unsigned long           *permits_map;
        size_t                  queue_depth;
        size_t                  max_io_size;
        wait_queue_head_t       permits_wait;
        size_t                  pdu_sz;
        void                    *priv;
        void                    (*link_ev)(void *priv,
                                           enum rtrs_clt_link_ev ev);
        struct device           dev;
        struct kobject          *kobj_paths;
        enum rtrs_mp_policy     mp_policy;
};

static inline struct rtrs_clt_con *to_clt_con(struct rtrs_con *c)
{
        return container_of(c, struct rtrs_clt_con, c);
}

static inline struct rtrs_clt_path *to_clt_path(struct rtrs_path *s)
{
        return container_of(s, struct rtrs_clt_path, s);
}

static inline int permit_size(struct rtrs_clt_sess *clt)
{
        return sizeof(struct rtrs_permit) + clt->pdu_sz;
}

static inline struct rtrs_permit *get_permit(struct rtrs_clt_sess *clt,
                                             int idx)
{
        return (struct rtrs_permit *)(clt->permits + permit_size(clt) * idx);
}

int rtrs_clt_reconnect_from_sysfs(struct rtrs_clt_path *path);
void rtrs_clt_close_conns(struct rtrs_clt_path *clt_path, bool wait);
int rtrs_clt_create_path_from_sysfs(struct rtrs_clt_sess *clt,
                                     struct rtrs_addr *addr);
int rtrs_clt_remove_path_from_sysfs(struct rtrs_clt_path *path,
                                     const struct attribute *sysfs_self);

void rtrs_clt_set_max_reconnect_attempts(struct rtrs_clt_sess *clt, int value);
int rtrs_clt_get_max_reconnect_attempts(const struct rtrs_clt_sess *clt);
void free_path(struct rtrs_clt_path *clt_path);
void rtrs_clt_ib_event_handler(struct ib_event_handler *handler,
                               struct ib_event *ibevent);

/* rtrs-clt-stats.c */

int rtrs_clt_init_stats(struct rtrs_clt_stats *stats);

void rtrs_clt_inc_failover_cnt(struct rtrs_clt_stats *s);

void rtrs_clt_update_wc_stats(struct rtrs_clt_con *con);
void rtrs_clt_update_all_stats(struct rtrs_clt_io_req *req, int dir);

int rtrs_clt_reset_rdma_lat_distr_stats(struct rtrs_clt_stats *stats,
                                         bool enable);
ssize_t rtrs_clt_stats_rdma_lat_distr_to_str(struct rtrs_clt_stats *stats,
                                              char *page);
int rtrs_clt_reset_cpu_migr_stats(struct rtrs_clt_stats *stats, bool enable);
int rtrs_clt_stats_migration_from_cnt_to_str(struct rtrs_clt_stats *stats, char *buf);
int rtrs_clt_stats_migration_to_cnt_to_str(struct rtrs_clt_stats *stats, char *buf);
int rtrs_clt_reset_reconnects_stat(struct rtrs_clt_stats *stats, bool enable);
int rtrs_clt_stats_reconnects_to_str(struct rtrs_clt_stats *stats, char *buf);
int rtrs_clt_reset_rdma_stats(struct rtrs_clt_stats *stats, bool enable);
ssize_t rtrs_clt_stats_rdma_to_str(struct rtrs_clt_stats *stats,
                                    char *page);
int rtrs_clt_reset_all_stats(struct rtrs_clt_stats *stats, bool enable);
ssize_t rtrs_clt_reset_all_help(struct rtrs_clt_stats *stats,
                                 char *page);

/* rtrs-clt-sysfs.c */

int rtrs_clt_create_sysfs_root_files(struct rtrs_clt_sess *clt);
void rtrs_clt_destroy_sysfs_root(struct rtrs_clt_sess *clt);

int rtrs_clt_create_path_files(struct rtrs_clt_path *clt_path);
void rtrs_clt_destroy_path_files(struct rtrs_clt_path *clt_path,
                                  const struct attribute *sysfs_self);

#endif /* RTRS_CLT_H */