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