target_core_rd.c 16.7 KB
Newer Older
1 2 3 4 5 6
/*******************************************************************************
 * Filename:  target_core_rd.c
 *
 * This file contains the Storage Engine <-> Ramdisk transport
 * specific functions.
 *
7
 * (c) Copyright 2003-2013 Datera, Inc.
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *
 * Nicholas A. Bellinger <nab@kernel.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 ******************************************************************************/

#include <linux/string.h>
#include <linux/parser.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
32
#include <scsi/scsi_proto.h>
33 34

#include <target/target_core_base.h>
35
#include <target/target_core_backend.h>
36 37 38

#include "target_core_rd.h"

39 40 41 42
static inline struct rd_dev *RD_DEV(struct se_device *dev)
{
	return container_of(dev, struct rd_dev, dev);
}
43 44 45 46 47 48

static int rd_attach_hba(struct se_hba *hba, u32 host_id)
{
	struct rd_host *rd_host;

	rd_host = kzalloc(sizeof(struct rd_host), GFP_KERNEL);
49 50
	if (!rd_host) {
		pr_err("Unable to allocate memory for struct rd_host\n");
51 52 53 54 55
		return -ENOMEM;
	}

	rd_host->rd_host_id = host_id;

56
	hba->hba_ptr = rd_host;
57

58
	pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on"
59
		" Generic Target Core Stack %s\n", hba->hba_id,
60
		RD_HBA_VERSION, TARGET_CORE_VERSION);
61 62 63 64 65 66 67 68

	return 0;
}

static void rd_detach_hba(struct se_hba *hba)
{
	struct rd_host *rd_host = hba->hba_ptr;

69
	pr_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from"
70 71 72 73 74 75
		" Generic Target Core\n", hba->hba_id, rd_host->rd_host_id);

	kfree(rd_host);
	hba->hba_ptr = NULL;
}

76 77
static u32 rd_release_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *sg_table,
				 u32 sg_table_count)
78 79 80
{
	struct page *pg;
	struct scatterlist *sg;
81
	u32 i, j, page_count = 0, sg_per_table;
82

83
	for (i = 0; i < sg_table_count; i++) {
84 85 86 87 88
		sg = sg_table[i].sg_table;
		sg_per_table = sg_table[i].rd_sg_count;

		for (j = 0; j < sg_per_table; j++) {
			pg = sg_page(&sg[j]);
89
			if (pg) {
90 91 92 93 94 95 96
				__free_page(pg);
				page_count++;
			}
		}
		kfree(sg);
	}

97 98 99 100 101 102 103 104 105 106 107 108 109 110
	kfree(sg_table);
	return page_count;
}

static void rd_release_device_space(struct rd_dev *rd_dev)
{
	u32 page_count;

	if (!rd_dev->sg_table_array || !rd_dev->sg_table_count)
		return;

	page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_table_array,
					  rd_dev->sg_table_count);

111
	pr_debug("CORE_RD[%u] - Released device space for Ramdisk"
112 113 114 115 116 117 118 119 120 121 122 123 124
		" Device ID: %u, pages %u in %u tables total bytes %lu\n",
		rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
		rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);

	rd_dev->sg_table_array = NULL;
	rd_dev->sg_table_count = 0;
}


/*	rd_build_device_space():
 *
 *
 */
125 126
static int rd_allocate_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *sg_table,
				 u32 total_sg_needed, unsigned char init_payload)
127
{
128
	u32 i = 0, j, page_offset = 0, sg_per_table;
129 130 131 132
	u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
				sizeof(struct scatterlist));
	struct page *pg;
	struct scatterlist *sg;
133
	unsigned char *p;
134 135

	while (total_sg_needed) {
136 137
		unsigned int chain_entry = 0;

138 139 140
		sg_per_table = (total_sg_needed > max_sg_per_table) ?
			max_sg_per_table : total_sg_needed;

141 142 143 144 145 146 147
		/*
		 * Reserve extra element for chain entry
		 */
		if (sg_per_table < total_sg_needed)
			chain_entry = 1;

		sg = kcalloc(sg_per_table + chain_entry, sizeof(*sg),
148
				GFP_KERNEL);
149 150
		if (!sg) {
			pr_err("Unable to allocate scatterlist array"
151
				" for struct rd_dev\n");
152
			return -ENOMEM;
153 154
		}

155 156 157 158 159 160 161
		sg_init_table(sg, sg_per_table + chain_entry);

		if (i > 0) {
			sg_chain(sg_table[i - 1].sg_table,
				 max_sg_per_table + 1, sg);
		}

162 163 164 165 166 167 168 169
		sg_table[i].sg_table = sg;
		sg_table[i].rd_sg_count = sg_per_table;
		sg_table[i].page_start_offset = page_offset;
		sg_table[i++].page_end_offset = (page_offset + sg_per_table)
						- 1;

		for (j = 0; j < sg_per_table; j++) {
			pg = alloc_pages(GFP_KERNEL, 0);
170 171
			if (!pg) {
				pr_err("Unable to allocate scatterlist"
172
					" pages for struct rd_dev_sg_table\n");
173
				return -ENOMEM;
174 175 176
			}
			sg_assign_page(&sg[j], pg);
			sg[j].length = PAGE_SIZE;
177 178 179 180

			p = kmap(pg);
			memset(p, init_payload, PAGE_SIZE);
			kunmap(pg);
181 182 183 184 185 186
		}

		page_offset += sg_per_table;
		total_sg_needed -= sg_per_table;
	}

