linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) 2015 IT University of Copenhagen (rrpc.c)

 * Copyright (C) 2016 CNEX Labs

 * Initial release: Javier Gonzalez <javier@cnexlabs.com>

 *                  Matias Bjorling <matias@cnexlabs.com>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License version

 * 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * Implementation of a physical block-device target for Open-channel SSDs.

 *

 * pblk-init.c - pblk's initialization.

 */

​

#include "pblk.h"

#include "pblk-trace.h"

​

static unsigned int write_buffer_size;

​

module_param(write_buffer_size, uint, 0644);

MODULE_PARM_DESC(write_buffer_size, "number of entries in a write buffer");

​

struct pblk_global_caches {

    struct kmem_cache   *ws;

    struct kmem_cache   *rec;

    struct kmem_cache   *g_rq;

    struct kmem_cache   *w_rq;

​

    struct kref     kref;

​

    struct mutex        mutex; /* Ensures consistency between

                    * caches and kref

                    */

};

​

static struct pblk_global_caches pblk_caches = {

    .mutex = __MUTEX_INITIALIZER(pblk_caches.mutex),

    .kref = KREF_INIT(0),

};

​

struct bio_set pblk_bio_set;

​

static int pblk_rw_io(struct request_queue *q, struct pblk *pblk,

              struct bio *bio)

{

    int ret;

​

    /* Read requests must be <= 256kb due to NVMe's 64 bit completion bitmap

     * constraint. Writes can be of arbitrary size.

     */

    if (bio_data_dir(bio) == READ) {

        blk_queue_split(q, &bio);

        ret = pblk_submit_read(pblk, bio);

        if (ret == NVM_IO_DONE && bio_flagged(bio, BIO_CLONED))

            bio_put(bio);

​

        return ret;

    }

​

    /* Prevent deadlock in the case of a modest LUN configuration and large

     * user I/Os. Unless stalled, the rate limiter leaves at least 256KB

     * available for user I/O.

     */

    if (pblk_get_secs(bio) > pblk_rl_max_io(&pblk->rl))

        blk_queue_split(q, &bio);

​

    return pblk_write_to_cache(pblk, bio, PBLK_IOTYPE_USER);

}

​

static blk_qc_t pblk_make_rq(struct request_queue *q, struct bio *bio)

{

    struct pblk *pblk = q->queuedata;

​

    if (bio_op(bio) == REQ_OP_DISCARD) {

        pblk_discard(pblk, bio);

        if (!(bio->bi_opf & REQ_PREFLUSH)) {

            bio_endio(bio);

            return BLK_QC_T_NONE;

        }

    }

​

    switch (pblk_rw_io(q, pblk, bio)) {

    case NVM_IO_ERR:

        bio_io_error(bio);

        break;