1
2
3
4
5
6
7#define KMSG_COMPONENT "dcssblk"
8#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
9
10#include <linux/module.h>
11#include <linux/moduleparam.h>
12#include <linux/ctype.h>
13#include <linux/errno.h>
14#include <linux/init.h>
15#include <linux/slab.h>
16#include <linux/blkdev.h>
17#include <linux/completion.h>
18#include <linux/interrupt.h>
19#include <linux/platform_device.h>
20#include <linux/pfn_t.h>
21#include <asm/extmem.h>
22#include <asm/io.h>
23
24#define DCSSBLK_NAME "dcssblk"
25#define DCSSBLK_MINORS_PER_DISK 1
26#define DCSSBLK_PARM_LEN 400
27#define DCSS_BUS_ID_SIZE 20
28
29static int dcssblk_open(struct block_device *bdev, fmode_t mode);
30static void dcssblk_release(struct gendisk *disk, fmode_t mode);
31static blk_qc_t dcssblk_make_request(struct request_queue *q,
32 struct bio *bio);
33static long dcssblk_direct_access(struct block_device *bdev, sector_t secnum,
34 void __pmem **kaddr, pfn_t *pfn);
35
36static char dcssblk_segments[DCSSBLK_PARM_LEN] = "\0";
37
38static int dcssblk_major;
39static const struct block_device_operations dcssblk_devops = {
40 .owner = THIS_MODULE,
41 .open = dcssblk_open,
42 .release = dcssblk_release,
43 .direct_access = dcssblk_direct_access,
44};
45
46struct dcssblk_dev_info {
47 struct list_head lh;
48 struct device dev;
49 char segment_name[DCSS_BUS_ID_SIZE];
50 atomic_t use_count;
51 struct gendisk *gd;
52 unsigned long start;
53 unsigned long end;
54 int segment_type;
55 unsigned char save_pending;
56 unsigned char is_shared;
57 struct request_queue *dcssblk_queue;
58 int num_of_segments;
59 struct list_head seg_list;
60};
61
62struct segment_info {
63 struct list_head lh;
64 char segment_name[DCSS_BUS_ID_SIZE];
65 unsigned long start;
66 unsigned long end;
67 int segment_type;
68};
69
70static ssize_t dcssblk_add_store(struct device * dev, struct device_attribute *attr, const char * buf,
71 size_t count);
72static ssize_t dcssblk_remove_store(struct device * dev, struct device_attribute *attr, const char * buf,
73 size_t count);
74
75static DEVICE_ATTR(add, S_IWUSR, NULL, dcssblk_add_store);
76static DEVICE_ATTR(remove, S_IWUSR, NULL, dcssblk_remove_store);
77
78static struct device *dcssblk_root_dev;
79
80static LIST_HEAD(dcssblk_devices);
81static struct rw_semaphore dcssblk_devices_sem;
82
83
84
85
86static void
87dcssblk_release_segment(struct device *dev)
88{
89 struct dcssblk_dev_info *dev_info;
90 struct segment_info *entry, *temp;
91
92 dev_info = container_of(dev, struct dcssblk_dev_info, dev);
93 list_for_each_entry_safe(entry, temp, &dev_info->seg_list, lh) {
94 list_del(&entry->lh);
95 kfree(entry);
96 }
97 kfree(dev_info);
98 module_put(THIS_MODULE);
99}
100
101
102
103
104
105
106
107static int
108dcssblk_assign_free_minor(struct dcssblk_dev_info *dev_info)
109{
110 int minor, found;
111 struct dcssblk_dev_info *entry;
112
113 if (dev_info == NULL)
114 return -EINVAL;
115 for (minor = 0; minor < (1<<MINORBITS); minor++) {
116 found = 0;
117
118 list_for_each_entry(entry, &dcssblk_devices, lh)
119 if (minor == entry->gd->first_minor)
120 found++;
121 if (!found) break;
122 }
123 if (found)
124 return -EBUSY;
125 dev_info->gd->first_minor = minor;
126 return 0;
127}
128
129
130
131
132
133
134static struct dcssblk_dev_info *
135dcssblk_get_device_by_name(char *name)
136{
137 struct dcssblk_dev_info *entry;
138
139 list_for_each_entry(entry, &dcssblk_devices, lh) {
140 if (!strcmp(name, entry->segment_name)) {
141 return entry;
142 }
143 }
144 return NULL;
145}
146
147
148
149
150
151
152static struct segment_info *
153dcssblk_get_segment_by_name(char *name)
154{
155 struct dcssblk_dev_info *dev_info;
156 struct segment_info *entry;
157
158 list_for_each_entry(dev_info, &dcssblk_devices, lh) {
159 list_for_each_entry(entry, &dev_info->seg_list, lh) {
160 if (!strcmp(name, entry->segment_name))
161 return entry;
162 }
163 }
164 return NULL;
165}
166
167
168
169
170static unsigned long
171dcssblk_find_highest_addr(struct dcssblk_dev_info *dev_info)
172{
173 unsigned long highest_addr;
174 struct segment_info *entry;
175
176 highest_addr = 0;
177 list_for_each_entry(entry, &dev_info->seg_list, lh) {
178 if (highest_addr < entry->end)
179 highest_addr = entry->end;
180 }
181 return highest_addr;
182}
183
184
185
186
187static unsigned long
188dcssblk_find_lowest_addr(struct dcssblk_dev_info *dev_info)
189{
190 int set_first;
191 unsigned long lowest_addr;
192 struct segment_info *entry;
193
194 set_first = 0;
195 lowest_addr = 0;
196 list_for_each_entry(entry, &dev_info->seg_list, lh) {
197 if (set_first == 0) {
198 lowest_addr = entry->start;
199 set_first = 1;
200 } else {
201 if (lowest_addr > entry->start)
202 lowest_addr = entry->start;
203 }
204 }
205 return lowest_addr;
206}
207
208
209
210
211static int
212dcssblk_is_continuous(struct dcssblk_dev_info *dev_info)
213{
214 int i, j, rc;
215 struct segment_info *sort_list, *entry, temp;
216
217 if (dev_info->num_of_segments <= 1)
218 return 0;
219
220 sort_list = kzalloc(
221 sizeof(struct segment_info) * dev_info->num_of_segments,
222 GFP_KERNEL);
223 if (sort_list == NULL)
224 return -ENOMEM;
225 i = 0;
226 list_for_each_entry(entry, &dev_info->seg_list, lh) {
227 memcpy(&sort_list[i], entry, sizeof(struct segment_info));
228 i++;
229 }
230
231
232 for (i = 0; i < dev_info->num_of_segments; i++)
233 for (j = 0; j < dev_info->num_of_segments; j++)
234 if (sort_list[j].start > sort_list[i].start) {
235 memcpy(&temp, &sort_list[i],
236 sizeof(struct segment_info));
237 memcpy(&sort_list[i], &sort_list[j],
238 sizeof(struct segment_info));
239 memcpy(&sort_list[j], &temp,
240 sizeof(struct segment_info));
241 }
242
243
244 for (i = 0; i < dev_info->num_of_segments - 1; i++) {
245 if ((sort_list[i].end + 1) != sort_list[i+1].start) {
246 pr_err("Adjacent DCSSs %s and %s are not "
247 "contiguous\n", sort_list[i].segment_name,
248 sort_list[i+1].segment_name);
249 rc = -EINVAL;
250 goto out;
251 }
252
253 if (sort_list[i].segment_type != sort_list[i+1].segment_type) {
254 if (!(sort_list[i].segment_type & SEGMENT_EXCLUSIVE) ||
255 (sort_list[i].segment_type == SEG_TYPE_ER) ||
256 !(sort_list[i+1].segment_type &
257 SEGMENT_EXCLUSIVE) ||
258 (sort_list[i+1].segment_type == SEG_TYPE_ER)) {
259 pr_err("DCSS %s and DCSS %s have "
260 "incompatible types\n",
261 sort_list[i].segment_name,
262 sort_list[i+1].segment_name);
263 rc = -EINVAL;
264 goto out;
265 }
266 }
267 }
268 rc = 0;
269out:
270 kfree(sort_list);
271 return rc;
272}
273
274
275
276
277static int
278dcssblk_load_segment(char *name, struct segment_info **seg_info)
279{
280 int rc;
281
282
283 down_read(&dcssblk_devices_sem);
284 *seg_info = dcssblk_get_segment_by_name(name);
285 up_read(&dcssblk_devices_sem);
286 if (*seg_info != NULL)
287 return -EEXIST;
288
289
290 *seg_info = kzalloc(sizeof(struct segment_info), GFP_KERNEL);
291 if (*seg_info == NULL)
292 return -ENOMEM;
293
294 strcpy((*seg_info)->segment_name, name);
295
296
297 rc = segment_load(name, SEGMENT_SHARED,
298 &(*seg_info)->start, &(*seg_info)->end);
299 if (rc < 0) {
300 segment_warning(rc, (*seg_info)->segment_name);
301 kfree(*seg_info);
302 } else {
303 INIT_LIST_HEAD(&(*seg_info)->lh);
304 (*seg_info)->segment_type = rc;
305 }
306 return rc;
307}
308
309
310
311
312
313static ssize_t
314dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
315{
316 struct dcssblk_dev_info *dev_info;
317
318 dev_info = container_of(dev, struct dcssblk_dev_info, dev);
319 return sprintf(buf, dev_info->is_shared ? "1\n" : "0\n");
320}
321
322static ssize_t
323dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
324{
325 struct dcssblk_dev_info *dev_info;
326 struct segment_info *entry, *temp;
327 int rc;
328
329 if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
330 return -EINVAL;
331 down_write(&dcssblk_devices_sem);
332 dev_info = container_of(dev, struct dcssblk_dev_info, dev);
333 if (atomic_read(&dev_info->use_count)) {
334 rc = -EBUSY;
335 goto out;
336 }
337 if (inbuf[0] == '1') {
338
339 list_for_each_entry(entry, &dev_info->seg_list, lh) {
340 rc = segment_modify_shared(entry->segment_name,
341 SEGMENT_SHARED);
342 if (rc < 0) {
343 BUG_ON(rc == -EINVAL);
344 if (rc != -EAGAIN)
345 goto removeseg;
346 }
347 }
348 dev_info->is_shared = 1;
349 switch (dev_info->segment_type) {
350 case SEG_TYPE_SR:
351 case SEG_TYPE_ER:
352 case SEG_TYPE_SC:
353 set_disk_ro(dev_info->gd, 1);
354 }
355 } else if (inbuf[0] == '0') {
356
357 if (dev_info->segment_type == SEG_TYPE_SC) {
358 pr_err("DCSS %s is of type SC and cannot be "
359 "loaded as exclusive-writable\n",
360 dev_info->segment_name);
361 rc = -EINVAL;
362 goto out;
363 }
364 list_for_each_entry(entry, &dev_info->seg_list, lh) {
365 rc = segment_modify_shared(entry->segment_name,
366 SEGMENT_EXCLUSIVE);
367 if (rc < 0) {
368 BUG_ON(rc == -EINVAL);
369 if (rc != -EAGAIN)
370 goto removeseg;
371 }
372 }
373 dev_info->is_shared = 0;
374 set_disk_ro(dev_info->gd, 0);
375 } else {
376 rc = -EINVAL;
377 goto out;
378 }
379 rc = count;
380 goto out;
381
382removeseg:
383 pr_err("DCSS device %s is removed after a failed access mode "
384 "change\n", dev_info->segment_name);
385 temp = entry;
386 list_for_each_entry(entry, &dev_info->seg_list, lh) {
387 if (entry != temp)
388 segment_unload(entry->segment_name);
389 }
390 list_del(&dev_info->lh);
391
392 del_gendisk(dev_info->gd);
393 blk_cleanup_queue(dev_info->dcssblk_queue);
394 dev_info->gd->queue = NULL;
395 put_disk(dev_info->gd);
396 up_write(&dcssblk_devices_sem);
397
398 if (device_remove_file_self(dev, attr)) {
399 device_unregister(dev);
400 put_device(dev);
401 }
402 return rc;
403out:
404 up_write(&dcssblk_devices_sem);
405 return rc;
406}
407static DEVICE_ATTR(shared, S_IWUSR | S_IRUSR, dcssblk_shared_show,
408 dcssblk_shared_store);
409
410
411
412
413
414
415
416
417static ssize_t
418dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf)
419{
420 struct dcssblk_dev_info *dev_info;
421
422 dev_info = container_of(dev, struct dcssblk_dev_info, dev);
423 return sprintf(buf, dev_info->save_pending ? "1\n" : "0\n");
424}
425
426static ssize_t
427dcssblk_save_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
428{
429 struct dcssblk_dev_info *dev_info;
430 struct segment_info *entry;
431
432 if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
433 return -EINVAL;
434 dev_info = container_of(dev, struct dcssblk_dev_info, dev);
435
436 down_write(&dcssblk_devices_sem);
437 if (inbuf[0] == '1') {
438 if (atomic_read(&dev_info->use_count) == 0) {
439
440 pr_info("All DCSSs that map to device %s are "
441 "saved\n", dev_info->segment_name);
442 list_for_each_entry(entry, &dev_info->seg_list, lh) {
443 if (entry->segment_type == SEG_TYPE_EN ||
444 entry->segment_type == SEG_TYPE_SN)
445 pr_warn("DCSS %s is of type SN or EN"
446 " and cannot be saved\n",
447 entry->segment_name);
448 else
449 segment_save(entry->segment_name);
450 }
451 } else {
452
453
454 pr_info("Device %s is in use, its DCSSs will be "
455 "saved when it becomes idle\n",
456 dev_info->segment_name);
457 dev_info->save_pending = 1;
458 }
459 } else if (inbuf[0] == '0') {
460 if (dev_info->save_pending) {
461
462
463 dev_info->save_pending = 0;
464 pr_info("A pending save request for device %s "
465 "has been canceled\n",
466 dev_info->segment_name);
467 }
468 } else {
469 up_write(&dcssblk_devices_sem);
470 return -EINVAL;
471 }
472 up_write(&dcssblk_devices_sem);
473 return count;
474}
475static DEVICE_ATTR(save, S_IWUSR | S_IRUSR, dcssblk_save_show,
476 dcssblk_save_store);
477
478
479
480
481static ssize_t
482dcssblk_seglist_show(struct device *dev, struct device_attribute *attr,
483 char *buf)
484{
485 int i;
486
487 struct dcssblk_dev_info *dev_info;
488 struct segment_info *entry;
489
490 down_read(&dcssblk_devices_sem);
491 dev_info = container_of(dev, struct dcssblk_dev_info, dev);
492 i = 0;
493 buf[0] = '\0';
494 list_for_each_entry(entry, &dev_info->seg_list, lh) {
495 strcpy(&buf[i], entry->segment_name);
496 i += strlen(entry->segment_name);
497 buf[i] = '\n';
498 i++;
499 }
500 up_read(&dcssblk_devices_sem);
501 return i;
502}
503static DEVICE_ATTR(seglist, S_IRUSR, dcssblk_seglist_show, NULL);
504
505static struct attribute *dcssblk_dev_attrs[] = {
506 &dev_attr_shared.attr,
507 &dev_attr_save.attr,
508 &dev_attr_seglist.attr,
509 NULL,
510};
511static struct attribute_group dcssblk_dev_attr_group = {
512 .attrs = dcssblk_dev_attrs,
513};
514static const struct attribute_group *dcssblk_dev_attr_groups[] = {
515 &dcssblk_dev_attr_group,
516 NULL,
517};
518
519
520
521
522static ssize_t
523dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
524{
525 int rc, i, j, num_of_segments;
526 struct dcssblk_dev_info *dev_info;
527 struct segment_info *seg_info, *temp;
528 char *local_buf;
529 unsigned long seg_byte_size;
530
531 dev_info = NULL;
532 seg_info = NULL;
533 if (dev != dcssblk_root_dev) {
534 rc = -EINVAL;
535 goto out_nobuf;
536 }
537 if ((count < 1) || (buf[0] == '\0') || (buf[0] == '\n')) {
538 rc = -ENAMETOOLONG;
539 goto out_nobuf;
540 }
541
542 local_buf = kmalloc(count + 1, GFP_KERNEL);
543 if (local_buf == NULL) {
544 rc = -ENOMEM;
545 goto out_nobuf;
546 }
547
548
549
550
551 num_of_segments = 0;
552 for (i = 0; (i < count && (buf[i] != '\0') && (buf[i] != '\n')); i++) {
553 for (j = i; j < count &&
554 (buf[j] != ':') &&
555 (buf[j] != '\0') &&
556 (buf[j] != '\n'); j++) {
557 local_buf[j-i] = toupper(buf[j]);
558 }
559 local_buf[j-i] = '\0';
560 if (((j - i) == 0) || ((j - i) > 8)) {
561 rc = -ENAMETOOLONG;
562 goto seg_list_del;
563 }
564
565 rc = dcssblk_load_segment(local_buf, &seg_info);
566 if (rc < 0)
567 goto seg_list_del;
568
569
570
571 if (num_of_segments == 0) {
572 dev_info = kzalloc(sizeof(struct dcssblk_dev_info),
573 GFP_KERNEL);
574 if (dev_info == NULL) {
575 rc = -ENOMEM;
576 goto out;
577 }
578 strcpy(dev_info->segment_name, local_buf);
579 dev_info->segment_type = seg_info->segment_type;
580 INIT_LIST_HEAD(&dev_info->seg_list);
581 }
582 list_add_tail(&seg_info->lh, &dev_info->seg_list);
583 num_of_segments++;
584 i = j;
585
586 if ((buf[j] == '\0') || (buf[j] == '\n'))
587 break;
588 }
589
590
591 if ((i > 0) && (buf[i-1] == ':')) {
592 rc = -ENAMETOOLONG;
593 goto seg_list_del;
594 }
595 strlcpy(local_buf, buf, i + 1);
596 dev_info->num_of_segments = num_of_segments;
597 rc = dcssblk_is_continuous(dev_info);
598 if (rc < 0)
599 goto seg_list_del;
600
601 dev_info->start = dcssblk_find_lowest_addr(dev_info);
602 dev_info->end = dcssblk_find_highest_addr(dev_info);
603
604 dev_set_name(&dev_info->dev, "%s", dev_info->segment_name);
605 dev_info->dev.release = dcssblk_release_segment;
606 dev_info->dev.groups = dcssblk_dev_attr_groups;
607 INIT_LIST_HEAD(&dev_info->lh);
608 dev_info->gd = alloc_disk(DCSSBLK_MINORS_PER_DISK);
609 if (dev_info->gd == NULL) {
610 rc = -ENOMEM;
611 goto seg_list_del;
612 }
613 dev_info->gd->major = dcssblk_major;
614 dev_info->gd->fops = &dcssblk_devops;
615 dev_info->dcssblk_queue = blk_alloc_queue(GFP_KERNEL);
616 dev_info->gd->queue = dev_info->dcssblk_queue;
617 dev_info->gd->private_data = dev_info;
618 dev_info->gd->driverfs_dev = &dev_info->dev;
619 blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request);
620 blk_queue_logical_block_size(dev_info->dcssblk_queue, 4096);
621
622 seg_byte_size = (dev_info->end - dev_info->start + 1);
623 set_capacity(dev_info->gd, seg_byte_size >> 9);
624 pr_info("Loaded %s with total size %lu bytes and capacity %lu "
625 "sectors\n", local_buf, seg_byte_size, seg_byte_size >> 9);
626
627 dev_info->save_pending = 0;
628 dev_info->is_shared = 1;
629 dev_info->dev.parent = dcssblk_root_dev;
630
631
632
633
634 down_write(&dcssblk_devices_sem);
635 if (dcssblk_get_segment_by_name(local_buf)) {
636 rc = -EEXIST;
637 goto release_gd;
638 }
639 rc = dcssblk_assign_free_minor(dev_info);
640 if (rc)
641 goto release_gd;
642 sprintf(dev_info->gd->disk_name, "dcssblk%d",
643 dev_info->gd->first_minor);
644 list_add_tail(&dev_info->lh, &dcssblk_devices);
645
646 if (!try_module_get(THIS_MODULE)) {
647 rc = -ENODEV;
648 goto dev_list_del;
649 }
650
651
652
653 rc = device_register(&dev_info->dev);
654 if (rc)
655 goto put_dev;
656
657 get_device(&dev_info->dev);
658 add_disk(dev_info->gd);
659
660 switch (dev_info->segment_type) {
661 case SEG_TYPE_SR:
662 case SEG_TYPE_ER:
663 case SEG_TYPE_SC:
664 set_disk_ro(dev_info->gd,1);
665 break;
666 default:
667 set_disk_ro(dev_info->gd,0);
668 break;
669 }
670 up_write(&dcssblk_devices_sem);
671 rc = count;
672 goto out;
673
674put_dev:
675 list_del(&dev_info->lh);
676 blk_cleanup_queue(dev_info->dcssblk_queue);
677 dev_info->gd->queue = NULL;
678 put_disk(dev_info->gd);
679 list_for_each_entry(seg_info, &dev_info->seg_list, lh) {
680 segment_unload(seg_info->segment_name);
681 }
682 put_device(&dev_info->dev);
683 up_write(&dcssblk_devices_sem);
684 goto out;
685dev_list_del:
686 list_del(&dev_info->lh);
687release_gd:
688 blk_cleanup_queue(dev_info->dcssblk_queue);
689 dev_info->gd->queue = NULL;
690 put_disk(dev_info->gd);
691 up_write(&dcssblk_devices_sem);
692seg_list_del:
693 if (dev_info == NULL)
694 goto out;
695 list_for_each_entry_safe(seg_info, temp, &dev_info->seg_list, lh) {
696 list_del(&seg_info->lh);
697 segment_unload(seg_info->segment_name);
698 kfree(seg_info);
699 }
700 kfree(dev_info);
701out:
702 kfree(local_buf);
703out_nobuf:
704 return rc;
705}
706
707
708
709
710static ssize_t
711dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
712{
713 struct dcssblk_dev_info *dev_info;
714 struct segment_info *entry;
715 int rc, i;
716 char *local_buf;
717
718 if (dev != dcssblk_root_dev) {
719 return -EINVAL;
720 }
721 local_buf = kmalloc(count + 1, GFP_KERNEL);
722 if (local_buf == NULL) {
723 return -ENOMEM;
724 }
725
726
727
728 for (i = 0; (i < count && (*(buf+i)!='\0') && (*(buf+i)!='\n')); i++) {
729 local_buf[i] = toupper(buf[i]);
730 }
731 local_buf[i] = '\0';
732 if ((i == 0) || (i > 8)) {
733 rc = -ENAMETOOLONG;
734 goto out_buf;
735 }
736
737 down_write(&dcssblk_devices_sem);
738 dev_info = dcssblk_get_device_by_name(local_buf);
739 if (dev_info == NULL) {
740 up_write(&dcssblk_devices_sem);
741 pr_warn("Device %s cannot be removed because it is not a known device\n",
742 local_buf);
743 rc = -ENODEV;
744 goto out_buf;
745 }
746 if (atomic_read(&dev_info->use_count) != 0) {
747 up_write(&dcssblk_devices_sem);
748 pr_warn("Device %s cannot be removed while it is in use\n",
749 local_buf);
750 rc = -EBUSY;
751 goto out_buf;
752 }
753
754 list_del(&dev_info->lh);
755 del_gendisk(dev_info->gd);
756 blk_cleanup_queue(dev_info->dcssblk_queue);
757 dev_info->gd->queue = NULL;
758 put_disk(dev_info->gd);
759
760
761 list_for_each_entry(entry, &dev_info->seg_list, lh)
762 segment_unload(entry->segment_name);
763
764 up_write(&dcssblk_devices_sem);
765
766 device_unregister(&dev_info->dev);
767 put_device(&dev_info->dev);
768
769 rc = count;
770out_buf:
771 kfree(local_buf);
772 return rc;
773}
774
775static int
776dcssblk_open(struct block_device *bdev, fmode_t mode)
777{
778 struct dcssblk_dev_info *dev_info;
779 int rc;
780
781 dev_info = bdev->bd_disk->private_data;
782 if (NULL == dev_info) {
783 rc = -ENODEV;
784 goto out;
785 }
786 atomic_inc(&dev_info->use_count);
787 bdev->bd_block_size = 4096;
788 rc = 0;
789out:
790 return rc;
791}
792
793static void
794dcssblk_release(struct gendisk *disk, fmode_t mode)
795{
796 struct dcssblk_dev_info *dev_info = disk->private_data;
797 struct segment_info *entry;
798
799 if (!dev_info) {
800 WARN_ON(1);
801 return;
802 }
803 down_write(&dcssblk_devices_sem);
804 if (atomic_dec_and_test(&dev_info->use_count)
805 && (dev_info->save_pending)) {
806 pr_info("Device %s has become idle and is being saved "
807 "now\n", dev_info->segment_name);
808 list_for_each_entry(entry, &dev_info->seg_list, lh) {
809 if (entry->segment_type == SEG_TYPE_EN ||
810 entry->segment_type == SEG_TYPE_SN)
811 pr_warn("DCSS %s is of type SN or EN and cannot"
812 " be saved\n", entry->segment_name);
813 else
814 segment_save(entry->segment_name);
815 }
816 dev_info->save_pending = 0;
817 }
818 up_write(&dcssblk_devices_sem);
819}
820
821static blk_qc_t
822dcssblk_make_request(struct request_queue *q, struct bio *bio)
823{
824 struct dcssblk_dev_info *dev_info;
825 struct bio_vec bvec;
826 struct bvec_iter iter;
827 unsigned long index;
828 unsigned long page_addr;
829 unsigned long source_addr;
830 unsigned long bytes_done;
831
832 blk_queue_split(q, &bio, q->bio_split);
833
834 bytes_done = 0;
835 dev_info = bio->bi_bdev->bd_disk->private_data;
836 if (dev_info == NULL)
837 goto fail;
838 if ((bio->bi_iter.bi_sector & 7) != 0 ||
839 (bio->bi_iter.bi_size & 4095) != 0)
840
841 goto fail;
842 if (bio_end_sector(bio) > get_capacity(bio->bi_bdev->bd_disk)) {
843
844 goto fail;
845 }
846
847 if (dev_info->is_shared) {
848 switch (dev_info->segment_type) {
849 case SEG_TYPE_SR:
850 case SEG_TYPE_ER:
851 case SEG_TYPE_SC:
852
853 if (bio_data_dir(bio) == WRITE) {
854 pr_warn("Writing to %s failed because it is a read-only device\n",
855 dev_name(&dev_info->dev));
856 goto fail;
857 }
858 }
859 }
860
861 index = (bio->bi_iter.bi_sector >> 3);
862 bio_for_each_segment(bvec, bio, iter) {
863 page_addr = (unsigned long)
864 page_address(bvec.bv_page) + bvec.bv_offset;
865 source_addr = dev_info->start + (index<<12) + bytes_done;
866 if (unlikely((page_addr & 4095) != 0) || (bvec.bv_len & 4095) != 0)
867
868 goto fail;
869 if (bio_data_dir(bio) == READ) {
870 memcpy((void*)page_addr, (void*)source_addr,
871 bvec.bv_len);
872 } else {
873 memcpy((void*)source_addr, (void*)page_addr,
874 bvec.bv_len);
875 }
876 bytes_done += bvec.bv_len;
877 }
878 bio_endio(bio);
879 return BLK_QC_T_NONE;
880fail:
881 bio_io_error(bio);
882 return BLK_QC_T_NONE;
883}
884
885static long
886dcssblk_direct_access (struct block_device *bdev, sector_t secnum,
887 void __pmem **kaddr, pfn_t *pfn)
888{
889 struct dcssblk_dev_info *dev_info;
890 unsigned long offset, dev_sz;
891
892 dev_info = bdev->bd_disk->private_data;
893 if (!dev_info)
894 return -ENODEV;
895 dev_sz = dev_info->end - dev_info->start;
896 offset = secnum * 512;
897 *kaddr = (void __pmem *) (dev_info->start + offset);
898 *pfn = __pfn_to_pfn_t(PFN_DOWN(dev_info->start + offset), PFN_DEV);
899
900 return dev_sz - offset;
901}
902
903static void
904dcssblk_check_params(void)
905{
906 int rc, i, j, k;
907 char buf[DCSSBLK_PARM_LEN + 1];
908 struct dcssblk_dev_info *dev_info;
909
910 for (i = 0; (i < DCSSBLK_PARM_LEN) && (dcssblk_segments[i] != '\0');
911 i++) {
912 for (j = i; (j < DCSSBLK_PARM_LEN) &&
913 (dcssblk_segments[j] != ',') &&
914 (dcssblk_segments[j] != '\0') &&
915 (dcssblk_segments[j] != '('); j++)
916 {
917 buf[j-i] = dcssblk_segments[j];
918 }
919 buf[j-i] = '\0';
920 rc = dcssblk_add_store(dcssblk_root_dev, NULL, buf, j-i);
921 if ((rc >= 0) && (dcssblk_segments[j] == '(')) {
922 for (k = 0; (buf[k] != ':') && (buf[k] != '\0'); k++)
923 buf[k] = toupper(buf[k]);
924 buf[k] = '\0';
925 if (!strncmp(&dcssblk_segments[j], "(local)", 7)) {
926 down_read(&dcssblk_devices_sem);
927 dev_info = dcssblk_get_device_by_name(buf);
928 up_read(&dcssblk_devices_sem);
929 if (dev_info)
930 dcssblk_shared_store(&dev_info->dev,
931 NULL, "0\n", 2);
932 }
933 }
934 while ((dcssblk_segments[j] != ',') &&
935 (dcssblk_segments[j] != '\0'))
936 {
937 j++;
938 }
939 if (dcssblk_segments[j] == '\0')
940 break;
941 i = j;
942 }
943}
944
945
946
947
948static int dcssblk_freeze(struct device *dev)
949{
950 struct dcssblk_dev_info *dev_info;
951 int rc = 0;
952
953 list_for_each_entry(dev_info, &dcssblk_devices, lh) {
954 switch (dev_info->segment_type) {
955 case SEG_TYPE_SR:
956 case SEG_TYPE_ER:
957 case SEG_TYPE_SC:
958 if (!dev_info->is_shared)
959 rc = -EINVAL;
960 break;
961 default:
962 rc = -EINVAL;
963 break;
964 }
965 if (rc)
966 break;
967 }
968 if (rc)
969 pr_err("Suspending the system failed because DCSS device %s "
970 "is writable\n",
971 dev_info->segment_name);
972 return rc;
973}
974
975static int dcssblk_restore(struct device *dev)
976{
977 struct dcssblk_dev_info *dev_info;
978 struct segment_info *entry;
979 unsigned long start, end;
980 int rc = 0;
981
982 list_for_each_entry(dev_info, &dcssblk_devices, lh) {
983 list_for_each_entry(entry, &dev_info->seg_list, lh) {
984 segment_unload(entry->segment_name);
985 rc = segment_load(entry->segment_name, SEGMENT_SHARED,
986 &start, &end);
987 if (rc < 0) {
988
989 segment_warning(rc, entry->segment_name);
990 goto out_panic;
991 }
992 if (start != entry->start || end != entry->end) {
993 pr_err("The address range of DCSS %s changed "
994 "while the system was suspended\n",
995 entry->segment_name);
996 goto out_panic;
997 }
998 }
999 }
1000 return 0;
1001out_panic:
1002 panic("fatal dcssblk resume error\n");
1003}
1004
1005static int dcssblk_thaw(struct device *dev)
1006{
1007 return 0;
1008}
1009
1010static const struct dev_pm_ops dcssblk_pm_ops = {
1011 .freeze = dcssblk_freeze,
1012 .thaw = dcssblk_thaw,
1013 .restore = dcssblk_restore,
1014};
1015
1016static struct platform_driver dcssblk_pdrv = {
1017 .driver = {
1018 .name = "dcssblk",
1019 .pm = &dcssblk_pm_ops,
1020 },
1021};
1022
1023static struct platform_device *dcssblk_pdev;
1024
1025
1026
1027
1028
1029static void __exit
1030dcssblk_exit(void)
1031{
1032 platform_device_unregister(dcssblk_pdev);
1033 platform_driver_unregister(&dcssblk_pdrv);
1034 root_device_unregister(dcssblk_root_dev);
1035 unregister_blkdev(dcssblk_major, DCSSBLK_NAME);
1036}
1037
1038static int __init
1039dcssblk_init(void)
1040{
1041 int rc;
1042
1043 rc = platform_driver_register(&dcssblk_pdrv);
1044 if (rc)
1045 return rc;
1046
1047 dcssblk_pdev = platform_device_register_simple("dcssblk", -1, NULL,
1048 0);
1049 if (IS_ERR(dcssblk_pdev)) {
1050 rc = PTR_ERR(dcssblk_pdev);
1051 goto out_pdrv;
1052 }
1053
1054 dcssblk_root_dev = root_device_register("dcssblk");
1055 if (IS_ERR(dcssblk_root_dev)) {
1056 rc = PTR_ERR(dcssblk_root_dev);
1057 goto out_pdev;
1058 }
1059 rc = device_create_file(dcssblk_root_dev, &dev_attr_add);
1060 if (rc)
1061 goto out_root;
1062 rc = device_create_file(dcssblk_root_dev, &dev_attr_remove);
1063 if (rc)
1064 goto out_root;
1065 rc = register_blkdev(0, DCSSBLK_NAME);
1066 if (rc < 0)
1067 goto out_root;
1068 dcssblk_major = rc;
1069 init_rwsem(&dcssblk_devices_sem);
1070
1071 dcssblk_check_params();
1072 return 0;
1073
1074out_root:
1075 root_device_unregister(dcssblk_root_dev);
1076out_pdev:
1077 platform_device_unregister(dcssblk_pdev);
1078out_pdrv:
1079 platform_driver_unregister(&dcssblk_pdrv);
1080 return rc;
1081}
1082
1083module_init(dcssblk_init);
1084module_exit(dcssblk_exit);
1085
1086module_param_string(segments, dcssblk_segments, DCSSBLK_PARM_LEN, 0444);
1087MODULE_PARM_DESC(segments, "Name of DCSS segment(s) to be loaded, "
1088 "comma-separated list, names in each set separated "
1089 "by commas are separated by colons, each set contains "
1090 "names of contiguous segments and each name max. 8 chars.\n"
1091 "Adding \"(local)\" to the end of each set equals echoing 0 "
1092 "to /sys/devices/dcssblk/<device name>/shared after loading "
1093 "the contiguous segments - \n"
1094 "e.g. segments=\"mydcss1,mydcss2:mydcss3,mydcss4(local)\"");
1095
1096MODULE_LICENSE("GPL");
1097