187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
	return 0;
}

static int rd_build_device_space(struct rd_dev *rd_dev)
{
	struct rd_dev_sg_table *sg_table;
	u32 sg_tables, total_sg_needed;
	u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
				sizeof(struct scatterlist));
	int rc;

	if (rd_dev->rd_page_count <= 0) {
		pr_err("Illegal page count: %u for Ramdisk device\n",
		       rd_dev->rd_page_count);
		return -EINVAL;
	}

	/* Don't need backing pages for NULLIO */
	if (rd_dev->rd_flags & RDF_NULLIO)
		return 0;

	total_sg_needed = rd_dev->rd_page_count;

	sg_tables = (total_sg_needed / max_sg_per_table) + 1;

	sg_table = kzalloc(sg_tables * sizeof(struct rd_dev_sg_table), GFP_KERNEL);
	if (!sg_table) {
		pr_err("Unable to allocate memory for Ramdisk"
		       " scatterlist tables\n");
		return -ENOMEM;
	}

	rd_dev->sg_table_array = sg_table;
	rd_dev->sg_table_count = sg_tables;

	rc = rd_allocate_sgl_table(rd_dev, sg_table, total_sg_needed, 0x00);
	if (rc)
		return rc;

226
	pr_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u space of"
227 228 229
		 " %u pages in %u tables\n", rd_dev->rd_host->rd_host_id,
		 rd_dev->rd_dev_id, rd_dev->rd_page_count,
		 rd_dev->sg_table_count);
230 231 232 233

	return 0;
}

234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
static void rd_release_prot_space(struct rd_dev *rd_dev)
{
	u32 page_count;

	if (!rd_dev->sg_prot_array || !rd_dev->sg_prot_count)
		return;

	page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_prot_array,
					  rd_dev->sg_prot_count);

	pr_debug("CORE_RD[%u] - Released protection space for Ramdisk"
		 " Device ID: %u, pages %u in %u tables total bytes %lu\n",
		 rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
		 rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);

	rd_dev->sg_prot_array = NULL;
	rd_dev->sg_prot_count = 0;
}

253
static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size)
254 255 256 257 258 259 260 261 262
{
	struct rd_dev_sg_table *sg_table;
	u32 total_sg_needed, sg_tables;
	u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
				sizeof(struct scatterlist));
	int rc;

	if (rd_dev->rd_flags & RDF_NULLIO)
		return 0;
263 264 265 266 267 268 269
	/*
	 * prot_length=8byte dif data
	 * tot sg needed = rd_page_count * (PGSZ/block_size) *
	 * 		   (prot_length/block_size) + pad
	 * PGSZ canceled each other.
	 */
	total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1;
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293

	sg_tables = (total_sg_needed / max_sg_per_table) + 1;

	sg_table = kzalloc(sg_tables * sizeof(struct rd_dev_sg_table), GFP_KERNEL);
	if (!sg_table) {
		pr_err("Unable to allocate memory for Ramdisk protection"
		       " scatterlist tables\n");
		return -ENOMEM;
	}

	rd_dev->sg_prot_array = sg_table;
	rd_dev->sg_prot_count = sg_tables;

	rc = rd_allocate_sgl_table(rd_dev, sg_table, total_sg_needed, 0xff);
	if (rc)
		return rc;

	pr_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u prot space of"
		 " %u pages in %u tables\n", rd_dev->rd_host->rd_host_id,
		 rd_dev->rd_dev_id, total_sg_needed, rd_dev->sg_prot_count);

	return 0;
}

