xref: /linux/drivers/target/target_core_rd.c (revision eecb20720f1b29019725515051e41bc7c079f91f) 
1 /*******************************************************************************
2  * Filename:  target_core_rd.c
3  *
4  * This file contains the Storage Engine <-> Ramdisk transport
5  * specific functions.
6  *
7  * Copyright (c) 2003, 2004, 2005 PyX Technologies, Inc.
8  * Copyright (c) 2005, 2006, 2007 SBE, Inc.
9  * Copyright (c) 2007-2010 Rising Tide Systems
10  * Copyright (c) 2008-2010 Linux-iSCSI.org
11  *
12  * Nicholas A. Bellinger <nab@kernel.org>
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27  *
28  ******************************************************************************/
29 
30 #include <linux/string.h>
31 #include <linux/parser.h>
32 #include <linux/timer.h>
33 #include <linux/blkdev.h>
34 #include <linux/slab.h>
35 #include <linux/spinlock.h>
36 #include <scsi/scsi.h>
37 #include <scsi/scsi_host.h>
38 
39 #include <target/target_core_base.h>
40 #include <target/target_core_device.h>
41 #include <target/target_core_transport.h>
42 #include <target/target_core_fabric_ops.h>
43 
44 #include "target_core_rd.h"
45 
46 static struct se_subsystem_api rd_mcp_template;
47 
48 /*	rd_attach_hba(): (Part of se_subsystem_api_t template)
49  *
50  *
51  */
52 static int rd_attach_hba(struct se_hba *hba, u32 host_id)
53 {
54 	struct rd_host *rd_host;
55 
56 	rd_host = kzalloc(sizeof(struct rd_host), GFP_KERNEL);
57 	if (!rd_host) {
58 		pr_err("Unable to allocate memory for struct rd_host\n");
59 		return -ENOMEM;
60 	}
61 
62 	rd_host->rd_host_id = host_id;
63 
64 	hba->hba_ptr = rd_host;
65 
66 	pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on"
67 		" Generic Target Core Stack %s\n", hba->hba_id,
68 		RD_HBA_VERSION, TARGET_CORE_MOD_VERSION);
69 	pr_debug("CORE_HBA[%d] - Attached Ramdisk HBA: %u to Generic"
70 		" MaxSectors: %u\n", hba->hba_id,
71 		rd_host->rd_host_id, RD_MAX_SECTORS);
72 
73 	return 0;
74 }
75 
76 static void rd_detach_hba(struct se_hba *hba)
77 {
78 	struct rd_host *rd_host = hba->hba_ptr;
79 
80 	pr_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from"
81 		" Generic Target Core\n", hba->hba_id, rd_host->rd_host_id);
82 
83 	kfree(rd_host);
84 	hba->hba_ptr = NULL;
85 }
86 
87 /*	rd_release_device_space():
88  *
89  *
90  */
91 static void rd_release_device_space(struct rd_dev *rd_dev)
92 {
93 	u32 i, j, page_count = 0, sg_per_table;
94 	struct rd_dev_sg_table *sg_table;
95 	struct page *pg;
96 	struct scatterlist *sg;
97 
98 	if (!rd_dev->sg_table_array || !rd_dev->sg_table_count)
99 		return;
100 
101 	sg_table = rd_dev->sg_table_array;
102 
103 	for (i = 0; i < rd_dev->sg_table_count; i++) {
104 		sg = sg_table[i].sg_table;
105 		sg_per_table = sg_table[i].rd_sg_count;
106 
107 		for (j = 0; j < sg_per_table; j++) {
108 			pg = sg_page(&sg[j]);
109 			if (pg) {
110 				__free_page(pg);
111 				page_count++;
112 			}
113 		}
114 
115 		kfree(sg);
116 	}
117 
118 	pr_debug("CORE_RD[%u] - Released device space for Ramdisk"
119 		" Device ID: %u, pages %u in %u tables total bytes %lu\n",
120 		rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
121 		rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
122 
123 	kfree(sg_table);
124 	rd_dev->sg_table_array = NULL;
125 	rd_dev->sg_table_count = 0;
126 }
127 
128 
129 /*	rd_build_device_space():
130  *
131  *
132  */
133 static int rd_build_device_space(struct rd_dev *rd_dev)
134 {
135 	u32 i = 0, j, page_offset = 0, sg_per_table, sg_tables, total_sg_needed;
136 	u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
137 				sizeof(struct scatterlist));
138 	struct rd_dev_sg_table *sg_table;
139 	struct page *pg;
140 	struct scatterlist *sg;
141 
142 	if (rd_dev->rd_page_count <= 0) {
143 		pr_err("Illegal page count: %u for Ramdisk device\n",
144 			rd_dev->rd_page_count);
145 		return -EINVAL;
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 
204 static void *rd_allocate_virtdevice(
205 	struct se_hba *hba,
206 	const char *name,
207 	int rd_direct)
208 {
209 	struct rd_dev *rd_dev;
210 	struct rd_host *rd_host = hba->hba_ptr;
211 
212 	rd_dev = kzalloc(sizeof(struct rd_dev), GFP_KERNEL);
213 	if (!rd_dev) {
214 		pr_err("Unable to allocate memory for struct rd_dev\n");
215 		return NULL;
216 	}
217 
218 	rd_dev->rd_host = rd_host;
219 	rd_dev->rd_direct = rd_direct;
220 
221 	return rd_dev;
222 }
223 
224 static void *rd_MEMCPY_allocate_virtdevice(struct se_hba *hba, const char *name)
225 {
226 	return rd_allocate_virtdevice(hba, name, 0);
227 }
228 
229 /*	rd_create_virtdevice():
230  *
231  *
232  */
233 static struct se_device *rd_create_virtdevice(
234 	struct se_hba *hba,
235 	struct se_subsystem_dev *se_dev,
236 	void *p,
237 	int rd_direct)
238 {
239 	struct se_device *dev;
240 	struct se_dev_limits dev_limits;
241 	struct rd_dev *rd_dev = p;
242 	struct rd_host *rd_host = hba->hba_ptr;
243 	int dev_flags = 0, ret;
244 	char prod[16], rev[4];
245 
246 	memset(&dev_limits, 0, sizeof(struct se_dev_limits));
247 
248 	ret = rd_build_device_space(rd_dev);
249 	if (ret < 0)
250 		goto fail;
251 
252 	snprintf(prod, 16, "RAMDISK-%s", (rd_dev->rd_direct) ? "DR" : "MCP");
253 	snprintf(rev, 4, "%s", (rd_dev->rd_direct) ? RD_DR_VERSION :
254 						RD_MCP_VERSION);
255 
256 	dev_limits.limits.logical_block_size = RD_BLOCKSIZE;
257 	dev_limits.limits.max_hw_sectors = RD_MAX_SECTORS;
258 	dev_limits.limits.max_sectors = RD_MAX_SECTORS;
259 	dev_limits.hw_queue_depth = RD_MAX_DEVICE_QUEUE_DEPTH;
260 	dev_limits.queue_depth = RD_DEVICE_QUEUE_DEPTH;
261 
262 	dev = transport_add_device_to_core_hba(hba,
263 			&rd_mcp_template, se_dev, dev_flags, rd_dev,
264 			&dev_limits, prod, rev);
265 	if (!dev)
266 		goto fail;
267 
268 	rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++;
269 	rd_dev->rd_queue_depth = dev->queue_depth;
270 
271 	pr_debug("CORE_RD[%u] - Added TCM %s Ramdisk Device ID: %u of"
272 		" %u pages in %u tables, %lu total bytes\n",
273 		rd_host->rd_host_id, (!rd_dev->rd_direct) ? "MEMCPY" :
274 		"DIRECT", rd_dev->rd_dev_id, rd_dev->rd_page_count,
275 		rd_dev->sg_table_count,
276 		(unsigned long)(rd_dev->rd_page_count * PAGE_SIZE));
277 
278 	return dev;
279 
280 fail:
281 	rd_release_device_space(rd_dev);
282 	return ERR_PTR(ret);
283 }
284 
285 static struct se_device *rd_MEMCPY_create_virtdevice(
286 	struct se_hba *hba,
287 	struct se_subsystem_dev *se_dev,
288 	void *p)
289 {
290 	return rd_create_virtdevice(hba, se_dev, p, 0);
291 }
292 
293 /*	rd_free_device(): (Part of se_subsystem_api_t template)
294  *
295  *
296  */
297 static void rd_free_device(void *p)
298 {
299 	struct rd_dev *rd_dev = p;
300 
301 	rd_release_device_space(rd_dev);
302 	kfree(rd_dev);
303 }
304 
305 static inline struct rd_request *RD_REQ(struct se_task *task)
306 {
307 	return container_of(task, struct rd_request, rd_task);
308 }
309 
310 static struct se_task *
311 rd_alloc_task(unsigned char *cdb)
312 {
313 	struct rd_request *rd_req;
314 
315 	rd_req = kzalloc(sizeof(struct rd_request), GFP_KERNEL);
316 	if (!rd_req) {
317 		pr_err("Unable to allocate struct rd_request\n");
318 		return NULL;
319 	}
320 
321 	return &rd_req->rd_task;
322 }
323 
324 /*	rd_get_sg_table():
325  *
326  *
327  */
328 static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
329 {
330 	u32 i;
331 	struct rd_dev_sg_table *sg_table;
332 
333 	for (i = 0; i < rd_dev->sg_table_count; i++) {
334 		sg_table = &rd_dev->sg_table_array[i];
335 		if ((sg_table->page_start_offset <= page) &&
336 		    (sg_table->page_end_offset >= page))
337 			return sg_table;
338 	}
339 
340 	pr_err("Unable to locate struct rd_dev_sg_table for page: %u\n",
341 			page);
342 
343 	return NULL;
344 }
345 
346 static int rd_MEMCPY(struct rd_request *req, u32 read_rd)
347 {
348 	struct se_task *task = &req->rd_task;
349 	struct rd_dev *dev = req->rd_task.task_se_cmd->se_dev->dev_ptr;
350 	struct rd_dev_sg_table *table;
351 	struct scatterlist *rd_sg;
352 	struct sg_mapping_iter m;
353 	u32 rd_offset = req->rd_offset;
354 	u32 src_len;
355 
356 	table = rd_get_sg_table(dev, req->rd_page);
357 	if (!table)
358 		return -EINVAL;
359 
360 	rd_sg = &table->sg_table[req->rd_page - table->page_start_offset];
361 
362 	pr_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n",
363 			dev->rd_dev_id, read_rd ? "Read" : "Write",
364 			task->task_lba, req->rd_size, req->rd_page,
365 			rd_offset);
366 
367 	src_len = PAGE_SIZE - rd_offset;
368 	sg_miter_start(&m, task->task_sg, task->task_sg_nents,
369 			read_rd ? SG_MITER_TO_SG : SG_MITER_FROM_SG);
370 	while (req->rd_size) {
371 		u32 len;
372 		void *rd_addr;
373 
374 		sg_miter_next(&m);
375 		len = min((u32)m.length, src_len);
376 		m.consumed = len;
377 
378 		rd_addr = sg_virt(rd_sg) + rd_offset;
379 
380 		if (read_rd)
381 			memcpy(m.addr, rd_addr, len);
382 		else
383 			memcpy(rd_addr, m.addr, len);
384 
385 		req->rd_size -= len;
386 		if (!req->rd_size)
387 			continue;
388 
389 		src_len -= len;
390 		if (src_len) {
391 			rd_offset += len;
392 			continue;
393 		}
394 
395 		/* rd page completed, next one please */
396 		req->rd_page++;
397 		rd_offset = 0;
398 		src_len = PAGE_SIZE;
399 		if (req->rd_page <= table->page_end_offset) {
400 			rd_sg++;
401 			continue;
402 		}
403 
404 		table = rd_get_sg_table(dev, req->rd_page);
405 		if (!table) {
406 			sg_miter_stop(&m);
407 			return -EINVAL;
408 		}
409 
410 		/* since we increment, the first sg entry is correct */
411 		rd_sg = table->sg_table;
412 	}
413 	sg_miter_stop(&m);
414 	return 0;
415 }
416 
417 /*	rd_MEMCPY_do_task(): (Part of se_subsystem_api_t template)
418  *
419  *
420  */
421 static int rd_MEMCPY_do_task(struct se_task *task)
422 {
423 	struct se_device *dev = task->task_se_cmd->se_dev;
424 	struct rd_request *req = RD_REQ(task);
425 	u64 tmp;
426 	int ret;
427 
428 	tmp = task->task_lba * dev->se_sub_dev->se_dev_attrib.block_size;
429 	req->rd_offset = do_div(tmp, PAGE_SIZE);
430 	req->rd_page = tmp;
431 	req->rd_size = task->task_size;
432 
433 	ret = rd_MEMCPY(req, task->task_data_direction == DMA_FROM_DEVICE);
434 	if (ret != 0)
435 		return ret;
436 
437 	task->task_scsi_status = GOOD;
438 	transport_complete_task(task, 1);
439 	return 0;
440 }
441 
442 /*	rd_free_task(): (Part of se_subsystem_api_t template)
443  *
444  *
445  */
446 static void rd_free_task(struct se_task *task)
447 {
448 	kfree(RD_REQ(task));
449 }
450 
451 enum {
452 	Opt_rd_pages, Opt_err
453 };
454 
455 static match_table_t tokens = {
456 	{Opt_rd_pages, "rd_pages=%d"},
457 	{Opt_err, NULL}
458 };
459 
460 static ssize_t rd_set_configfs_dev_params(
461 	struct se_hba *hba,
462 	struct se_subsystem_dev *se_dev,
463 	const char *page,
464 	ssize_t count)
465 {
466 	struct rd_dev *rd_dev = se_dev->se_dev_su_ptr;
467 	char *orig, *ptr, *opts;
468 	substring_t args[MAX_OPT_ARGS];
469 	int ret = 0, arg, token;
470 
471 	opts = kstrdup(page, GFP_KERNEL);
472 	if (!opts)
473 		return -ENOMEM;
474 
475 	orig = opts;
476 
477 	while ((ptr = strsep(&opts, ",")) != NULL) {
478 		if (!*ptr)
479 			continue;
480 
481 		token = match_token(ptr, tokens, args);
482 		switch (token) {
483 		case Opt_rd_pages:
484 			match_int(args, &arg);
485 			rd_dev->rd_page_count = arg;
486 			pr_debug("RAMDISK: Referencing Page"
487 				" Count: %u\n", rd_dev->rd_page_count);
488 			rd_dev->rd_flags |= RDF_HAS_PAGE_COUNT;
489 			break;
490 		default:
491 			break;
492 		}
493 	}
494 
495 	kfree(orig);
496 	return (!ret) ? count : ret;
497 }
498 
499 static ssize_t rd_check_configfs_dev_params(struct se_hba *hba, struct se_subsystem_dev *se_dev)
500 {
501 	struct rd_dev *rd_dev = se_dev->se_dev_su_ptr;
502 
503 	if (!(rd_dev->rd_flags & RDF_HAS_PAGE_COUNT)) {
504 		pr_debug("Missing rd_pages= parameter\n");
505 		return -EINVAL;
506 	}
507 
508 	return 0;
509 }
510 
511 static ssize_t rd_show_configfs_dev_params(
512 	struct se_hba *hba,
513 	struct se_subsystem_dev *se_dev,
514 	char *b)
515 {
516 	struct rd_dev *rd_dev = se_dev->se_dev_su_ptr;
517 	ssize_t bl = sprintf(b, "TCM RamDisk ID: %u  RamDisk Makeup: %s\n",
518 			rd_dev->rd_dev_id, (rd_dev->rd_direct) ?
519 			"rd_direct" : "rd_mcp");
520 	bl += sprintf(b + bl, "        PAGES/PAGE_SIZE: %u*%lu"
521 			"  SG_table_count: %u\n", rd_dev->rd_page_count,
522 			PAGE_SIZE, rd_dev->sg_table_count);
523 	return bl;
524 }
525 
526 static u32 rd_get_device_rev(struct se_device *dev)
527 {
528 	return SCSI_SPC_2; /* Returns SPC-3 in Initiator Data */
529 }
530 
531 static u32 rd_get_device_type(struct se_device *dev)
532 {
533 	return TYPE_DISK;
534 }
535 
536 static sector_t rd_get_blocks(struct se_device *dev)
537 {
538 	struct rd_dev *rd_dev = dev->dev_ptr;
539 	unsigned long long blocks_long = ((rd_dev->rd_page_count * PAGE_SIZE) /
540 			dev->se_sub_dev->se_dev_attrib.block_size) - 1;
541 
542 	return blocks_long;
543 }
544 
545 static struct se_subsystem_api rd_mcp_template = {
546 	.name			= "rd_mcp",
547 	.transport_type		= TRANSPORT_PLUGIN_VHBA_VDEV,
548 	.attach_hba		= rd_attach_hba,
549 	.detach_hba		= rd_detach_hba,
550 	.allocate_virtdevice	= rd_MEMCPY_allocate_virtdevice,
551 	.create_virtdevice	= rd_MEMCPY_create_virtdevice,
552 	.free_device		= rd_free_device,
553 	.alloc_task		= rd_alloc_task,
554 	.do_task		= rd_MEMCPY_do_task,
555 	.free_task		= rd_free_task,
556 	.check_configfs_dev_params = rd_check_configfs_dev_params,
557 	.set_configfs_dev_params = rd_set_configfs_dev_params,
558 	.show_configfs_dev_params = rd_show_configfs_dev_params,
559 	.get_device_rev		= rd_get_device_rev,
560 	.get_device_type	= rd_get_device_type,
561 	.get_blocks		= rd_get_blocks,
562 };
563 
564 int __init rd_module_init(void)
565 {
566 	int ret;
567 
568 	ret = transport_subsystem_register(&rd_mcp_template);
569 	if (ret < 0) {
570 		return ret;
571 	}
572 
573 	return 0;
574 }
575 
576 void rd_module_exit(void)
577 {
578 	transport_subsystem_release(&rd_mcp_template);
579 }
580