/*
* Alloc bounce buf for read/write numbers of pages in one request
*/
static int card_init_bounce_buf(struct card_queue *cq,
struct memory_card *card)
{
int ret=0;
struct card_host *host = card->host;
unsigned int bouncesz;
bouncesz = CARD_QUEUE_BOUNCESZ;
if (bouncesz > host->max_req_size)
bouncesz = host->max_req_size;
if (bouncesz >= PAGE_CACHE_SIZE) {
//cq->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
cq->bounce_buf = host->dma_buf;
if (!cq->bounce_buf) {
printk(KERN_WARNING "%s: unable to "
"allocate bounce buffer\n", card->name);
}
}
if (cq->bounce_buf) {
blk_queue_bounce_limit(cq->queue, BLK_BOUNCE_HIGH);
blk_queue_max_hw_sectors(cq->queue, bouncesz / 512);
blk_queue_physical_block_size(cq->queue, bouncesz);
blk_queue_max_segments(cq->queue, bouncesz / PAGE_CACHE_SIZE);
blk_queue_max_segment_size(cq->queue, bouncesz);
cq->queue->queuedata = cq;
cq->req = NULL;
cq->sg = kmalloc(sizeof(struct scatterlist),
GFP_KERNEL);
if (!cq->sg) {
ret = -ENOMEM;
blk_cleanup_queue(cq->queue);
return ret;
}
sg_init_table(cq->sg, 1);
cq->bounce_sg = kmalloc(sizeof(struct scatterlist) *
bouncesz / PAGE_CACHE_SIZE, GFP_KERNEL);
if (!cq->bounce_sg) {
ret = -ENOMEM;
kfree(cq->sg);
cq->sg = NULL;
blk_cleanup_queue(cq->queue);
return ret;
}
sg_init_table(cq->bounce_sg, bouncesz / PAGE_CACHE_SIZE);
}
return 0;
}
static int pmem_attach_disk(struct device *dev,
struct nd_namespace_common *ndns, struct pmem_device *pmem)
{
struct gendisk *disk;
pmem->pmem_queue = blk_alloc_queue(GFP_KERNEL);
if (!pmem->pmem_queue)
return -ENOMEM;
blk_queue_make_request(pmem->pmem_queue, pmem_make_request);
blk_queue_physical_block_size(pmem->pmem_queue, PAGE_SIZE);
blk_queue_max_hw_sectors(pmem->pmem_queue, UINT_MAX);
blk_queue_bounce_limit(pmem->pmem_queue, BLK_BOUNCE_ANY);
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, pmem->pmem_queue);
disk = alloc_disk(0);
if (!disk) {
blk_cleanup_queue(pmem->pmem_queue);
return -ENOMEM;
}
disk->major = pmem_major;
disk->first_minor = 0;
disk->fops = &pmem_fops;
disk->private_data = pmem;
disk->queue = pmem->pmem_queue;
disk->flags = GENHD_FL_EXT_DEVT;
nvdimm_namespace_disk_name(ndns, disk->disk_name);
disk->driverfs_dev = dev;
set_capacity(disk, (pmem->size - pmem->data_offset) / 512);
pmem->pmem_disk = disk;
add_disk(disk);
revalidate_disk(disk);
return 0;
}
/*
* Create a block device minor node and setup the linkage between it
* and the specified volume. Once this function returns the block
* device is live and ready for use.
*/
static int
zvol_create_minor_impl(const char *name)
{
zvol_state_t *zv;
objset_t *os;
dmu_object_info_t *doi;
uint64_t volsize;
uint64_t len;
unsigned minor = 0;
int error = 0;
mutex_enter(&zvol_state_lock);
zv = zvol_find_by_name(name);
if (zv) {
error = SET_ERROR(EEXIST);
goto out;
}
doi = kmem_alloc(sizeof (dmu_object_info_t), KM_SLEEP);
error = dmu_objset_own(name, DMU_OST_ZVOL, B_TRUE, zvol_tag, &os);
if (error)
goto out_doi;
error = dmu_object_info(os, ZVOL_OBJ, doi);
if (error)
goto out_dmu_objset_disown;
error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
if (error)
goto out_dmu_objset_disown;
error = zvol_find_minor(&minor);
if (error)
goto out_dmu_objset_disown;
zv = zvol_alloc(MKDEV(zvol_major, minor), name);
if (zv == NULL) {
error = SET_ERROR(EAGAIN);
goto out_dmu_objset_disown;
}
if (dmu_objset_is_snapshot(os))
zv->zv_flags |= ZVOL_RDONLY;
zv->zv_volblocksize = doi->doi_data_block_size;
zv->zv_volsize = volsize;
zv->zv_objset = os;
set_capacity(zv->zv_disk, zv->zv_volsize >> 9);
blk_queue_max_hw_sectors(zv->zv_queue, (DMU_MAX_ACCESS / 4) >> 9);
blk_queue_max_segments(zv->zv_queue, UINT16_MAX);
blk_queue_max_segment_size(zv->zv_queue, UINT_MAX);
blk_queue_physical_block_size(zv->zv_queue, zv->zv_volblocksize);
blk_queue_io_opt(zv->zv_queue, zv->zv_volblocksize);
blk_queue_max_discard_sectors(zv->zv_queue,
(zvol_max_discard_blocks * zv->zv_volblocksize) >> 9);
blk_queue_discard_granularity(zv->zv_queue, zv->zv_volblocksize);
queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, zv->zv_queue);
#ifdef QUEUE_FLAG_NONROT
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zv->zv_queue);
#endif
#ifdef QUEUE_FLAG_ADD_RANDOM
queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, zv->zv_queue);
#endif
if (spa_writeable(dmu_objset_spa(os))) {
if (zil_replay_disable)
zil_destroy(dmu_objset_zil(os), B_FALSE);
else
zil_replay(os, zv, zvol_replay_vector);
}
/*
* When udev detects the addition of the device it will immediately
* invoke blkid(8) to determine the type of content on the device.
* Prefetching the blocks commonly scanned by blkid(8) will speed
* up this process.
*/
len = MIN(MAX(zvol_prefetch_bytes, 0), SPA_MAXBLOCKSIZE);
if (len > 0) {
dmu_prefetch(os, ZVOL_OBJ, 0, 0, len, ZIO_PRIORITY_SYNC_READ);
dmu_prefetch(os, ZVOL_OBJ, 0, volsize - len, len,
ZIO_PRIORITY_SYNC_READ);
}
zv->zv_objset = NULL;
out_dmu_objset_disown:
dmu_objset_disown(os, zvol_tag);
out_doi:
kmem_free(doi, sizeof (dmu_object_info_t));
out:
if (error == 0) {
zvol_insert(zv);
/*
* Drop the lock to prevent deadlock with sys_open() ->
* zvol_open(), which first takes bd_disk->bd_mutex and then
* takes zvol_state_lock, whereas this code path first takes
* zvol_state_lock, and then takes bd_disk->bd_mutex.
*/
mutex_exit(&zvol_state_lock);
add_disk(zv->zv_disk);
} else {
mutex_exit(&zvol_state_lock);
}
return (SET_ERROR(error));
}
static int null_add_dev(void)
{
struct gendisk *disk;
struct nullb *nullb;
sector_t size;
int rv;
nullb = kzalloc_node(sizeof(*nullb), GFP_KERNEL, home_node);
if (!nullb) {
rv = -ENOMEM;
goto out;
}
spin_lock_init(&nullb->lock);
if (queue_mode == NULL_Q_MQ && use_per_node_hctx)
submit_queues = nr_online_nodes;
rv = setup_queues(nullb);
if (rv)
goto out_free_nullb;
if (queue_mode == NULL_Q_MQ) {
nullb->tag_set.ops = &null_mq_ops;
nullb->tag_set.nr_hw_queues = submit_queues;
nullb->tag_set.queue_depth = hw_queue_depth;
nullb->tag_set.numa_node = home_node;
nullb->tag_set.cmd_size = sizeof(struct nullb_cmd);
nullb->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
nullb->tag_set.driver_data = nullb;
rv = blk_mq_alloc_tag_set(&nullb->tag_set);
if (rv)
goto out_cleanup_queues;
nullb->q = blk_mq_init_queue(&nullb->tag_set);
if (IS_ERR(nullb->q)) {
rv = -ENOMEM;
goto out_cleanup_tags;
}
} else if (queue_mode == NULL_Q_BIO) {
nullb->q = blk_alloc_queue_node(GFP_KERNEL, home_node);
if (!nullb->q) {
rv = -ENOMEM;
goto out_cleanup_queues;
}
blk_queue_make_request(nullb->q, null_queue_bio);
rv = init_driver_queues(nullb);
if (rv)
goto out_cleanup_blk_queue;
} else {
nullb->q = blk_init_queue_node(null_request_fn, &nullb->lock, home_node);
if (!nullb->q) {
rv = -ENOMEM;
goto out_cleanup_queues;
}
blk_queue_prep_rq(nullb->q, null_rq_prep_fn);
blk_queue_softirq_done(nullb->q, null_softirq_done_fn);
rv = init_driver_queues(nullb);
if (rv)
goto out_cleanup_blk_queue;
}
nullb->q->queuedata = nullb;
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, nullb->q);
queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, nullb->q);
disk = nullb->disk = alloc_disk_node(1, home_node);
if (!disk) {
rv = -ENOMEM;
goto out_cleanup_blk_queue;
}
mutex_lock(&lock);
list_add_tail(&nullb->list, &nullb_list);
nullb->index = nullb_indexes++;
mutex_unlock(&lock);
blk_queue_logical_block_size(nullb->q, bs);
blk_queue_physical_block_size(nullb->q, bs);
size = gb * 1024 * 1024 * 1024ULL;
sector_div(size, bs);
set_capacity(disk, size);
disk->flags |= GENHD_FL_EXT_DEVT | GENHD_FL_SUPPRESS_PARTITION_INFO;
disk->major = null_major;
disk->first_minor = nullb->index;
disk->fops = &null_fops;
disk->private_data = nullb;
disk->queue = nullb->q;
sprintf(disk->disk_name, "nullb%d", nullb->index);
add_disk(disk);
return 0;
out_cleanup_blk_queue:
blk_cleanup_queue(nullb->q);
out_cleanup_tags:
if (queue_mode == NULL_Q_MQ)
blk_mq_free_tag_set(&nullb->tag_set);
out_cleanup_queues:
cleanup_queues(nullb);
out_free_nullb:
kfree(nullb);
out:
return rv;
}
static int
__zvol_create_minor(const char *name)
{
zvol_state_t *zv;
objset_t *os;
dmu_object_info_t *doi;
uint64_t volsize;
unsigned minor = 0;
int error = 0;
ASSERT(MUTEX_HELD(&zvol_state_lock));
zv = zvol_find_by_name(name);
if (zv) {
error = EEXIST;
goto out;
}
doi = kmem_alloc(sizeof(dmu_object_info_t), KM_SLEEP);
error = dmu_objset_own(name, DMU_OST_ZVOL, B_TRUE, zvol_tag, &os);
if (error)
goto out_doi;
/* Make sure we have the key loaded if we need one. */
error = dsl_crypto_key_inherit(name);
if (error != 0 && error != EEXIST)
goto out_dmu_objset_disown;
error = dmu_object_info(os, ZVOL_OBJ, doi);
if (error)
goto out_dmu_objset_disown;
error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
if (error)
goto out_dmu_objset_disown;
error = zvol_find_minor(&minor);
if (error)
goto out_dmu_objset_disown;
zv = zvol_alloc(MKDEV(zvol_major, minor), name);
if (zv == NULL) {
error = EAGAIN;
goto out_dmu_objset_disown;
}
if (dmu_objset_is_snapshot(os))
zv->zv_flags |= ZVOL_RDONLY;
zv->zv_volblocksize = doi->doi_data_block_size;
zv->zv_volsize = volsize;
zv->zv_objset = os;
set_capacity(zv->zv_disk, zv->zv_volsize >> 9);
blk_queue_max_hw_sectors(zv->zv_queue, UINT_MAX);
blk_queue_max_segments(zv->zv_queue, UINT16_MAX);
blk_queue_max_segment_size(zv->zv_queue, UINT_MAX);
blk_queue_physical_block_size(zv->zv_queue, zv->zv_volblocksize);
blk_queue_io_opt(zv->zv_queue, zv->zv_volblocksize);
#ifdef HAVE_BLK_QUEUE_DISCARD
blk_queue_max_discard_sectors(zv->zv_queue,
(zvol_max_discard_blocks * zv->zv_volblocksize) >> 9);
blk_queue_discard_granularity(zv->zv_queue, zv->zv_volblocksize);
queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, zv->zv_queue);
#endif
#ifdef HAVE_BLK_QUEUE_NONROT
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zv->zv_queue);
#endif
if (zil_replay_disable)
zil_destroy(dmu_objset_zil(os), B_FALSE);
else
zil_replay(os, zv, zvol_replay_vector);
out_dmu_objset_disown:
dmu_objset_disown(os, zvol_tag);
zv->zv_objset = NULL;
out_doi:
kmem_free(doi, sizeof(dmu_object_info_t));
out:
if (error == 0) {
zvol_insert(zv);
add_disk(zv->zv_disk);
}
return (error);
}
int nbdx_register_block_device(struct nbdx_file *nbdx_file)
{
sector_t size = nbdx_file->stbuf.st_size;
int page_size = PAGE_SIZE;
int err = 0;
pr_debug("%s called\n", __func__);
nbdx_file->major = nbdx_major;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 16, 0)
nbdx_mq_reg.nr_hw_queues = submit_queues;
nbdx_file->queue = blk_mq_init_queue(&nbdx_mq_reg, nbdx_file);
#else
nbdx_file->tag_set.ops = &nbdx_mq_ops;
nbdx_file->tag_set.nr_hw_queues = submit_queues;
nbdx_file->tag_set.queue_depth = NBDX_QUEUE_DEPTH;
nbdx_file->tag_set.numa_node = NUMA_NO_NODE;
nbdx_file->tag_set.cmd_size = sizeof(struct raio_io_u);
nbdx_file->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
nbdx_file->tag_set.driver_data = nbdx_file;
err = blk_mq_alloc_tag_set(&nbdx_file->tag_set);
if (err)
goto out;
nbdx_file->queue = blk_mq_init_queue(&nbdx_file->tag_set);
#endif
if (IS_ERR(nbdx_file->queue)) {
pr_err("%s: Failed to allocate blk queue ret=%ld\n",
__func__, PTR_ERR(nbdx_file->queue));
err = PTR_ERR(nbdx_file->queue);
goto blk_mq_init;
}
nbdx_file->queue->queuedata = nbdx_file;
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, nbdx_file->queue);
queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, nbdx_file->queue);
nbdx_file->disk = alloc_disk_node(1, NUMA_NO_NODE);
if (!nbdx_file->disk) {
pr_err("%s: Failed to allocate disk node\n", __func__);
err = -ENOMEM;
goto alloc_disk;
}
nbdx_file->disk->major = nbdx_file->major;
nbdx_file->disk->first_minor = nbdx_file->index;
nbdx_file->disk->fops = &nbdx_ops;
nbdx_file->disk->queue = nbdx_file->queue;
nbdx_file->disk->private_data = nbdx_file;
blk_queue_logical_block_size(nbdx_file->queue, NBDX_SECT_SIZE);
blk_queue_physical_block_size(nbdx_file->queue, NBDX_SECT_SIZE);
sector_div(page_size, NBDX_SECT_SIZE);
blk_queue_max_hw_sectors(nbdx_file->queue, page_size * MAX_SGL_LEN);
sector_div(size, NBDX_SECT_SIZE);
set_capacity(nbdx_file->disk, size);
sscanf(nbdx_file->dev_name, "%s", nbdx_file->disk->disk_name);
add_disk(nbdx_file->disk);
goto out;
alloc_disk:
blk_cleanup_queue(nbdx_file->queue);
blk_mq_init:
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
blk_mq_free_tag_set(&nbdx_file->tag_set);
#endif
out:
return err;
}
static int null_add_dev(void)
{
struct nullb *nullb;
int rv;
nullb = kzalloc_node(sizeof(*nullb), GFP_KERNEL, home_node);
if (!nullb) {
rv = -ENOMEM;
goto out;
}
spin_lock_init(&nullb->lock);
if (queue_mode == NULL_Q_MQ && use_per_node_hctx)
submit_queues = nr_online_nodes;
rv = setup_queues(nullb);
if (rv)
goto out_free_nullb;
if (queue_mode == NULL_Q_MQ) {
nullb->tag_set.ops = &null_mq_ops;
nullb->tag_set.nr_hw_queues = submit_queues;
nullb->tag_set.queue_depth = hw_queue_depth;
nullb->tag_set.numa_node = home_node;
nullb->tag_set.cmd_size = sizeof(struct nullb_cmd);
nullb->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
nullb->tag_set.driver_data = nullb;
rv = blk_mq_alloc_tag_set(&nullb->tag_set);
if (rv)
goto out_cleanup_queues;
nullb->q = blk_mq_init_queue(&nullb->tag_set);
if (IS_ERR(nullb->q)) {
rv = -ENOMEM;
goto out_cleanup_tags;
}
} else if (queue_mode == NULL_Q_BIO) {
nullb->q = blk_alloc_queue_node(GFP_KERNEL, home_node);
if (!nullb->q) {
rv = -ENOMEM;
goto out_cleanup_queues;
}
blk_queue_make_request(nullb->q, null_queue_bio);
rv = init_driver_queues(nullb);
if (rv)
goto out_cleanup_blk_queue;
} else {
nullb->q = blk_init_queue_node(null_request_fn, &nullb->lock, home_node);
if (!nullb->q) {
rv = -ENOMEM;
goto out_cleanup_queues;
}
blk_queue_prep_rq(nullb->q, null_rq_prep_fn);
blk_queue_softirq_done(nullb->q, null_softirq_done_fn);
rv = init_driver_queues(nullb);
if (rv)
goto out_cleanup_blk_queue;
}
nullb->q->queuedata = nullb;
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, nullb->q);
queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, nullb->q);
mutex_lock(&lock);
nullb->index = nullb_indexes++;
mutex_unlock(&lock);
blk_queue_logical_block_size(nullb->q, bs);
blk_queue_physical_block_size(nullb->q, bs);
sprintf(nullb->disk_name, "nullb%d", nullb->index);
if (use_lightnvm)
rv = null_nvm_register(nullb);
else
rv = null_gendisk_register(nullb);
if (rv)
goto out_cleanup_blk_queue;
mutex_lock(&lock);
list_add_tail(&nullb->list, &nullb_list);
mutex_unlock(&lock);
return 0;
out_cleanup_blk_queue:
blk_cleanup_queue(nullb->q);
out_cleanup_tags:
if (queue_mode == NULL_Q_MQ)
blk_mq_free_tag_set(&nullb->tag_set);
out_cleanup_queues:
cleanup_queues(nullb);
out_free_nullb:
kfree(nullb);
out:
return rv;
}
static int null_add_dev(void)
{
struct gendisk *disk;
struct nullb *nullb;
sector_t size;
nullb = kzalloc_node(sizeof(*nullb), GFP_KERNEL, home_node);
if (!nullb)
return -ENOMEM;
spin_lock_init(&nullb->lock);
if (setup_queues(nullb))
goto err;
if (queue_mode == NULL_Q_MQ) {
null_mq_reg.numa_node = home_node;
null_mq_reg.queue_depth = hw_queue_depth;
if (use_per_node_hctx) {
null_mq_reg.ops->alloc_hctx = null_alloc_hctx;
null_mq_reg.ops->free_hctx = null_free_hctx;
null_mq_reg.nr_hw_queues = nr_online_nodes;
} else {
null_mq_reg.ops->alloc_hctx = blk_mq_alloc_single_hw_queue;
null_mq_reg.ops->free_hctx = blk_mq_free_single_hw_queue;
null_mq_reg.nr_hw_queues = submit_queues;
}
nullb->q = blk_mq_init_queue(&null_mq_reg, nullb);
} else if (queue_mode == NULL_Q_BIO) {
nullb->q = blk_alloc_queue_node(GFP_KERNEL, home_node);
blk_queue_make_request(nullb->q, null_queue_bio);
} else {
nullb->q = blk_init_queue_node(null_request_fn, &nullb->lock, home_node);
blk_queue_prep_rq(nullb->q, null_rq_prep_fn);
if (nullb->q)
blk_queue_softirq_done(nullb->q, null_softirq_done_fn);
}
if (!nullb->q)
goto queue_fail;
nullb->q->queuedata = nullb;
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, nullb->q);
disk = nullb->disk = alloc_disk_node(1, home_node);
if (!disk) {
queue_fail:
if (queue_mode == NULL_Q_MQ)
blk_mq_free_queue(nullb->q);
else
blk_cleanup_queue(nullb->q);
cleanup_queues(nullb);
err:
kfree(nullb);
return -ENOMEM;
}
mutex_lock(&lock);
list_add_tail(&nullb->list, &nullb_list);
nullb->index = nullb_indexes++;
mutex_unlock(&lock);
blk_queue_logical_block_size(nullb->q, bs);
blk_queue_physical_block_size(nullb->q, bs);
size = gb * 1024 * 1024 * 1024ULL;
sector_div(size, bs);
set_capacity(disk, size);
disk->flags |= GENHD_FL_EXT_DEVT;
disk->major = null_major;
disk->first_minor = nullb->index;
disk->fops = &null_fops;
disk->private_data = nullb;
disk->queue = nullb->q;
sprintf(disk->disk_name, "nullb%d", nullb->index);
add_disk(disk);
return 0;
}
int td_linux_block_create(struct td_osdev *dev)
{
int rc;
struct request_queue *queue;
unsigned bio_sector_size = dev->block_params.bio_sector_size;
unsigned hw_sector_size = dev->block_params.hw_sector_size;
/* very simple sector size support */
if (!bio_sector_size || bio_sector_size & 511 || bio_sector_size > 4096) {
td_os_err(dev, "bio sector size of %u is not supported\n", bio_sector_size);
return -EINVAL;
}
/* MetaData is reported here */
if (hw_sector_size == 520)
hw_sector_size = 512;
if (!hw_sector_size || hw_sector_size & 511 || hw_sector_size > 4096) {
td_os_err(dev, "hw sector size of %u is not supported\n", hw_sector_size);
return -EINVAL;
}
td_os_notice(dev, " - Set capacity to %llu (%u bytes/sector)\n",
dev->block_params.capacity, dev->block_params.hw_sector_size);
/* create a new bio queue */
queue = blk_alloc_queue(GFP_KERNEL);
if (!queue) {
td_os_err(dev, "Error allocating disk queue.\n");
rc = -ENOMEM;
goto error_alloc_queue;
}
#ifdef QUEUE_FLAG_NONROT
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, queue);
#endif
switch (dev->type) {
case TD_OSDEV_DEVICE:
blk_queue_make_request(queue, td_device_make_request);
dev->_bio_error = td_device_bio_error;
break;
case TD_OSDEV_RAID:
blk_queue_make_request(queue, td_raid_make_request);
dev->_bio_error = td_raid_bio_error;
break;
default:
td_os_err(dev, "Unkonwn OS Type, cannot register block request handler\n");
goto error_config_queue;
}
queue->queuedata = dev;
#if defined QUEUE_FLAG_PLUGGED
queue->unplug_fn = td_device_queue_unplug;
#endif
/* configure queue ordering */
/* in QUEUE_ORDERED_DRAIN we will get BARRIERS after the queue has
* been drained. */
#if defined KABI__blk_queue_ordered
#if KABI__blk_queue_ordered == 2
blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN);
#elif KABI__blk_queue_ordered == 3
blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN, NULL);
#else
#error unhandled value of KABI__blk_queue_ordered
#endif
#elif defined KABI__blk_queue_flush
/*
* blk_queue_ordered was replaced with blk_queue_flush
* The default implementation is QUEUE_ORDERED_DRAIN
*/
blk_queue_flush(queue, 0);
#else
#error undefined KABI__blk_queue_flush or KABI__blk_queue_ordered
#endif
/* max out the throttling */
#ifdef KABI__blk_queue_max_hw_sectors
blk_queue_max_hw_sectors(queue, dev->block_params.bio_max_bytes/512);
#elif defined KABI__blk_queue_max_sectors
blk_queue_max_sectors(queue, dev->block_params.bio_max_bytes/512);
#else
td_os_err(dev, "No kernel API for maximum sectors\n");
#endif
#if defined KABI__blk_queue_max_segments
blk_queue_max_segments(queue, BLK_MAX_SEGMENTS);
#elif defined KABI__blk_queue_max_phys_segments
blk_queue_max_phys_segments(queue, MAX_SEGMENT_SIZE);
blk_queue_max_hw_segments(queue, MAX_SEGMENT_SIZE);
#else
td_os_err(dev, "No kernel API for maximum segments\n");
#endif
blk_queue_max_segment_size(queue, dev->block_params.bio_max_bytes);
blk_queue_bounce_limit(queue, BLK_BOUNCE_ANY);
/* setup paged based access */
td_os_info(dev, "Set queue physical block size to %u\n", hw_sector_size);
#ifdef KABI__blk_queue_physical_block_size
blk_queue_physical_block_size(queue, hw_sector_size);
#elif defined KABI__blk_queue_hardsect_size
blk_queue_hardsect_size(queue, hw_sector_size);
#else
td_os_err(dev, "No kernel API for physical sector size\n");
#endif
#ifdef KABI__blk_queue_logical_block_size
td_os_info(dev, "Set queue logical block size to %u\n", bio_sector_size);
blk_queue_logical_block_size(queue, bio_sector_size);
#else
td_os_err(dev, "No kernel API for logical block size\n");
#endif
#ifdef KABI__blk_queue_io_min
td_os_info(dev, "Set queue io_min to %u\n", bio_sector_size);
blk_queue_io_min(queue, bio_sector_size);
#else
td_os_err(dev, "No kernel API for minimum IO size\n");
#endif
#ifdef KABI__blk_queue_io_opt
td_os_info(dev, "Set queue io_opt to %u\n", dev->block_params.bio_max_bytes);
blk_queue_io_opt(queue, dev->block_params.bio_max_bytes);
#else
td_os_err(dev, "No kernel API for optimal IO size\n");
#endif
#if 0
if (dev->block_params.discard)
{
int did_something = 0;
#if defined KABI__blk_queue_discard_granularity
queue->limits.discard_granularity = bio_sector_size;
did_something++;
#endif
#ifdef KABI__blk_queue_max_discard_sectors
/* 0xFFFF (max sector size of chunk on trim) * 64 * # SSD */
blk_queue_max_discard_sectors(queue, TD_MAX_DISCARD_LBA_COUNT * 2);
did_something++;
#endif
#ifdef KABI__blk_queue_discard_zeroes_data
queue->limits.discard_zeroes_data = 1;
did_something++;
#endif
#ifdef KABI__queue_flag_set_unlocked
queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, queue);
did_something++;
#endif
/* Maybe some day.. But not today.
queue_flag_set_unlocked(QUEUE_FLAG_SECDISCARD, queue);
*/
if (did_something)
td_os_info(dev, "Enabling discard support\n");
else
td_os_notice(dev, "No kernel API for discard support\n");
} else {
td_os_info(dev, "No DISCARD support enabled\n");
}
#else
/* bug 7444 */
if (dev->block_params.discard)
td_os_info(dev, "Device supports DISCARD but is currently being forced disabled\n");
#endif
/* assign */
dev->queue = queue;
return 0;
error_config_queue:
blk_cleanup_queue(dev->queue);
dev->queue = NULL;
error_alloc_queue:
return rc;
}
