/*
 * Copyright (c) 2016 Oracle.  All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef _RDS_IB_MR_H
#define _RDS_IB_MR_H

#include <linux/kernel.h>

#include "rds.h"
#include "ib.h"

#define RDS_MR_1M_POOL_SIZE             (8192 / 2)
#define RDS_MR_1M_MSG_SIZE              256
#define RDS_MR_8K_MSG_SIZE              2
#define RDS_MR_8K_SCALE                 (256 / (RDS_MR_8K_MSG_SIZE + 1))
#define RDS_MR_8K_POOL_SIZE             (RDS_MR_8K_SCALE * (8192 / 2))

enum rds_ib_fr_state {
        FRMR_IS_FREE,   /* mr invalidated & ready for use */
        FRMR_IS_INUSE,  /* mr is in use or used & can be invalidated */
        FRMR_IS_STALE,  /* Stale MR and needs to be dropped  */
};

struct rds_ib_frmr {
        struct ib_mr            *mr;
        enum rds_ib_fr_state    fr_state;
        bool                    fr_inv;
        wait_queue_head_t       fr_inv_done;
        bool                    fr_reg;
        wait_queue_head_t       fr_reg_done;
        struct ib_send_wr       fr_wr;
        unsigned int            dma_npages;
        unsigned int            sg_byte_len;
};

/* This is stored as mr->r_trans_private. */
struct rds_ib_mr {
        struct delayed_work             work;
        struct rds_ib_device            *device;
        struct rds_ib_mr_pool           *pool;
        struct rds_ib_connection        *ic;

        struct llist_node               llnode;

        /* unmap_list is for freeing */
        struct list_head                unmap_list;
        unsigned int                    remap_count;

        struct scatterlist              *sg;
        unsigned int                    sg_len;
        int                             sg_dma_len;

        u8                              odp:1;
        union {
                struct rds_ib_frmr      frmr;
                struct ib_mr            *mr;
        } u;
};

/* Our own little MR pool */
struct rds_ib_mr_pool {
        unsigned int            pool_type;
        struct mutex            flush_lock;     /* serialize fmr invalidate */
        struct delayed_work     flush_worker;   /* flush worker */

        atomic_t                item_count;     /* total # of MRs */
        atomic_t                dirty_count;    /* # dirty of MRs */

        struct llist_head       drop_list;      /* MRs not reached max_maps */
        struct llist_head       free_list;      /* unused MRs */
        struct llist_head       clean_list;     /* unused & unmapped MRs */
        wait_queue_head_t       flush_wait;
        spinlock_t              clean_lock;     /* "clean_list" concurrency */

        atomic_t                free_pinned;    /* memory pinned by free MRs */
        unsigned long           max_items;
        unsigned long           max_items_soft;
        unsigned long           max_free_pinned;
        unsigned int            max_pages;
};

extern struct workqueue_struct *rds_ib_mr_wq;

struct rds_ib_mr_pool *rds_ib_create_mr_pool(struct rds_ib_device *rds_dev,
                                             int npages);
void rds_ib_get_mr_info(struct rds_ib_device *rds_ibdev,
                        struct rds_info_rdma_connection *iinfo);
void rds6_ib_get_mr_info(struct rds_ib_device *rds_ibdev,
                         struct rds6_info_rdma_connection *iinfo6);
void rds_ib_destroy_mr_pool(struct rds_ib_mr_pool *);
void *rds_ib_get_mr(struct scatterlist *sg, unsigned long nents,
                    struct rds_sock *rs, u32 *key_ret,
                    struct rds_connection *conn, u64 start, u64 length,
                    int need_odp);
void rds_ib_sync_mr(void *trans_private, int dir);
void rds_ib_free_mr(void *trans_private, int invalidate);
void rds_ib_flush_mrs(void);
int rds_ib_mr_init(void);
void rds_ib_mr_exit(void);
u32 rds_ib_get_lkey(void *trans_private);

void __rds_ib_teardown_mr(struct rds_ib_mr *);
void rds_ib_teardown_mr(struct rds_ib_mr *);
struct rds_ib_mr *rds_ib_reuse_mr(struct rds_ib_mr_pool *);
int rds_ib_flush_mr_pool(struct rds_ib_mr_pool *, int, struct rds_ib_mr **);
struct rds_ib_mr *rds_ib_try_reuse_ibmr(struct rds_ib_mr_pool *);
struct rds_ib_mr *rds_ib_reg_frmr(struct rds_ib_device *rds_ibdev,
                                  struct rds_ib_connection *ic,
                                  struct scatterlist *sg,
                                  unsigned long nents, u32 *key);
void rds_ib_unreg_frmr(struct list_head *list, unsigned int *nfreed,
                       unsigned long *unpinned, unsigned int goal);
void rds_ib_free_frmr_list(struct rds_ib_mr *);
#endif