/* SPDX-License-Identifier: GPL-2.0-or-later */
#ifndef _BACKING_DEV_H
#define _BACKING_DEV_H

#include <linux/device-mapper.h>

#include "pcache_internal.h"

struct pcache_backing_dev_req;
typedef void (*backing_req_end_fn_t)(struct pcache_backing_dev_req *backing_req, int ret);

#define BACKING_DEV_REQ_TYPE_REQ                1
#define BACKING_DEV_REQ_TYPE_KMEM               2

#define BACKING_DEV_REQ_INLINE_BVECS            4

struct pcache_request;
struct pcache_backing_dev_req {
        u8                              type;
        struct bio                      bio;
        struct pcache_backing_dev       *backing_dev;

        void                            *priv_data;
        backing_req_end_fn_t            end_req;

        struct list_head                node;
        int                             ret;

        union {
                struct {
                        struct pcache_request           *upper_req;
                        u32                             bio_off;
                } req;
                struct {
                        struct bio_vec  inline_bvecs[BACKING_DEV_REQ_INLINE_BVECS];
                        struct bio_vec  *bvecs;
                        u32             n_vecs;
                } kmem;
        };
};

struct pcache_backing_dev {
        struct pcache_cache             *cache;

        struct dm_dev                   *dm_dev;
        mempool_t                       req_pool;
        mempool_t                       bvec_pool;

        struct list_head                submit_list;
        spinlock_t                      submit_lock;
        struct work_struct              req_submit_work;

        struct list_head                complete_list;
        spinlock_t                      complete_lock;
        struct work_struct              req_complete_work;

        atomic_t                        inflight_reqs;
        wait_queue_head_t               inflight_wq;

        u64                             dev_size;
};

struct dm_pcache;
int backing_dev_start(struct dm_pcache *pcache);
void backing_dev_stop(struct dm_pcache *pcache);

struct pcache_backing_dev_req_opts {
        u32 type;
        union {
                struct {
                        struct pcache_request *upper_req;
                        u32 req_off;
                        u32 len;
                } req;
                struct {
                        void *data;
                        blk_opf_t opf;
                        u32 len;
                        u64 backing_off;
                } kmem;
        };

        gfp_t gfp_mask;
        backing_req_end_fn_t    end_fn;
        void                    *priv_data;
};

static inline u32 backing_dev_req_coalesced_max_len(const void *data, u32 len)
{
        const void *p = data;
        u32 done = 0, in_page, to_advance;
        struct page *first_page, *next_page;

        if (!is_vmalloc_addr(data))
                return len;

        first_page = vmalloc_to_page(p);
advance:
        in_page = PAGE_SIZE - offset_in_page(p);
        to_advance = min_t(u32, in_page, len - done);

        done += to_advance;
        p += to_advance;

        if (done == len)
                return done;

        next_page = vmalloc_to_page(p);
        if (zone_device_pages_have_same_pgmap(first_page, next_page))
                goto advance;

        return done;
}

void backing_dev_req_submit(struct pcache_backing_dev_req *backing_req, bool direct);
void backing_dev_req_end(struct pcache_backing_dev_req *backing_req);
struct pcache_backing_dev_req *backing_dev_req_create(struct pcache_backing_dev *backing_dev,
                                                struct pcache_backing_dev_req_opts *opts);
struct pcache_backing_dev_req *backing_dev_req_alloc(struct pcache_backing_dev *backing_dev,
                                                struct pcache_backing_dev_req_opts *opts);
void backing_dev_req_init(struct pcache_backing_dev_req *backing_req,
                        struct pcache_backing_dev_req_opts *opts);
void backing_dev_flush(struct pcache_backing_dev *backing_dev);

int pcache_backing_init(void);
void pcache_backing_exit(void);
#endif /* _BACKING_DEV_H */