11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2c66ac9dbSNicholas Bellinger /*******************************************************************************
3c66ac9dbSNicholas Bellinger * Filename: target_core_rd.c
4c66ac9dbSNicholas Bellinger *
5c66ac9dbSNicholas Bellinger * This file contains the Storage Engine <-> Ramdisk transport
6c66ac9dbSNicholas Bellinger * specific functions.
7c66ac9dbSNicholas Bellinger *
84c76251eSNicholas Bellinger * (c) Copyright 2003-2013 Datera, Inc.
9c66ac9dbSNicholas Bellinger *
10c66ac9dbSNicholas Bellinger * Nicholas A. Bellinger <nab@kernel.org>
11c66ac9dbSNicholas Bellinger *
12c66ac9dbSNicholas Bellinger ******************************************************************************/
13c66ac9dbSNicholas Bellinger
14c66ac9dbSNicholas Bellinger #include <linux/string.h>
15c66ac9dbSNicholas Bellinger #include <linux/parser.h>
168dcf07beSBart Van Assche #include <linux/highmem.h>
17c66ac9dbSNicholas Bellinger #include <linux/timer.h>
188dcf07beSBart Van Assche #include <linux/scatterlist.h>
19c66ac9dbSNicholas Bellinger #include <linux/slab.h>
20c66ac9dbSNicholas Bellinger #include <linux/spinlock.h>
21ba929992SBart Van Assche #include <scsi/scsi_proto.h>
22c66ac9dbSNicholas Bellinger
23c66ac9dbSNicholas Bellinger #include <target/target_core_base.h>
24c4795fb2SChristoph Hellwig #include <target/target_core_backend.h>
25c66ac9dbSNicholas Bellinger
26c66ac9dbSNicholas Bellinger #include "target_core_rd.h"
27c66ac9dbSNicholas Bellinger
RD_DEV(struct se_device * dev)280fd97ccfSChristoph Hellwig static inline struct rd_dev *RD_DEV(struct se_device *dev)
290fd97ccfSChristoph Hellwig {
300fd97ccfSChristoph Hellwig return container_of(dev, struct rd_dev, dev);
310fd97ccfSChristoph Hellwig }
32c66ac9dbSNicholas Bellinger
rd_attach_hba(struct se_hba * hba,u32 host_id)33c66ac9dbSNicholas Bellinger static int rd_attach_hba(struct se_hba *hba, u32 host_id)
34c66ac9dbSNicholas Bellinger {
35c66ac9dbSNicholas Bellinger struct rd_host *rd_host;
36c66ac9dbSNicholas Bellinger
375d68fb72SMarkus Elfring rd_host = kzalloc(sizeof(*rd_host), GFP_KERNEL);
38fbc4040bSMarkus Elfring if (!rd_host)
39c66ac9dbSNicholas Bellinger return -ENOMEM;
40c66ac9dbSNicholas Bellinger
41c66ac9dbSNicholas Bellinger rd_host->rd_host_id = host_id;
42c66ac9dbSNicholas Bellinger
435951146dSAndy Grover hba->hba_ptr = rd_host;
44c66ac9dbSNicholas Bellinger
456708bb27SAndy Grover pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on"
46c66ac9dbSNicholas Bellinger " Generic Target Core Stack %s\n", hba->hba_id,
47ce8dd25dSChristoph Hellwig RD_HBA_VERSION, TARGET_CORE_VERSION);
48c66ac9dbSNicholas Bellinger
49c66ac9dbSNicholas Bellinger return 0;
50c66ac9dbSNicholas Bellinger }
51c66ac9dbSNicholas Bellinger
rd_detach_hba(struct se_hba * hba)52c66ac9dbSNicholas Bellinger static void rd_detach_hba(struct se_hba *hba)
53c66ac9dbSNicholas Bellinger {
54c66ac9dbSNicholas Bellinger struct rd_host *rd_host = hba->hba_ptr;
55c66ac9dbSNicholas Bellinger
566708bb27SAndy Grover pr_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from"
57c66ac9dbSNicholas Bellinger " Generic Target Core\n", hba->hba_id, rd_host->rd_host_id);
58c66ac9dbSNicholas Bellinger
59c66ac9dbSNicholas Bellinger kfree(rd_host);
60c66ac9dbSNicholas Bellinger hba->hba_ptr = NULL;
61c66ac9dbSNicholas Bellinger }
62c66ac9dbSNicholas Bellinger
rd_release_sgl_table(struct rd_dev * rd_dev,struct rd_dev_sg_table * sg_table,u32 sg_table_count)634442dc8aSNicholas Bellinger static u32 rd_release_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *sg_table,
644442dc8aSNicholas Bellinger u32 sg_table_count)
65c66ac9dbSNicholas Bellinger {
66c66ac9dbSNicholas Bellinger struct page *pg;
67c66ac9dbSNicholas Bellinger struct scatterlist *sg;
684442dc8aSNicholas Bellinger u32 i, j, page_count = 0, sg_per_table;
69c66ac9dbSNicholas Bellinger
704442dc8aSNicholas Bellinger for (i = 0; i < sg_table_count; i++) {
71c66ac9dbSNicholas Bellinger sg = sg_table[i].sg_table;
72c66ac9dbSNicholas Bellinger sg_per_table = sg_table[i].rd_sg_count;
73c66ac9dbSNicholas Bellinger
74c66ac9dbSNicholas Bellinger for (j = 0; j < sg_per_table; j++) {
75c66ac9dbSNicholas Bellinger pg = sg_page(&sg[j]);
766708bb27SAndy Grover if (pg) {
77c66ac9dbSNicholas Bellinger __free_page(pg);
78c66ac9dbSNicholas Bellinger page_count++;
79c66ac9dbSNicholas Bellinger }
80c66ac9dbSNicholas Bellinger }
81c66ac9dbSNicholas Bellinger kfree(sg);
82c66ac9dbSNicholas Bellinger }
83c66ac9dbSNicholas Bellinger
844442dc8aSNicholas Bellinger kfree(sg_table);
854442dc8aSNicholas Bellinger return page_count;
864442dc8aSNicholas Bellinger }
874442dc8aSNicholas Bellinger
rd_release_device_space(struct rd_dev * rd_dev)884442dc8aSNicholas Bellinger static void rd_release_device_space(struct rd_dev *rd_dev)
894442dc8aSNicholas Bellinger {
904442dc8aSNicholas Bellinger u32 page_count;
914442dc8aSNicholas Bellinger
924442dc8aSNicholas Bellinger if (!rd_dev->sg_table_array || !rd_dev->sg_table_count)
934442dc8aSNicholas Bellinger return;
944442dc8aSNicholas Bellinger
954442dc8aSNicholas Bellinger page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_table_array,
964442dc8aSNicholas Bellinger rd_dev->sg_table_count);
974442dc8aSNicholas Bellinger
986708bb27SAndy Grover pr_debug("CORE_RD[%u] - Released device space for Ramdisk"
99c66ac9dbSNicholas Bellinger " Device ID: %u, pages %u in %u tables total bytes %lu\n",
100c66ac9dbSNicholas Bellinger rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
101c66ac9dbSNicholas Bellinger rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
102c66ac9dbSNicholas Bellinger
103c66ac9dbSNicholas Bellinger rd_dev->sg_table_array = NULL;
104c66ac9dbSNicholas Bellinger rd_dev->sg_table_count = 0;
105c66ac9dbSNicholas Bellinger }
106c66ac9dbSNicholas Bellinger
107c66ac9dbSNicholas Bellinger
108c66ac9dbSNicholas Bellinger /* rd_build_device_space():
109c66ac9dbSNicholas Bellinger *
110c66ac9dbSNicholas Bellinger *
111c66ac9dbSNicholas Bellinger */
rd_allocate_sgl_table(struct rd_dev * rd_dev,struct rd_dev_sg_table * sg_table,u32 total_sg_needed,unsigned char init_payload)1124442dc8aSNicholas Bellinger static int rd_allocate_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *sg_table,
1134442dc8aSNicholas Bellinger u32 total_sg_needed, unsigned char init_payload)
114c66ac9dbSNicholas Bellinger {
1154442dc8aSNicholas Bellinger u32 i = 0, j, page_offset = 0, sg_per_table;
116c66ac9dbSNicholas Bellinger u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
117c66ac9dbSNicholas Bellinger sizeof(struct scatterlist));
118c66ac9dbSNicholas Bellinger struct page *pg;
119c66ac9dbSNicholas Bellinger struct scatterlist *sg;
1204442dc8aSNicholas Bellinger unsigned char *p;
121c66ac9dbSNicholas Bellinger
122c66ac9dbSNicholas Bellinger while (total_sg_needed) {
123bfd9a53eSAkinobu Mita unsigned int chain_entry = 0;
124bfd9a53eSAkinobu Mita
125c66ac9dbSNicholas Bellinger sg_per_table = (total_sg_needed > max_sg_per_table) ?
126c66ac9dbSNicholas Bellinger max_sg_per_table : total_sg_needed;
127c66ac9dbSNicholas Bellinger
128bfd9a53eSAkinobu Mita /*
129bfd9a53eSAkinobu Mita * Reserve extra element for chain entry
130bfd9a53eSAkinobu Mita */
131bfd9a53eSAkinobu Mita if (sg_per_table < total_sg_needed)
132bfd9a53eSAkinobu Mita chain_entry = 1;
133bfd9a53eSAkinobu Mita
1344b217e01SJulia Lawall sg = kmalloc_array(sg_per_table + chain_entry, sizeof(*sg),
135c66ac9dbSNicholas Bellinger GFP_KERNEL);
136fbc4040bSMarkus Elfring if (!sg)
137065f9716SDan Carpenter return -ENOMEM;
138c66ac9dbSNicholas Bellinger
139bfd9a53eSAkinobu Mita sg_init_table(sg, sg_per_table + chain_entry);
140bfd9a53eSAkinobu Mita
141bfd9a53eSAkinobu Mita if (i > 0) {
142bfd9a53eSAkinobu Mita sg_chain(sg_table[i - 1].sg_table,
143bfd9a53eSAkinobu Mita max_sg_per_table + 1, sg);
144bfd9a53eSAkinobu Mita }
145bfd9a53eSAkinobu Mita
146c66ac9dbSNicholas Bellinger sg_table[i].sg_table = sg;
147c66ac9dbSNicholas Bellinger sg_table[i].rd_sg_count = sg_per_table;
148c66ac9dbSNicholas Bellinger sg_table[i].page_start_offset = page_offset;
149c66ac9dbSNicholas Bellinger sg_table[i++].page_end_offset = (page_offset + sg_per_table)
150c66ac9dbSNicholas Bellinger - 1;
151c66ac9dbSNicholas Bellinger
152c66ac9dbSNicholas Bellinger for (j = 0; j < sg_per_table; j++) {
153c66ac9dbSNicholas Bellinger pg = alloc_pages(GFP_KERNEL, 0);
1546708bb27SAndy Grover if (!pg) {
1556708bb27SAndy Grover pr_err("Unable to allocate scatterlist"
156c66ac9dbSNicholas Bellinger " pages for struct rd_dev_sg_table\n");
157065f9716SDan Carpenter return -ENOMEM;
158c66ac9dbSNicholas Bellinger }
159c66ac9dbSNicholas Bellinger sg_assign_page(&sg[j], pg);
160c66ac9dbSNicholas Bellinger sg[j].length = PAGE_SIZE;
1614442dc8aSNicholas Bellinger
1624442dc8aSNicholas Bellinger p = kmap(pg);
1634442dc8aSNicholas Bellinger memset(p, init_payload, PAGE_SIZE);
1644442dc8aSNicholas Bellinger kunmap(pg);
165c66ac9dbSNicholas Bellinger }
166c66ac9dbSNicholas Bellinger
167c66ac9dbSNicholas Bellinger page_offset += sg_per_table;
168c66ac9dbSNicholas Bellinger total_sg_needed -= sg_per_table;
169c66ac9dbSNicholas Bellinger }
170c66ac9dbSNicholas Bellinger
1714442dc8aSNicholas Bellinger return 0;
1724442dc8aSNicholas Bellinger }
1734442dc8aSNicholas Bellinger
rd_build_device_space(struct rd_dev * rd_dev)1744442dc8aSNicholas Bellinger static int rd_build_device_space(struct rd_dev *rd_dev)
1754442dc8aSNicholas Bellinger {
1764442dc8aSNicholas Bellinger struct rd_dev_sg_table *sg_table;
1774442dc8aSNicholas Bellinger u32 sg_tables, total_sg_needed;
1784442dc8aSNicholas Bellinger u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
1794442dc8aSNicholas Bellinger sizeof(struct scatterlist));
1804442dc8aSNicholas Bellinger int rc;
1814442dc8aSNicholas Bellinger
1824442dc8aSNicholas Bellinger if (rd_dev->rd_page_count <= 0) {
1834442dc8aSNicholas Bellinger pr_err("Illegal page count: %u for Ramdisk device\n",
1844442dc8aSNicholas Bellinger rd_dev->rd_page_count);
1854442dc8aSNicholas Bellinger return -EINVAL;
1864442dc8aSNicholas Bellinger }
1874442dc8aSNicholas Bellinger
1884442dc8aSNicholas Bellinger /* Don't need backing pages for NULLIO */
1894442dc8aSNicholas Bellinger if (rd_dev->rd_flags & RDF_NULLIO)
1904442dc8aSNicholas Bellinger return 0;
1914442dc8aSNicholas Bellinger
1924442dc8aSNicholas Bellinger total_sg_needed = rd_dev->rd_page_count;
1934442dc8aSNicholas Bellinger
1944442dc8aSNicholas Bellinger sg_tables = (total_sg_needed / max_sg_per_table) + 1;
19555ec4092SMarkus Elfring sg_table = kcalloc(sg_tables, sizeof(*sg_table), GFP_KERNEL);
196fbc4040bSMarkus Elfring if (!sg_table)
1974442dc8aSNicholas Bellinger return -ENOMEM;
1984442dc8aSNicholas Bellinger
1994442dc8aSNicholas Bellinger rd_dev->sg_table_array = sg_table;
2004442dc8aSNicholas Bellinger rd_dev->sg_table_count = sg_tables;
2014442dc8aSNicholas Bellinger
2024442dc8aSNicholas Bellinger rc = rd_allocate_sgl_table(rd_dev, sg_table, total_sg_needed, 0x00);
2034442dc8aSNicholas Bellinger if (rc)
2044442dc8aSNicholas Bellinger return rc;
2054442dc8aSNicholas Bellinger
2066708bb27SAndy Grover pr_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u space of"
207c66ac9dbSNicholas Bellinger " %u pages in %u tables\n", rd_dev->rd_host->rd_host_id,
208c66ac9dbSNicholas Bellinger rd_dev->rd_dev_id, rd_dev->rd_page_count,
209c66ac9dbSNicholas Bellinger rd_dev->sg_table_count);
210c66ac9dbSNicholas Bellinger
211c66ac9dbSNicholas Bellinger return 0;
212c66ac9dbSNicholas Bellinger }
213c66ac9dbSNicholas Bellinger
rd_release_prot_space(struct rd_dev * rd_dev)214d7e8eb5dSNicholas Bellinger static void rd_release_prot_space(struct rd_dev *rd_dev)
215d7e8eb5dSNicholas Bellinger {
216d7e8eb5dSNicholas Bellinger u32 page_count;
217d7e8eb5dSNicholas Bellinger
218d7e8eb5dSNicholas Bellinger if (!rd_dev->sg_prot_array || !rd_dev->sg_prot_count)
219d7e8eb5dSNicholas Bellinger return;
220d7e8eb5dSNicholas Bellinger
221d7e8eb5dSNicholas Bellinger page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_prot_array,
222d7e8eb5dSNicholas Bellinger rd_dev->sg_prot_count);
223d7e8eb5dSNicholas Bellinger
224d7e8eb5dSNicholas Bellinger pr_debug("CORE_RD[%u] - Released protection space for Ramdisk"
225d7e8eb5dSNicholas Bellinger " Device ID: %u, pages %u in %u tables total bytes %lu\n",
226d7e8eb5dSNicholas Bellinger rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
227d7e8eb5dSNicholas Bellinger rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
228d7e8eb5dSNicholas Bellinger
229d7e8eb5dSNicholas Bellinger rd_dev->sg_prot_array = NULL;
230d7e8eb5dSNicholas Bellinger rd_dev->sg_prot_count = 0;
231d7e8eb5dSNicholas Bellinger }
232d7e8eb5dSNicholas Bellinger
rd_build_prot_space(struct rd_dev * rd_dev,int prot_length,int block_size)2339d2e59f2SQuinn Tran static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size)
234d7e8eb5dSNicholas Bellinger {
235d7e8eb5dSNicholas Bellinger struct rd_dev_sg_table *sg_table;
236d7e8eb5dSNicholas Bellinger u32 total_sg_needed, sg_tables;
237d7e8eb5dSNicholas Bellinger u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
238d7e8eb5dSNicholas Bellinger sizeof(struct scatterlist));
239d7e8eb5dSNicholas Bellinger int rc;
240d7e8eb5dSNicholas Bellinger
241d7e8eb5dSNicholas Bellinger if (rd_dev->rd_flags & RDF_NULLIO)
242d7e8eb5dSNicholas Bellinger return 0;
2439d2e59f2SQuinn Tran /*
2449d2e59f2SQuinn Tran * prot_length=8byte dif data
2459d2e59f2SQuinn Tran * tot sg needed = rd_page_count * (PGSZ/block_size) *
2469d2e59f2SQuinn Tran * (prot_length/block_size) + pad
2479d2e59f2SQuinn Tran * PGSZ canceled each other.
2489d2e59f2SQuinn Tran */
2499d2e59f2SQuinn Tran total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1;
250d7e8eb5dSNicholas Bellinger
251d7e8eb5dSNicholas Bellinger sg_tables = (total_sg_needed / max_sg_per_table) + 1;
25255ec4092SMarkus Elfring sg_table = kcalloc(sg_tables, sizeof(*sg_table), GFP_KERNEL);
253fbc4040bSMarkus Elfring if (!sg_table)
254d7e8eb5dSNicholas Bellinger return -ENOMEM;
255d7e8eb5dSNicholas Bellinger
256d7e8eb5dSNicholas Bellinger rd_dev->sg_prot_array = sg_table;
257d7e8eb5dSNicholas Bellinger rd_dev->sg_prot_count = sg_tables;
258d7e8eb5dSNicholas Bellinger
259d7e8eb5dSNicholas Bellinger rc = rd_allocate_sgl_table(rd_dev, sg_table, total_sg_needed, 0xff);
260d7e8eb5dSNicholas Bellinger if (rc)
261d7e8eb5dSNicholas Bellinger return rc;
262d7e8eb5dSNicholas Bellinger
263d7e8eb5dSNicholas Bellinger pr_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u prot space of"
264d7e8eb5dSNicholas Bellinger " %u pages in %u tables\n", rd_dev->rd_host->rd_host_id,
265d7e8eb5dSNicholas Bellinger rd_dev->rd_dev_id, total_sg_needed, rd_dev->sg_prot_count);
266d7e8eb5dSNicholas Bellinger
267d7e8eb5dSNicholas Bellinger return 0;
268d7e8eb5dSNicholas Bellinger }
269d7e8eb5dSNicholas Bellinger
rd_alloc_device(struct se_hba * hba,const char * name)2700fd97ccfSChristoph Hellwig static struct se_device *rd_alloc_device(struct se_hba *hba, const char *name)
271c66ac9dbSNicholas Bellinger {
272c66ac9dbSNicholas Bellinger struct rd_dev *rd_dev;
273c66ac9dbSNicholas Bellinger struct rd_host *rd_host = hba->hba_ptr;
274c66ac9dbSNicholas Bellinger
2755d68fb72SMarkus Elfring rd_dev = kzalloc(sizeof(*rd_dev), GFP_KERNEL);
276fbc4040bSMarkus Elfring if (!rd_dev)
277c66ac9dbSNicholas Bellinger return NULL;
278c66ac9dbSNicholas Bellinger
279c66ac9dbSNicholas Bellinger rd_dev->rd_host = rd_host;
280c66ac9dbSNicholas Bellinger
2810fd97ccfSChristoph Hellwig return &rd_dev->dev;
282c66ac9dbSNicholas Bellinger }
283c66ac9dbSNicholas Bellinger
rd_configure_device(struct se_device * dev)2840fd97ccfSChristoph Hellwig static int rd_configure_device(struct se_device *dev)
285c66ac9dbSNicholas Bellinger {
2860fd97ccfSChristoph Hellwig struct rd_dev *rd_dev = RD_DEV(dev);
2870fd97ccfSChristoph Hellwig struct rd_host *rd_host = dev->se_hba->hba_ptr;
2880fd97ccfSChristoph Hellwig int ret;
289c66ac9dbSNicholas Bellinger
2900fd97ccfSChristoph Hellwig if (!(rd_dev->rd_flags & RDF_HAS_PAGE_COUNT)) {
2910fd97ccfSChristoph Hellwig pr_debug("Missing rd_pages= parameter\n");
2920fd97ccfSChristoph Hellwig return -EINVAL;
2930fd97ccfSChristoph Hellwig }
294c66ac9dbSNicholas Bellinger
295065f9716SDan Carpenter ret = rd_build_device_space(rd_dev);
296065f9716SDan Carpenter if (ret < 0)
297c66ac9dbSNicholas Bellinger goto fail;
298c66ac9dbSNicholas Bellinger
2990fd97ccfSChristoph Hellwig dev->dev_attrib.hw_block_size = RD_BLOCKSIZE;
3000fd97ccfSChristoph Hellwig dev->dev_attrib.hw_max_sectors = UINT_MAX;
3010fd97ccfSChristoph Hellwig dev->dev_attrib.hw_queue_depth = RD_MAX_DEVICE_QUEUE_DEPTH;
3025dacbfc9SSagi Grimberg dev->dev_attrib.is_nonrot = 1;
303c66ac9dbSNicholas Bellinger
304c66ac9dbSNicholas Bellinger rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++;
305c66ac9dbSNicholas Bellinger
3068feb58d0SChristoph Hellwig pr_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of"
307c66ac9dbSNicholas Bellinger " %u pages in %u tables, %lu total bytes\n",
3088feb58d0SChristoph Hellwig rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
309c66ac9dbSNicholas Bellinger rd_dev->sg_table_count,
310c66ac9dbSNicholas Bellinger (unsigned long)(rd_dev->rd_page_count * PAGE_SIZE));
311c66ac9dbSNicholas Bellinger
3120fd97ccfSChristoph Hellwig return 0;
313c66ac9dbSNicholas Bellinger
314c66ac9dbSNicholas Bellinger fail:
315c66ac9dbSNicholas Bellinger rd_release_device_space(rd_dev);
3160fd97ccfSChristoph Hellwig return ret;
317c66ac9dbSNicholas Bellinger }
318c66ac9dbSNicholas Bellinger
rd_dev_call_rcu(struct rcu_head * p)3194cc987eaSNicholas Bellinger static void rd_dev_call_rcu(struct rcu_head *p)
3204cc987eaSNicholas Bellinger {
3214cc987eaSNicholas Bellinger struct se_device *dev = container_of(p, struct se_device, rcu_head);
3224cc987eaSNicholas Bellinger struct rd_dev *rd_dev = RD_DEV(dev);
3234cc987eaSNicholas Bellinger
3244cc987eaSNicholas Bellinger kfree(rd_dev);
3254cc987eaSNicholas Bellinger }
3264cc987eaSNicholas Bellinger
rd_free_device(struct se_device * dev)3270fd97ccfSChristoph Hellwig static void rd_free_device(struct se_device *dev)
328c66ac9dbSNicholas Bellinger {
32992634706SMike Christie call_rcu(&dev->rcu_head, rd_dev_call_rcu);
33092634706SMike Christie }
33192634706SMike Christie
rd_destroy_device(struct se_device * dev)33292634706SMike Christie static void rd_destroy_device(struct se_device *dev)
33392634706SMike Christie {
3340fd97ccfSChristoph Hellwig struct rd_dev *rd_dev = RD_DEV(dev);
335c66ac9dbSNicholas Bellinger
336c66ac9dbSNicholas Bellinger rd_release_device_space(rd_dev);
337c66ac9dbSNicholas Bellinger }
338c66ac9dbSNicholas Bellinger
rd_get_sg_table(struct rd_dev * rd_dev,u32 page)339c66ac9dbSNicholas Bellinger static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
340c66ac9dbSNicholas Bellinger {
341c66ac9dbSNicholas Bellinger struct rd_dev_sg_table *sg_table;
3428f67835fSMartin Svec u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
3438f67835fSMartin Svec sizeof(struct scatterlist));
344c66ac9dbSNicholas Bellinger
3458f67835fSMartin Svec i = page / sg_per_table;
3468f67835fSMartin Svec if (i < rd_dev->sg_table_count) {
347c66ac9dbSNicholas Bellinger sg_table = &rd_dev->sg_table_array[i];
348c66ac9dbSNicholas Bellinger if ((sg_table->page_start_offset <= page) &&
349c66ac9dbSNicholas Bellinger (sg_table->page_end_offset >= page))
350c66ac9dbSNicholas Bellinger return sg_table;
351c66ac9dbSNicholas Bellinger }
352c66ac9dbSNicholas Bellinger
3536708bb27SAndy Grover pr_err("Unable to locate struct rd_dev_sg_table for page: %u\n",
354c66ac9dbSNicholas Bellinger page);
355c66ac9dbSNicholas Bellinger
356c66ac9dbSNicholas Bellinger return NULL;
357c66ac9dbSNicholas Bellinger }
358c66ac9dbSNicholas Bellinger
rd_get_prot_table(struct rd_dev * rd_dev,u32 page)3596e611119SNicholas Bellinger static struct rd_dev_sg_table *rd_get_prot_table(struct rd_dev *rd_dev, u32 page)
3606e611119SNicholas Bellinger {
3616e611119SNicholas Bellinger struct rd_dev_sg_table *sg_table;
3626e611119SNicholas Bellinger u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
3636e611119SNicholas Bellinger sizeof(struct scatterlist));
3646e611119SNicholas Bellinger
3656e611119SNicholas Bellinger i = page / sg_per_table;
3666e611119SNicholas Bellinger if (i < rd_dev->sg_prot_count) {
3676e611119SNicholas Bellinger sg_table = &rd_dev->sg_prot_array[i];
3686e611119SNicholas Bellinger if ((sg_table->page_start_offset <= page) &&
3696e611119SNicholas Bellinger (sg_table->page_end_offset >= page))
3706e611119SNicholas Bellinger return sg_table;
3716e611119SNicholas Bellinger }
3726e611119SNicholas Bellinger
3736e611119SNicholas Bellinger pr_err("Unable to locate struct prot rd_dev_sg_table for page: %u\n",
3746e611119SNicholas Bellinger page);
3756e611119SNicholas Bellinger
3766e611119SNicholas Bellinger return NULL;
3776e611119SNicholas Bellinger }
3786e611119SNicholas Bellinger
rd_do_prot_rw(struct se_cmd * cmd,bool is_read)379f75b6faeSSagi Grimberg static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read)
3806766cc81SAkinobu Mita {
3816766cc81SAkinobu Mita struct se_device *se_dev = cmd->se_dev;
3826766cc81SAkinobu Mita struct rd_dev *dev = RD_DEV(se_dev);
3836766cc81SAkinobu Mita struct rd_dev_sg_table *prot_table;
3846766cc81SAkinobu Mita struct scatterlist *prot_sg;
3856766cc81SAkinobu Mita u32 sectors = cmd->data_length / se_dev->dev_attrib.block_size;
3866766cc81SAkinobu Mita u32 prot_offset, prot_page;
387bfd9a53eSAkinobu Mita u32 prot_npages __maybe_unused;
3886766cc81SAkinobu Mita u64 tmp;
389056e8924SDmitry Monakhov sense_reason_t rc = 0;
3906766cc81SAkinobu Mita
3916766cc81SAkinobu Mita tmp = cmd->t_task_lba * se_dev->prot_length;
3926766cc81SAkinobu Mita prot_offset = do_div(tmp, PAGE_SIZE);
3936766cc81SAkinobu Mita prot_page = tmp;
3946766cc81SAkinobu Mita
3956766cc81SAkinobu Mita prot_table = rd_get_prot_table(dev, prot_page);
3966766cc81SAkinobu Mita if (!prot_table)
3976766cc81SAkinobu Mita return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
3986766cc81SAkinobu Mita
3996766cc81SAkinobu Mita prot_sg = &prot_table->sg_table[prot_page -
4006766cc81SAkinobu Mita prot_table->page_start_offset];
4016766cc81SAkinobu Mita
402056e8924SDmitry Monakhov if (se_dev->dev_attrib.pi_prot_verify) {
403f75b6faeSSagi Grimberg if (is_read)
404f75b6faeSSagi Grimberg rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
405f75b6faeSSagi Grimberg prot_sg, prot_offset);
406f75b6faeSSagi Grimberg else
407f75b6faeSSagi Grimberg rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
408f75b6faeSSagi Grimberg cmd->t_prot_sg, 0);
409056e8924SDmitry Monakhov }
410f75b6faeSSagi Grimberg if (!rc)
411f75b6faeSSagi Grimberg sbc_dif_copy_prot(cmd, sectors, is_read, prot_sg, prot_offset);
412f75b6faeSSagi Grimberg
4136766cc81SAkinobu Mita return rc;
4146766cc81SAkinobu Mita }
4156766cc81SAkinobu Mita
416de103c93SChristoph Hellwig static sense_reason_t
rd_execute_rw(struct se_cmd * cmd,struct scatterlist * sgl,u32 sgl_nents,enum dma_data_direction data_direction)417a82a9538SNicholas Bellinger rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
418a82a9538SNicholas Bellinger enum dma_data_direction data_direction)
419c66ac9dbSNicholas Bellinger {
4205787cacdSChristoph Hellwig struct se_device *se_dev = cmd->se_dev;
4210fd97ccfSChristoph Hellwig struct rd_dev *dev = RD_DEV(se_dev);
422c66ac9dbSNicholas Bellinger struct rd_dev_sg_table *table;
42365b0c78dSSebastian Andrzej Siewior struct scatterlist *rd_sg;
42465b0c78dSSebastian Andrzej Siewior struct sg_mapping_iter m;
4258feb58d0SChristoph Hellwig u32 rd_offset;
4268feb58d0SChristoph Hellwig u32 rd_size;
4278feb58d0SChristoph Hellwig u32 rd_page;
42865b0c78dSSebastian Andrzej Siewior u32 src_len;
4298feb58d0SChristoph Hellwig u64 tmp;
4306e611119SNicholas Bellinger sense_reason_t rc;
431c66ac9dbSNicholas Bellinger
43252c07423SNicholas Bellinger if (dev->rd_flags & RDF_NULLIO) {
43352c07423SNicholas Bellinger target_complete_cmd(cmd, SAM_STAT_GOOD);
43452c07423SNicholas Bellinger return 0;
43552c07423SNicholas Bellinger }
43652c07423SNicholas Bellinger
4370fd97ccfSChristoph Hellwig tmp = cmd->t_task_lba * se_dev->dev_attrib.block_size;
4388feb58d0SChristoph Hellwig rd_offset = do_div(tmp, PAGE_SIZE);
4398feb58d0SChristoph Hellwig rd_page = tmp;
4405787cacdSChristoph Hellwig rd_size = cmd->data_length;
4418feb58d0SChristoph Hellwig
4428feb58d0SChristoph Hellwig table = rd_get_sg_table(dev, rd_page);
4436708bb27SAndy Grover if (!table)
444de103c93SChristoph Hellwig return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
445c66ac9dbSNicholas Bellinger
4468feb58d0SChristoph Hellwig rd_sg = &table->sg_table[rd_page - table->page_start_offset];
4476708bb27SAndy Grover
44865b0c78dSSebastian Andrzej Siewior pr_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n",
4498feb58d0SChristoph Hellwig dev->rd_dev_id,
4505787cacdSChristoph Hellwig data_direction == DMA_FROM_DEVICE ? "Read" : "Write",
4515787cacdSChristoph Hellwig cmd->t_task_lba, rd_size, rd_page, rd_offset);
4526708bb27SAndy Grover
4531762742fSNicholas Bellinger if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
4541762742fSNicholas Bellinger data_direction == DMA_TO_DEVICE) {
455f75b6faeSSagi Grimberg rc = rd_do_prot_rw(cmd, false);
4566e611119SNicholas Bellinger if (rc)
4576e611119SNicholas Bellinger return rc;
4586e611119SNicholas Bellinger }
4596e611119SNicholas Bellinger
46065b0c78dSSebastian Andrzej Siewior src_len = PAGE_SIZE - rd_offset;
4615787cacdSChristoph Hellwig sg_miter_start(&m, sgl, sgl_nents,
4625787cacdSChristoph Hellwig data_direction == DMA_FROM_DEVICE ?
4638feb58d0SChristoph Hellwig SG_MITER_TO_SG : SG_MITER_FROM_SG);
4648feb58d0SChristoph Hellwig while (rd_size) {
46565b0c78dSSebastian Andrzej Siewior u32 len;
46665b0c78dSSebastian Andrzej Siewior void *rd_addr;
4676708bb27SAndy Grover
46865b0c78dSSebastian Andrzej Siewior sg_miter_next(&m);
469bbf344e5SHannes Reinecke if (!(u32)m.length) {
470bbf344e5SHannes Reinecke pr_debug("RD[%u]: invalid sgl %p len %zu\n",
471bbf344e5SHannes Reinecke dev->rd_dev_id, m.addr, m.length);
472bbf344e5SHannes Reinecke sg_miter_stop(&m);
473bbf344e5SHannes Reinecke return TCM_INCORRECT_AMOUNT_OF_DATA;
474bbf344e5SHannes Reinecke }
47565b0c78dSSebastian Andrzej Siewior len = min((u32)m.length, src_len);
476bbf344e5SHannes Reinecke if (len > rd_size) {
477bbf344e5SHannes Reinecke pr_debug("RD[%u]: size underrun page %d offset %d "
478bbf344e5SHannes Reinecke "size %d\n", dev->rd_dev_id,
479bbf344e5SHannes Reinecke rd_page, rd_offset, rd_size);
480bbf344e5SHannes Reinecke len = rd_size;
481bbf344e5SHannes Reinecke }
48265b0c78dSSebastian Andrzej Siewior m.consumed = len;
4836708bb27SAndy Grover
48465b0c78dSSebastian Andrzej Siewior rd_addr = sg_virt(rd_sg) + rd_offset;
485c66ac9dbSNicholas Bellinger
4865787cacdSChristoph Hellwig if (data_direction == DMA_FROM_DEVICE)
48765b0c78dSSebastian Andrzej Siewior memcpy(m.addr, rd_addr, len);
48865b0c78dSSebastian Andrzej Siewior else
48965b0c78dSSebastian Andrzej Siewior memcpy(rd_addr, m.addr, len);
490c66ac9dbSNicholas Bellinger
4918feb58d0SChristoph Hellwig rd_size -= len;
4928feb58d0SChristoph Hellwig if (!rd_size)
493c66ac9dbSNicholas Bellinger continue;
494c66ac9dbSNicholas Bellinger
49565b0c78dSSebastian Andrzej Siewior src_len -= len;
49665b0c78dSSebastian Andrzej Siewior if (src_len) {
49765b0c78dSSebastian Andrzej Siewior rd_offset += len;
498c66ac9dbSNicholas Bellinger continue;
499c66ac9dbSNicholas Bellinger }
5006708bb27SAndy Grover
50165b0c78dSSebastian Andrzej Siewior /* rd page completed, next one please */
5028feb58d0SChristoph Hellwig rd_page++;
50365b0c78dSSebastian Andrzej Siewior rd_offset = 0;
50465b0c78dSSebastian Andrzej Siewior src_len = PAGE_SIZE;
5058feb58d0SChristoph Hellwig if (rd_page <= table->page_end_offset) {
50665b0c78dSSebastian Andrzej Siewior rd_sg++;
50765b0c78dSSebastian Andrzej Siewior continue;
50865b0c78dSSebastian Andrzej Siewior }
5096708bb27SAndy Grover
5108feb58d0SChristoph Hellwig table = rd_get_sg_table(dev, rd_page);
51165b0c78dSSebastian Andrzej Siewior if (!table) {
51265b0c78dSSebastian Andrzej Siewior sg_miter_stop(&m);
513de103c93SChristoph Hellwig return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
514c66ac9dbSNicholas Bellinger }
515c66ac9dbSNicholas Bellinger
51665b0c78dSSebastian Andrzej Siewior /* since we increment, the first sg entry is correct */
51765b0c78dSSebastian Andrzej Siewior rd_sg = table->sg_table;
518c66ac9dbSNicholas Bellinger }
51965b0c78dSSebastian Andrzej Siewior sg_miter_stop(&m);
520c66ac9dbSNicholas Bellinger
5211762742fSNicholas Bellinger if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
5221762742fSNicholas Bellinger data_direction == DMA_FROM_DEVICE) {
523f75b6faeSSagi Grimberg rc = rd_do_prot_rw(cmd, true);
5246e611119SNicholas Bellinger if (rc)
5256e611119SNicholas Bellinger return rc;
5266e611119SNicholas Bellinger }
5276e611119SNicholas Bellinger
5285787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD);
52903e98c9eSNicholas Bellinger return 0;
530c66ac9dbSNicholas Bellinger }
531c66ac9dbSNicholas Bellinger
532c66ac9dbSNicholas Bellinger enum {
5330aecfa66SKonstantin Shelekhin Opt_rd_pages, Opt_rd_nullio, Opt_rd_dummy, Opt_err
534c66ac9dbSNicholas Bellinger };
535c66ac9dbSNicholas Bellinger
536c66ac9dbSNicholas Bellinger static match_table_t tokens = {
537c66ac9dbSNicholas Bellinger {Opt_rd_pages, "rd_pages=%d"},
53852c07423SNicholas Bellinger {Opt_rd_nullio, "rd_nullio=%d"},
5390aecfa66SKonstantin Shelekhin {Opt_rd_dummy, "rd_dummy=%d"},
540c66ac9dbSNicholas Bellinger {Opt_err, NULL}
541c66ac9dbSNicholas Bellinger };
542c66ac9dbSNicholas Bellinger
rd_set_configfs_dev_params(struct se_device * dev,const char * page,ssize_t count)5430fd97ccfSChristoph Hellwig static ssize_t rd_set_configfs_dev_params(struct se_device *dev,
5440fd97ccfSChristoph Hellwig const char *page, ssize_t count)
545c66ac9dbSNicholas Bellinger {
5460fd97ccfSChristoph Hellwig struct rd_dev *rd_dev = RD_DEV(dev);
547c66ac9dbSNicholas Bellinger char *orig, *ptr, *opts;
548c66ac9dbSNicholas Bellinger substring_t args[MAX_OPT_ARGS];
549fb418240SGustavo A. R. Silva int arg, token;
550c66ac9dbSNicholas Bellinger
551c66ac9dbSNicholas Bellinger opts = kstrdup(page, GFP_KERNEL);
552c66ac9dbSNicholas Bellinger if (!opts)
553c66ac9dbSNicholas Bellinger return -ENOMEM;
554c66ac9dbSNicholas Bellinger
555c66ac9dbSNicholas Bellinger orig = opts;
556c66ac9dbSNicholas Bellinger
55790c161b6SSebastian Andrzej Siewior while ((ptr = strsep(&opts, ",\n")) != NULL) {
558c66ac9dbSNicholas Bellinger if (!*ptr)
559c66ac9dbSNicholas Bellinger continue;
560c66ac9dbSNicholas Bellinger
561c66ac9dbSNicholas Bellinger token = match_token(ptr, tokens, args);
562c66ac9dbSNicholas Bellinger switch (token) {
563c66ac9dbSNicholas Bellinger case Opt_rd_pages:
564c66ac9dbSNicholas Bellinger match_int(args, &arg);
565c66ac9dbSNicholas Bellinger rd_dev->rd_page_count = arg;
5666708bb27SAndy Grover pr_debug("RAMDISK: Referencing Page"
567c66ac9dbSNicholas Bellinger " Count: %u\n", rd_dev->rd_page_count);
568c66ac9dbSNicholas Bellinger rd_dev->rd_flags |= RDF_HAS_PAGE_COUNT;
569c66ac9dbSNicholas Bellinger break;
57052c07423SNicholas Bellinger case Opt_rd_nullio:
57152c07423SNicholas Bellinger match_int(args, &arg);
57252c07423SNicholas Bellinger if (arg != 1)
57352c07423SNicholas Bellinger break;
57452c07423SNicholas Bellinger
57552c07423SNicholas Bellinger pr_debug("RAMDISK: Setting NULLIO flag: %d\n", arg);
57652c07423SNicholas Bellinger rd_dev->rd_flags |= RDF_NULLIO;
57752c07423SNicholas Bellinger break;
5780aecfa66SKonstantin Shelekhin case Opt_rd_dummy:
5790aecfa66SKonstantin Shelekhin match_int(args, &arg);
5800aecfa66SKonstantin Shelekhin if (arg != 1)
5810aecfa66SKonstantin Shelekhin break;
5820aecfa66SKonstantin Shelekhin
5830aecfa66SKonstantin Shelekhin pr_debug("RAMDISK: Setting DUMMY flag: %d\n", arg);
5840aecfa66SKonstantin Shelekhin rd_dev->rd_flags |= RDF_DUMMY;
5850aecfa66SKonstantin Shelekhin break;
586c66ac9dbSNicholas Bellinger default:
587c66ac9dbSNicholas Bellinger break;
588c66ac9dbSNicholas Bellinger }
589c66ac9dbSNicholas Bellinger }
590c66ac9dbSNicholas Bellinger
591c66ac9dbSNicholas Bellinger kfree(orig);
592fb418240SGustavo A. R. Silva return count;
593c66ac9dbSNicholas Bellinger }
594c66ac9dbSNicholas Bellinger
rd_show_configfs_dev_params(struct se_device * dev,char * b)5950fd97ccfSChristoph Hellwig static ssize_t rd_show_configfs_dev_params(struct se_device *dev, char *b)
596c66ac9dbSNicholas Bellinger {
5970fd97ccfSChristoph Hellwig struct rd_dev *rd_dev = RD_DEV(dev);
598c66ac9dbSNicholas Bellinger
5998feb58d0SChristoph Hellwig ssize_t bl = sprintf(b, "TCM RamDisk ID: %u RamDisk Makeup: rd_mcp\n",
6008feb58d0SChristoph Hellwig rd_dev->rd_dev_id);
601c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, " PAGES/PAGE_SIZE: %u*%lu"
6020aecfa66SKonstantin Shelekhin " SG_table_count: %u nullio: %d dummy: %d\n",
6030aecfa66SKonstantin Shelekhin rd_dev->rd_page_count,
60452c07423SNicholas Bellinger PAGE_SIZE, rd_dev->sg_table_count,
6050aecfa66SKonstantin Shelekhin !!(rd_dev->rd_flags & RDF_NULLIO),
6060aecfa66SKonstantin Shelekhin !!(rd_dev->rd_flags & RDF_DUMMY));
607c66ac9dbSNicholas Bellinger return bl;
608c66ac9dbSNicholas Bellinger }
609c66ac9dbSNicholas Bellinger
rd_get_device_type(struct se_device * dev)6100aecfa66SKonstantin Shelekhin static u32 rd_get_device_type(struct se_device *dev)
6110aecfa66SKonstantin Shelekhin {
6120aecfa66SKonstantin Shelekhin if (RD_DEV(dev)->rd_flags & RDF_DUMMY)
6130aecfa66SKonstantin Shelekhin return 0x3f; /* Unknown device type, not connected */
6140aecfa66SKonstantin Shelekhin else
6150aecfa66SKonstantin Shelekhin return sbc_get_device_type(dev);
6160aecfa66SKonstantin Shelekhin }
6170aecfa66SKonstantin Shelekhin
rd_get_blocks(struct se_device * dev)618c66ac9dbSNicholas Bellinger static sector_t rd_get_blocks(struct se_device *dev)
619c66ac9dbSNicholas Bellinger {
6200fd97ccfSChristoph Hellwig struct rd_dev *rd_dev = RD_DEV(dev);
6210fd97ccfSChristoph Hellwig
622c66ac9dbSNicholas Bellinger unsigned long long blocks_long = ((rd_dev->rd_page_count * PAGE_SIZE) /
6230fd97ccfSChristoph Hellwig dev->dev_attrib.block_size) - 1;
624c66ac9dbSNicholas Bellinger
625c66ac9dbSNicholas Bellinger return blocks_long;
626c66ac9dbSNicholas Bellinger }
627c66ac9dbSNicholas Bellinger
rd_init_prot(struct se_device * dev)628d7e8eb5dSNicholas Bellinger static int rd_init_prot(struct se_device *dev)
629d7e8eb5dSNicholas Bellinger {
630d7e8eb5dSNicholas Bellinger struct rd_dev *rd_dev = RD_DEV(dev);
631d7e8eb5dSNicholas Bellinger
632d7e8eb5dSNicholas Bellinger if (!dev->dev_attrib.pi_prot_type)
633d7e8eb5dSNicholas Bellinger return 0;
634d7e8eb5dSNicholas Bellinger
6359d2e59f2SQuinn Tran return rd_build_prot_space(rd_dev, dev->prot_length,
6369d2e59f2SQuinn Tran dev->dev_attrib.block_size);
637d7e8eb5dSNicholas Bellinger }
638d7e8eb5dSNicholas Bellinger
rd_free_prot(struct se_device * dev)639d7e8eb5dSNicholas Bellinger static void rd_free_prot(struct se_device *dev)
640d7e8eb5dSNicholas Bellinger {
641d7e8eb5dSNicholas Bellinger struct rd_dev *rd_dev = RD_DEV(dev);
642d7e8eb5dSNicholas Bellinger
643d7e8eb5dSNicholas Bellinger rd_release_prot_space(rd_dev);
644d7e8eb5dSNicholas Bellinger }
645d7e8eb5dSNicholas Bellinger
646*0217da08SMike Christie static struct exec_cmd_ops rd_exec_cmd_ops = {
6470c2ad7d1SChristoph Hellwig .execute_rw = rd_execute_rw,
6480c2ad7d1SChristoph Hellwig };
6490c2ad7d1SChristoph Hellwig
650de103c93SChristoph Hellwig static sense_reason_t
rd_parse_cdb(struct se_cmd * cmd)651de103c93SChristoph Hellwig rd_parse_cdb(struct se_cmd *cmd)
6520c2ad7d1SChristoph Hellwig {
653*0217da08SMike Christie return sbc_parse_cdb(cmd, &rd_exec_cmd_ops);
6540c2ad7d1SChristoph Hellwig }
6550c2ad7d1SChristoph Hellwig
6560a06d430SChristoph Hellwig static const struct target_backend_ops rd_mcp_ops = {
657c66ac9dbSNicholas Bellinger .name = "rd_mcp",
6580fd97ccfSChristoph Hellwig .inquiry_prod = "RAMDISK-MCP",
6590fd97ccfSChristoph Hellwig .inquiry_rev = RD_MCP_VERSION,
660c66ac9dbSNicholas Bellinger .attach_hba = rd_attach_hba,
661c66ac9dbSNicholas Bellinger .detach_hba = rd_detach_hba,
6620fd97ccfSChristoph Hellwig .alloc_device = rd_alloc_device,
6630fd97ccfSChristoph Hellwig .configure_device = rd_configure_device,
66492634706SMike Christie .destroy_device = rd_destroy_device,
665c66ac9dbSNicholas Bellinger .free_device = rd_free_device,
6660c2ad7d1SChristoph Hellwig .parse_cdb = rd_parse_cdb,
667c66ac9dbSNicholas Bellinger .set_configfs_dev_params = rd_set_configfs_dev_params,
668c66ac9dbSNicholas Bellinger .show_configfs_dev_params = rd_show_configfs_dev_params,
6690aecfa66SKonstantin Shelekhin .get_device_type = rd_get_device_type,
670c66ac9dbSNicholas Bellinger .get_blocks = rd_get_blocks,
671d7e8eb5dSNicholas Bellinger .init_prot = rd_init_prot,
672d7e8eb5dSNicholas Bellinger .free_prot = rd_free_prot,
6735873c4d1SChristoph Hellwig .tb_dev_attrib_attrs = sbc_attrib_attrs,
674c66ac9dbSNicholas Bellinger };
675c66ac9dbSNicholas Bellinger
rd_module_init(void)676c66ac9dbSNicholas Bellinger int __init rd_module_init(void)
677c66ac9dbSNicholas Bellinger {
6780a06d430SChristoph Hellwig return transport_backend_register(&rd_mcp_ops);
679c66ac9dbSNicholas Bellinger }
680c66ac9dbSNicholas Bellinger
rd_module_exit(void)681c66ac9dbSNicholas Bellinger void rd_module_exit(void)
682c66ac9dbSNicholas Bellinger {
6830a06d430SChristoph Hellwig target_backend_unregister(&rd_mcp_ops);
684c66ac9dbSNicholas Bellinger }
685