294
static struct se_device *rd_alloc_device(struct se_hba *hba, const char *name)
295 296 297 298 299
{
	struct rd_dev *rd_dev;
	struct rd_host *rd_host = hba->hba_ptr;

	rd_dev = kzalloc(sizeof(struct rd_dev), GFP_KERNEL);
300 301
	if (!rd_dev) {
		pr_err("Unable to allocate memory for struct rd_dev\n");
302 303 304 305 306
		return NULL;
	}

	rd_dev->rd_host = rd_host;

307
	return &rd_dev->dev;
308 309
}

310
static int rd_configure_device(struct se_device *dev)
311
{
312 313 314
	struct rd_dev *rd_dev = RD_DEV(dev);
	struct rd_host *rd_host = dev->se_hba->hba_ptr;
	int ret;
315

316 317 318 319
	if (!(rd_dev->rd_flags & RDF_HAS_PAGE_COUNT)) {
		pr_debug("Missing rd_pages= parameter\n");
		return -EINVAL;
	}
320

321 322
	ret = rd_build_device_space(rd_dev);
	if (ret < 0)
323 324
		goto fail;

325 326 327
	dev->dev_attrib.hw_block_size = RD_BLOCKSIZE;
	dev->dev_attrib.hw_max_sectors = UINT_MAX;
	dev->dev_attrib.hw_queue_depth = RD_MAX_DEVICE_QUEUE_DEPTH;
328
	dev->dev_attrib.is_nonrot = 1;
329 330 331

	rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++;

332
	pr_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of"
333
		" %u pages in %u tables, %lu total bytes\n",
334
		rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
335 336 337
		rd_dev->sg_table_count,
		(unsigned long)(rd_dev->rd_page_count * PAGE_SIZE));

338
	return 0;
339 340 341

fail:
	rd_release_device_space(rd_dev);
342
	return ret;
343 344
}

345 346 347 348 349 350 351 352
static void rd_dev_call_rcu(struct rcu_head *p)
{
	struct se_device *dev = container_of(p, struct se_device, rcu_head);
	struct rd_dev *rd_dev = RD_DEV(dev);

	kfree(rd_dev);
}

353
static void rd_free_device(struct se_device *dev)
354
{
355
	struct rd_dev *rd_dev = RD_DEV(dev);
356 357

	rd_release_device_space(rd_dev);
358
	call_rcu(&dev->rcu_head, rd_dev_call_rcu);
359 360 361 362 363
}

static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
{
	struct rd_dev_sg_table *sg_table;
364 365
	u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
				sizeof(struct scatterlist));
366

367 368
	i = page / sg_per_table;
	if (i < rd_dev->sg_table_count) {
369 370 371 372 373 374
		sg_table = &rd_dev->sg_table_array[i];
		if ((sg_table->page_start_offset <= page) &&
		    (sg_table->page_end_offset >= page))
			return sg_table;
	}

375
	pr_err("Unable to locate struct rd_dev_sg_table for page: %u\n",
376 377 378 379 380
			page);

	return NULL;
}

381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
static struct rd_dev_sg_table *rd_get_prot_table(struct rd_dev *rd_dev, u32 page)
{
	struct rd_dev_sg_table *sg_table;
	u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
				sizeof(struct scatterlist));

	i = page / sg_per_table;
	if (i < rd_dev->sg_prot_count) {
		sg_table = &rd_dev->sg_prot_array[i];
		if ((sg_table->page_start_offset <= page) &&
		     (sg_table->page_end_offset >= page))
			return sg_table;
	}

	pr_err("Unable to locate struct prot rd_dev_sg_table for page: %u\n",
			page);

	return NULL;
}

401
static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read)
402 403 404 405 406 407 408
{
	struct se_device *se_dev = cmd->se_dev;
	struct rd_dev *dev = RD_DEV(se_dev);
	struct rd_dev_sg_table *prot_table;
	struct scatterlist *prot_sg;
	u32 sectors = cmd->data_length / se_dev->dev_attrib.block_size;
	u32 prot_offset, prot_page;
409
	u32 prot_npages __maybe_unused;
410
	u64 tmp;
411
	sense_reason_t rc = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
412 413 414 415 416 417 418 419 420 421 422 423

	tmp = cmd->t_task_lba * se_dev->prot_length;
	prot_offset = do_div(tmp, PAGE_SIZE);
	prot_page = tmp;

	prot_table = rd_get_prot_table(dev, prot_page);
	if (!prot_table)
		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;

	prot_sg = &prot_table->sg_table[prot_page -
					prot_table->page_start_offset];

424 425 426 427 428 429 430 431 432 433
	if (is_read)
		rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
				    prot_sg, prot_offset);
	else
		rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
				    cmd->t_prot_sg, 0);

	if (!rc)
		sbc_dif_copy_prot(cmd, sectors, is_read, prot_sg, prot_offset);

