target_core_rd.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*******************************************************************************
  3. * Filename: target_core_rd.c
  4. *
  5. * This file contains the Storage Engine <-> Ramdisk transport
  6. * specific functions.
  7. *
  8. * (c) Copyright 2003-2013 Datera, Inc.
  9. *
  10. * Nicholas A. Bellinger <nab@kernel.org>
  11. *
  12. ******************************************************************************/
  13. #include <linux/string.h>
  14. #include <linux/parser.h>
  15. #include <linux/highmem.h>
  16. #include <linux/timer.h>
  17. #include <linux/scatterlist.h>
  18. #include <linux/slab.h>
  19. #include <linux/spinlock.h>
  20. #include <scsi/scsi_proto.h>
  21. #include <target/target_core_base.h>
  22. #include <target/target_core_backend.h>
  23. #include "target_core_rd.h"
  24. static inline struct rd_dev *RD_DEV(struct se_device *dev)
  25. {
  26. return container_of(dev, struct rd_dev, dev);
  27. }
  28. static int rd_attach_hba(struct se_hba *hba, u32 host_id)
  29. {
  30. struct rd_host *rd_host;
  31. rd_host = kzalloc(sizeof(*rd_host), GFP_KERNEL);
  32. if (!rd_host)
  33. return -ENOMEM;
  34. rd_host->rd_host_id = host_id;
  35. hba->hba_ptr = rd_host;
  36. pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on"
  37. " Generic Target Core Stack %s\n", hba->hba_id,
  38. RD_HBA_VERSION, TARGET_CORE_VERSION);
  39. return 0;
  40. }
  41. static void rd_detach_hba(struct se_hba *hba)
  42. {
  43. struct rd_host *rd_host = hba->hba_ptr;
  44. pr_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from"
  45. " Generic Target Core\n", hba->hba_id, rd_host->rd_host_id);
  46. kfree(rd_host);
  47. hba->hba_ptr = NULL;
  48. }
  49. static u32 rd_release_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *sg_table,
  50. u32 sg_table_count)
  51. {
  52. struct page *pg;
  53. struct scatterlist *sg;
  54. u32 i, j, page_count = 0, sg_per_table;
  55. for (i = 0; i < sg_table_count; i++) {
  56. sg = sg_table[i].sg_table;
  57. sg_per_table = sg_table[i].rd_sg_count;
  58. for (j = 0; j < sg_per_table; j++) {
  59. pg = sg_page(&sg[j]);
  60. if (pg) {
  61. __free_page(pg);
  62. page_count++;
  63. }
  64. }
  65. kfree(sg);
  66. }
  67. kfree(sg_table);
  68. return page_count;
  69. }
  70. static void rd_release_device_space(struct rd_dev *rd_dev)
  71. {
  72. u32 page_count;
  73. if (!rd_dev->sg_table_array || !rd_dev->sg_table_count)
  74. return;
  75. page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_table_array,
  76. rd_dev->sg_table_count);
  77. pr_debug("CORE_RD[%u] - Released device space for Ramdisk"
  78. " Device ID: %u, pages %u in %u tables total bytes %lu\n",
  79. rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
  80. rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
  81. rd_dev->sg_table_array = NULL;
  82. rd_dev->sg_table_count = 0;
  83. }
  84. /* rd_build_device_space():
  85. *
  86. *
  87. */
  88. static int rd_allocate_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *sg_table,
  89. u32 total_sg_needed, unsigned char init_payload)
  90. {
  91. u32 i = 0, j, page_offset = 0, sg_per_table;
  92. u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
  93. sizeof(struct scatterlist));
  94. struct page *pg;
  95. struct scatterlist *sg;
  96. unsigned char *p;
  97. while (total_sg_needed) {
  98. unsigned int chain_entry = 0;
  99. sg_per_table = (total_sg_needed > max_sg_per_table) ?
  100. max_sg_per_table : total_sg_needed;
  101. /*
  102. * Reserve extra element for chain entry
  103. */
  104. if (sg_per_table < total_sg_needed)
  105. chain_entry = 1;
  106. sg = kmalloc_array(sg_per_table + chain_entry, sizeof(*sg),
  107. GFP_KERNEL);
  108. if (!sg)
  109. return -ENOMEM;
  110. sg_init_table(sg, sg_per_table + chain_entry);
  111. if (i > 0) {
  112. sg_chain(sg_table[i - 1].sg_table,
  113. max_sg_per_table + 1, sg);
  114. }
  115. sg_table[i].sg_table = sg;
  116. sg_table[i].rd_sg_count = sg_per_table;
  117. sg_table[i].page_start_offset = page_offset;
  118. sg_table[i++].page_end_offset = (page_offset + sg_per_table)
  119. - 1;
  120. for (j = 0; j < sg_per_table; j++) {
  121. pg = alloc_pages(GFP_KERNEL, 0);
  122. if (!pg) {
  123. pr_err("Unable to allocate scatterlist"
  124. " pages for struct rd_dev_sg_table\n");
  125. return -ENOMEM;
  126. }
  127. sg_assign_page(&sg[j], pg);
  128. sg[j].length = PAGE_SIZE;
  129. p = kmap(pg);
  130. memset(p, init_payload, PAGE_SIZE);
  131. kunmap(pg);
  132. }
  133. page_offset += sg_per_table;
  134. total_sg_needed -= sg_per_table;
  135. }
  136. return 0;
  137. }
  138. static int rd_build_device_space(struct rd_dev *rd_dev)
  139. {
  140. struct rd_dev_sg_table *sg_table;
  141. u32 sg_tables, total_sg_needed;
  142. u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
  143. sizeof(struct scatterlist));
  144. int rc;
  145. if (rd_dev->rd_page_count <= 0) {
  146. pr_err("Illegal page count: %u for Ramdisk device\n",
  147. rd_dev->rd_page_count);
  148. return -EINVAL;
  149. }
  150. /* Don't need backing pages for NULLIO */
  151. if (rd_dev->rd_flags & RDF_NULLIO)
  152. return 0;
  153. total_sg_needed = rd_dev->rd_page_count;
  154. sg_tables = (total_sg_needed / max_sg_per_table) + 1;
  155. sg_table = kcalloc(sg_tables, sizeof(*sg_table), GFP_KERNEL);
  156. if (!sg_table)
  157. return -ENOMEM;
  158. rd_dev->sg_table_array = sg_table;
  159. rd_dev->sg_table_count = sg_tables;
  160. rc = rd_allocate_sgl_table(rd_dev, sg_table, total_sg_needed, 0x00);
  161. if (rc)
  162. return rc;
  163. pr_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u space of"
  164. " %u pages in %u tables\n", rd_dev->rd_host->rd_host_id,
  165. rd_dev->rd_dev_id, rd_dev->rd_page_count,
  166. rd_dev->sg_table_count);
  167. return 0;
  168. }
  169. static void rd_release_prot_space(struct rd_dev *rd_dev)
  170. {
  171. u32 page_count;
  172. if (!rd_dev->sg_prot_array || !rd_dev->sg_prot_count)
  173. return;
  174. page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_prot_array,
  175. rd_dev->sg_prot_count);
  176. pr_debug("CORE_RD[%u] - Released protection space for Ramdisk"
  177. " Device ID: %u, pages %u in %u tables total bytes %lu\n",
  178. rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
  179. rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
  180. rd_dev->sg_prot_array = NULL;
  181. rd_dev->sg_prot_count = 0;
  182. }
  183. static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size)
  184. {
  185. struct rd_dev_sg_table *sg_table;
  186. u32 total_sg_needed, sg_tables;
  187. u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
  188. sizeof(struct scatterlist));
  189. int rc;
  190. if (rd_dev->rd_flags & RDF_NULLIO)
  191. return 0;
  192. /*
  193. * prot_length=8byte dif data
  194. * tot sg needed = rd_page_count * (PGSZ/block_size) *
  195. * (prot_length/block_size) + pad
  196. * PGSZ canceled each other.
  197. */
  198. total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1;
  199. sg_tables = (total_sg_needed / max_sg_per_table) + 1;
  200. sg_table = kcalloc(sg_tables, sizeof(*sg_table), GFP_KERNEL);
  201. if (!sg_table)
  202. return -ENOMEM;
  203. rd_dev->sg_prot_array = sg_table;
  204. rd_dev->sg_prot_count = sg_tables;
  205. rc = rd_allocate_sgl_table(rd_dev, sg_table, total_sg_needed, 0xff);
  206. if (rc)
  207. return rc;
  208. pr_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u prot space of"
  209. " %u pages in %u tables\n", rd_dev->rd_host->rd_host_id,
  210. rd_dev->rd_dev_id, total_sg_needed, rd_dev->sg_prot_count);
  211. return 0;
  212. }
  213. static struct se_device *rd_alloc_device(struct se_hba *hba, const char *name)
  214. {
  215. struct rd_dev *rd_dev;
  216. struct rd_host *rd_host = hba->hba_ptr;
  217. rd_dev = kzalloc(sizeof(*rd_dev), GFP_KERNEL);
  218. if (!rd_dev)
  219. return NULL;
  220. rd_dev->rd_host = rd_host;
  221. return &rd_dev->dev;
  222. }
  223. static int rd_configure_device(struct se_device *dev)
  224. {
  225. struct rd_dev *rd_dev = RD_DEV(dev);
  226. struct rd_host *rd_host = dev->se_hba->hba_ptr;
  227. int ret;
  228. if (!(rd_dev->rd_flags & RDF_HAS_PAGE_COUNT)) {
  229. pr_debug("Missing rd_pages= parameter\n");
  230. return -EINVAL;
  231. }
  232. ret = rd_build_device_space(rd_dev);
  233. if (ret < 0)
  234. goto fail;
  235. dev->dev_attrib.hw_block_size = RD_BLOCKSIZE;
  236. dev->dev_attrib.hw_max_sectors = UINT_MAX;
  237. dev->dev_attrib.hw_queue_depth = RD_MAX_DEVICE_QUEUE_DEPTH;
  238. dev->dev_attrib.is_nonrot = 1;
  239. rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++;
  240. pr_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of"
  241. " %u pages in %u tables, %lu total bytes\n",
  242. rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
  243. rd_dev->sg_table_count,
  244. (unsigned long)(rd_dev->rd_page_count * PAGE_SIZE));
  245. return 0;
  246. fail:
  247. rd_release_device_space(rd_dev);
  248. return ret;
  249. }
  250. static void rd_dev_call_rcu(struct rcu_head *p)
  251. {
  252. struct se_device *dev = container_of(p, struct se_device, rcu_head);
  253. struct rd_dev *rd_dev = RD_DEV(dev);
  254. kfree(rd_dev);
  255. }
  256. static void rd_free_device(struct se_device *dev)
  257. {
  258. call_rcu(&dev->rcu_head, rd_dev_call_rcu);
  259. }
  260. static void rd_destroy_device(struct se_device *dev)
  261. {
  262. struct rd_dev *rd_dev = RD_DEV(dev);
  263. rd_release_device_space(rd_dev);
  264. }
  265. static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
  266. {
  267. struct rd_dev_sg_table *sg_table;
  268. u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
  269. sizeof(struct scatterlist));
  270. i = page / sg_per_table;
  271. if (i < rd_dev->sg_table_count) {
  272. sg_table = &rd_dev->sg_table_array[i];
  273. if ((sg_table->page_start_offset <= page) &&
  274. (sg_table->page_end_offset >= page))
  275. return sg_table;
  276. }
  277. pr_err("Unable to locate struct rd_dev_sg_table for page: %u\n",
  278. page);
  279. return NULL;
  280. }
  281. static struct rd_dev_sg_table *rd_get_prot_table(struct rd_dev *rd_dev, u32 page)
  282. {
  283. struct rd_dev_sg_table *sg_table;
  284. u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
  285. sizeof(struct scatterlist));
  286. i = page / sg_per_table;
  287. if (i < rd_dev->sg_prot_count) {
  288. sg_table = &rd_dev->sg_prot_array[i];
  289. if ((sg_table->page_start_offset <= page) &&
  290. (sg_table->page_end_offset >= page))
  291. return sg_table;
  292. }
  293. pr_err("Unable to locate struct prot rd_dev_sg_table for page: %u\n",
  294. page);
  295. return NULL;
  296. }
  297. static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read)
  298. {
  299. struct se_device *se_dev = cmd->se_dev;
  300. struct rd_dev *dev = RD_DEV(se_dev);
  301. struct rd_dev_sg_table *prot_table;
  302. struct scatterlist *prot_sg;
  303. u32 sectors = cmd->data_length / se_dev->dev_attrib.block_size;
  304. u32 prot_offset, prot_page;
  305. u32 prot_npages __maybe_unused;
  306. u64 tmp;
  307. sense_reason_t rc = 0;
  308. tmp = cmd->t_task_lba * se_dev->prot_length;
  309. prot_offset = do_div(tmp, PAGE_SIZE);
  310. prot_page = tmp;
  311. prot_table = rd_get_prot_table(dev, prot_page);
  312. if (!prot_table)
  313. return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  314. prot_sg = &prot_table->sg_table[prot_page -
  315. prot_table->page_start_offset];
  316. if (se_dev->dev_attrib.pi_prot_verify) {
  317. if (is_read)
  318. rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
  319. prot_sg, prot_offset);
  320. else
  321. rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
  322. cmd->t_prot_sg, 0);
  323. }
  324. if (!rc)
  325. sbc_dif_copy_prot(cmd, sectors, is_read, prot_sg, prot_offset);
  326. return rc;
  327. }
  328. static sense_reason_t
  329. rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
  330. enum dma_data_direction data_direction)
  331. {
  332. struct se_device *se_dev = cmd->se_dev;
  333. struct rd_dev *dev = RD_DEV(se_dev);
  334. struct rd_dev_sg_table *table;
  335. struct scatterlist *rd_sg;
  336. struct sg_mapping_iter m;
  337. u32 rd_offset;
  338. u32 rd_size;
  339. u32 rd_page;
  340. u32 src_len;
  341. u64 tmp;
  342. sense_reason_t rc;
  343. if (dev->rd_flags & RDF_NULLIO) {
  344. target_complete_cmd(cmd, SAM_STAT_GOOD);
  345. return 0;
  346. }
  347. tmp = cmd->t_task_lba * se_dev->dev_attrib.block_size;
  348. rd_offset = do_div(tmp, PAGE_SIZE);
  349. rd_page = tmp;
  350. rd_size = cmd->data_length;
  351. table = rd_get_sg_table(dev, rd_page);
  352. if (!table)
  353. return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  354. rd_sg = &table->sg_table[rd_page - table->page_start_offset];
  355. pr_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n",
  356. dev->rd_dev_id,
  357. data_direction == DMA_FROM_DEVICE ? "Read" : "Write",
  358. cmd->t_task_lba, rd_size, rd_page, rd_offset);
  359. if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
  360. data_direction == DMA_TO_DEVICE) {
  361. rc = rd_do_prot_rw(cmd, false);
  362. if (rc)
  363. return rc;
  364. }
  365. src_len = PAGE_SIZE - rd_offset;
  366. sg_miter_start(&m, sgl, sgl_nents,
  367. data_direction == DMA_FROM_DEVICE ?
  368. SG_MITER_TO_SG : SG_MITER_FROM_SG);
  369. while (rd_size) {
  370. u32 len;
  371. void *rd_addr;
  372. sg_miter_next(&m);
  373. if (!(u32)m.length) {
  374. pr_debug("RD[%u]: invalid sgl %p len %zu\n",
  375. dev->rd_dev_id, m.addr, m.length);
  376. sg_miter_stop(&m);
  377. return TCM_INCORRECT_AMOUNT_OF_DATA;
  378. }
  379. len = min((u32)m.length, src_len);
  380. if (len > rd_size) {
  381. pr_debug("RD[%u]: size underrun page %d offset %d "
  382. "size %d\n", dev->rd_dev_id,
  383. rd_page, rd_offset, rd_size);
  384. len = rd_size;
  385. }
  386. m.consumed = len;
  387. rd_addr = sg_virt(rd_sg) + rd_offset;
  388. if (data_direction == DMA_FROM_DEVICE)
  389. memcpy(m.addr, rd_addr, len);
  390. else
  391. memcpy(rd_addr, m.addr, len);
  392. rd_size -= len;
  393. if (!rd_size)
  394. continue;
  395. src_len -= len;
  396. if (src_len) {
  397. rd_offset += len;
  398. continue;
  399. }
  400. /* rd page completed, next one please */
  401. rd_page++;
  402. rd_offset = 0;
  403. src_len = PAGE_SIZE;
  404. if (rd_page <= table->page_end_offset) {
  405. rd_sg++;
  406. continue;
  407. }
  408. table = rd_get_sg_table(dev, rd_page);
  409. if (!table) {
  410. sg_miter_stop(&m);
  411. return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  412. }
  413. /* since we increment, the first sg entry is correct */
  414. rd_sg = table->sg_table;
  415. }
  416. sg_miter_stop(&m);
  417. if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
  418. data_direction == DMA_FROM_DEVICE) {
  419. rc = rd_do_prot_rw(cmd, true);
  420. if (rc)
  421. return rc;
  422. }
  423. target_complete_cmd(cmd, SAM_STAT_GOOD);
  424. return 0;
  425. }
  426. enum {
  427. Opt_rd_pages, Opt_rd_nullio, Opt_err
  428. };
  429. static match_table_t tokens = {
  430. {Opt_rd_pages, "rd_pages=%d"},
  431. {Opt_rd_nullio, "rd_nullio=%d"},
  432. {Opt_err, NULL}
  433. };
  434. static ssize_t rd_set_configfs_dev_params(struct se_device *dev,
  435. const char *page, ssize_t count)
  436. {
  437. struct rd_dev *rd_dev = RD_DEV(dev);
  438. char *orig, *ptr, *opts;
  439. substring_t args[MAX_OPT_ARGS];
  440. int arg, token;
  441. opts = kstrdup(page, GFP_KERNEL);
  442. if (!opts)
  443. return -ENOMEM;
  444. orig = opts;
  445. while ((ptr = strsep(&opts, ",\n")) != NULL) {
  446. if (!*ptr)
  447. continue;
  448. token = match_token(ptr, tokens, args);
  449. switch (token) {
  450. case Opt_rd_pages:
  451. match_int(args, &arg);
  452. rd_dev->rd_page_count = arg;
  453. pr_debug("RAMDISK: Referencing Page"
  454. " Count: %u\n", rd_dev->rd_page_count);
  455. rd_dev->rd_flags |= RDF_HAS_PAGE_COUNT;
  456. break;
  457. case Opt_rd_nullio:
  458. match_int(args, &arg);
  459. if (arg != 1)
  460. break;
  461. pr_debug("RAMDISK: Setting NULLIO flag: %d\n", arg);
  462. rd_dev->rd_flags |= RDF_NULLIO;
  463. break;
  464. default:
  465. break;
  466. }
  467. }
  468. kfree(orig);
  469. return count;
  470. }
  471. static ssize_t rd_show_configfs_dev_params(struct se_device *dev, char *b)
  472. {
  473. struct rd_dev *rd_dev = RD_DEV(dev);
  474. ssize_t bl = sprintf(b, "TCM RamDisk ID: %u RamDisk Makeup: rd_mcp\n",
  475. rd_dev->rd_dev_id);
  476. bl += sprintf(b + bl, " PAGES/PAGE_SIZE: %u*%lu"
  477. " SG_table_count: %u nullio: %d\n", rd_dev->rd_page_count,
  478. PAGE_SIZE, rd_dev->sg_table_count,
  479. !!(rd_dev->rd_flags & RDF_NULLIO));
  480. return bl;
  481. }
  482. static sector_t rd_get_blocks(struct se_device *dev)
  483. {
  484. struct rd_dev *rd_dev = RD_DEV(dev);
  485. unsigned long long blocks_long = ((rd_dev->rd_page_count * PAGE_SIZE) /
  486. dev->dev_attrib.block_size) - 1;
  487. return blocks_long;
  488. }
  489. static int rd_init_prot(struct se_device *dev)
  490. {
  491. struct rd_dev *rd_dev = RD_DEV(dev);
  492. if (!dev->dev_attrib.pi_prot_type)
  493. return 0;
  494. return rd_build_prot_space(rd_dev, dev->prot_length,
  495. dev->dev_attrib.block_size);
  496. }
  497. static void rd_free_prot(struct se_device *dev)
  498. {
  499. struct rd_dev *rd_dev = RD_DEV(dev);
  500. rd_release_prot_space(rd_dev);
  501. }
  502. static struct sbc_ops rd_sbc_ops = {
  503. .execute_rw = rd_execute_rw,
  504. };
  505. static sense_reason_t
  506. rd_parse_cdb(struct se_cmd *cmd)
  507. {
  508. return sbc_parse_cdb(cmd, &rd_sbc_ops);
  509. }
  510. static const struct target_backend_ops rd_mcp_ops = {
  511. .name = "rd_mcp",
  512. .inquiry_prod = "RAMDISK-MCP",
  513. .inquiry_rev = RD_MCP_VERSION,
  514. .attach_hba = rd_attach_hba,
  515. .detach_hba = rd_detach_hba,
  516. .alloc_device = rd_alloc_device,
  517. .configure_device = rd_configure_device,
  518. .destroy_device = rd_destroy_device,
  519. .free_device = rd_free_device,
  520. .parse_cdb = rd_parse_cdb,
  521. .set_configfs_dev_params = rd_set_configfs_dev_params,
  522. .show_configfs_dev_params = rd_show_configfs_dev_params,
  523. .get_device_type = sbc_get_device_type,
  524. .get_blocks = rd_get_blocks,
  525. .init_prot = rd_init_prot,
  526. .free_prot = rd_free_prot,
  527. .tb_dev_attrib_attrs = sbc_attrib_attrs,
  528. };
  529. int __init rd_module_init(void)
  530. {
  531. return transport_backend_register(&rd_mcp_ops);
  532. }
  533. void rd_module_exit(void)
  534. {
  535. target_backend_unregister(&rd_mcp_ops);
  536. }