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