434 435 436
	return rc;
}

437
static sense_reason_t
438 439
rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
	      enum dma_data_direction data_direction)
440
{
441
	struct se_device *se_dev = cmd->se_dev;
442
	struct rd_dev *dev = RD_DEV(se_dev);
443
	struct rd_dev_sg_table *table;
444 445
	struct scatterlist *rd_sg;
	struct sg_mapping_iter m;
446 447 448
	u32 rd_offset;
	u32 rd_size;
	u32 rd_page;
449
	u32 src_len;
450
	u64 tmp;
451
	sense_reason_t rc;
452

453 454 455 456 457
	if (dev->rd_flags & RDF_NULLIO) {
		target_complete_cmd(cmd, SAM_STAT_GOOD);
		return 0;
	}

458
	tmp = cmd->t_task_lba * se_dev->dev_attrib.block_size;
459 460
	rd_offset = do_div(tmp, PAGE_SIZE);
	rd_page = tmp;
461
	rd_size = cmd->data_length;
462 463

	table = rd_get_sg_table(dev, rd_page);
464
	if (!table)
465
		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
466

467
	rd_sg = &table->sg_table[rd_page - table->page_start_offset];
468

469
	pr_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n",
470
			dev->rd_dev_id,
471 472
			data_direction == DMA_FROM_DEVICE ? "Read" : "Write",
			cmd->t_task_lba, rd_size, rd_page, rd_offset);
473

474 475
	if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
	    data_direction == DMA_TO_DEVICE) {
476
		rc = rd_do_prot_rw(cmd, false);
477 478 479 480
		if (rc)
			return rc;
	}

481
	src_len = PAGE_SIZE - rd_offset;
482 483
	sg_miter_start(&m, sgl, sgl_nents,
			data_direction == DMA_FROM_DEVICE ?
484 485
				SG_MITER_TO_SG : SG_MITER_FROM_SG);
	while (rd_size) {
486 487
		u32 len;
		void *rd_addr;
488

489
		sg_miter_next(&m);
490 491 492 493 494 495
		if (!(u32)m.length) {
			pr_debug("RD[%u]: invalid sgl %p len %zu\n",
				 dev->rd_dev_id, m.addr, m.length);
			sg_miter_stop(&m);
			return TCM_INCORRECT_AMOUNT_OF_DATA;
		}
496
		len = min((u32)m.length, src_len);
497 498 499 500 501 502
		if (len > rd_size) {
			pr_debug("RD[%u]: size underrun page %d offset %d "
				 "size %d\n", dev->rd_dev_id,
				 rd_page, rd_offset, rd_size);
			len = rd_size;
		}
503
		m.consumed = len;
504

505
		rd_addr = sg_virt(rd_sg) + rd_offset;
506

507
		if (data_direction == DMA_FROM_DEVICE)
508 509 510
			memcpy(m.addr, rd_addr, len);
		else
			memcpy(rd_addr, m.addr, len);
511

512 513
		rd_size -= len;
		if (!rd_size)
514 515
			continue;

516 517 518
		src_len -= len;
		if (src_len) {
			rd_offset += len;
519 520
			continue;
		}
521

522
		/* rd page completed, next one please */
523
		rd_page++;
524 525
		rd_offset = 0;
		src_len = PAGE_SIZE;
526
		if (rd_page <= table->page_end_offset) {
527
			rd_sg++;
528 529
			continue;
		}
530

531
		table = rd_get_sg_table(dev, rd_page);
532 533
		if (!table) {
			sg_miter_stop(&m);
534
			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
535
		}
536

537 538
		/* since we increment, the first sg entry is correct */
		rd_sg = table->sg_table;
539
	}
540
	sg_miter_stop(&m);
541

542 543
	if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
	    data_direction == DMA_FROM_DEVICE) {
544
		rc = rd_do_prot_rw(cmd, true);
545 546 547 548
		if (rc)
			return rc;
	}

549
	target_complete_cmd(cmd, SAM_STAT_GOOD);
550
	return 0;
551 552 553
}

enum {
554
	Opt_rd_pages, Opt_rd_nullio, Opt_err
555 556 557 558
};

static match_table_t tokens = {
	{Opt_rd_pages, "rd_pages=%d"},
559
	{Opt_rd_nullio, "rd_nullio=%d"},
560 561 562
	{Opt_err, NULL}
};

563 564
static ssize_t rd_set_configfs_dev_params(struct se_device *dev,
		const char *page, ssize_t count)
565
{
566
	struct rd_dev *rd_dev = RD_DEV(dev);
567 568 569 570 571 572 573 574 575 576
	char *orig, *ptr, *opts;
	substring_t args[MAX_OPT_ARGS];
	int ret = 0, arg, token;

	opts = kstrdup(page, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;

	orig = opts;

577
	while ((ptr = strsep(&opts, ",\n")) != NULL) {
578 579 580 581 582 583 584 585
		if (!*ptr)
			continue;

		token = match_token(ptr, tokens, args);
		switch (token) {
		case Opt_rd_pages:
			match_int(args, &arg);
			rd_dev->rd_page_count = arg;
586
			pr_debug("RAMDISK: Referencing Page"
587 588 589
				" Count: %u\n", rd_dev->rd_page_count);
			rd_dev->rd_flags |= RDF_HAS_PAGE_COUNT;
			break;
590 591 592 593 594 595 596 597
		case Opt_rd_nullio:
			match_int(args, &arg);
			if (arg != 1)
				break;

			pr_debug("RAMDISK: Setting NULLIO flag: %d\n", arg);
			rd_dev->rd_flags |= RDF_NULLIO;
			break;
598 599 600 601 602 603 604 605 606
		default:
			break;
		}
	}

	kfree(orig);
	return (!ret) ? count : ret;
}

607
static ssize_t rd_show_configfs_dev_params(struct se_device *dev, char *b)
608
{
609
	struct rd_dev *rd_dev = RD_DEV(dev);
610

611 612
	ssize_t bl = sprintf(b, "TCM RamDisk ID: %u  RamDisk Makeup: rd_mcp\n",
			rd_dev->rd_dev_id);
613
	bl += sprintf(b + bl, "        PAGES/PAGE_SIZE: %u*%lu"
614 615 616
			"  SG_table_count: %u  nullio: %d\n", rd_dev->rd_page_count,
			PAGE_SIZE, rd_dev->sg_table_count,
			!!(rd_dev->rd_flags & RDF_NULLIO));
617 618 619 620 621
	return bl;
}

static sector_t rd_get_blocks(struct se_device *dev)
{
622 623
	struct rd_dev *rd_dev = RD_DEV(dev);

624
	unsigned long long blocks_long = ((rd_dev->rd_page_count * PAGE_SIZE) /
625
			dev->dev_attrib.block_size) - 1;
626 627 628 629

	return blocks_long;
}

630 631 632 633 634 635 636
static int rd_init_prot(struct se_device *dev)
{
	struct rd_dev *rd_dev = RD_DEV(dev);

        if (!dev->dev_attrib.pi_prot_type)
		return 0;

637 638
	return rd_build_prot_space(rd_dev, dev->prot_length,
				   dev->dev_attrib.block_size);
639 640 641 642 643 644 645 646 647
}

static void rd_free_prot(struct se_device *dev)
{
	struct rd_dev *rd_dev = RD_DEV(dev);

	rd_release_prot_space(rd_dev);
}

648
static struct sbc_ops rd_sbc_ops = {
649 650 651
	.execute_rw		= rd_execute_rw,
};

652 653
static sense_reason_t
rd_parse_cdb(struct se_cmd *cmd)
654
{
655
	return sbc_parse_cdb(cmd, &rd_sbc_ops);
656 657
}

658
static const struct target_backend_ops rd_mcp_ops = {
659
	.name			= "rd_mcp",
660 661
	.inquiry_prod		= "RAMDISK-MCP",
	.inquiry_rev		= RD_MCP_VERSION,
662 663
	.attach_hba		= rd_attach_hba,
	.detach_hba		= rd_detach_hba,
664 665
	.alloc_device		= rd_alloc_device,
	.configure_device	= rd_configure_device,
666
	.free_device		= rd_free_device,
667
	.parse_cdb		= rd_parse_cdb,
668 669
	.set_configfs_dev_params = rd_set_configfs_dev_params,
	.show_configfs_dev_params = rd_show_configfs_dev_params,
670
	.get_device_type	= sbc_get_device_type,
671
	.get_blocks		= rd_get_blocks,
672 673
	.init_prot		= rd_init_prot,
	.free_prot		= rd_free_prot,
674
	.tb_dev_attrib_attrs	= sbc_attrib_attrs,
675 676 677 678
};

int __init rd_module_init(void)
{
679
	return transport_backend_register(&rd_mcp_ops);
680 681 682 683
}

void rd_module_exit(void)
{
684
	target_backend_unregister(&rd_mcp_ops);
685
}