dcssblk.c revision ff483d55ba6fb50a8d6f99e808da35218533b1ef
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 28static int dcssblk_open(struct block_device *bdev, fmode_t mode); 29static void dcssblk_release(struct gendisk *disk, fmode_t mode); 30static void dcssblk_make_request(struct request_queue *q, struct bio *bio); 31static int dcssblk_direct_access(struct block_device *bdev, sector_t secnum, 32 void **kaddr, unsigned long *pfn); 33 34static char dcssblk_segments[DCSSBLK_PARM_LEN] = "\0"; 35 36static int dcssblk_major; 37static 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 44struct 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 60struct 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 68static ssize_t dcssblk_add_store(struct device * dev, struct device_attribute *attr, const char * buf, 69 size_t count); 70static ssize_t dcssblk_remove_store(struct device * dev, struct device_attribute *attr, const char * buf, 71 size_t count); 72 73static DEVICE_ATTR(add, S_IWUSR, NULL, dcssblk_add_store); 74static DEVICE_ATTR(remove, S_IWUSR, NULL, dcssblk_remove_store); 75 76static struct device *dcssblk_root_dev; 77 78static LIST_HEAD(dcssblk_devices); 79static struct rw_semaphore dcssblk_devices_sem; 80 81/* 82 * release function for segment device. 83 */ 84static void 85dcssblk_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 */ 105static int 106dcssblk_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 */ 132static struct dcssblk_dev_info * 133dcssblk_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 */ 150static struct segment_info * 151dcssblk_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 */ 168static unsigned long 169dcssblk_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 */ 185static unsigned long 186dcssblk_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 */ 209static int 210dcssblk_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; 267out: 268 kfree(sort_list); 269 return rc; 270} 271 272/* 273 * Load a segment 274 */ 275static int 276dcssblk_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 307static void dcssblk_unregister_callback(struct device *dev) 308{ 309 device_unregister(dev); 310 put_device(dev); 311} 312 313/* 314 * device attribute for switching shared/nonshared (exclusive) 315 * operation (show + store) 316 */ 317static ssize_t 318dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf) 319{ 320 struct dcssblk_dev_info *dev_info; 321 322 dev_info = container_of(dev, struct dcssblk_dev_info, dev); 323 return sprintf(buf, dev_info->is_shared ? "1\n" : "0\n"); 324} 325 326static ssize_t 327dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count) 328{ 329 struct dcssblk_dev_info *dev_info; 330 struct segment_info *entry, *temp; 331 int rc; 332 333 if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0')) 334 return -EINVAL; 335 down_write(&dcssblk_devices_sem); 336 dev_info = container_of(dev, struct dcssblk_dev_info, dev); 337 if (atomic_read(&dev_info->use_count)) { 338 rc = -EBUSY; 339 goto out; 340 } 341 if (inbuf[0] == '1') { 342 /* reload segments in shared mode */ 343 list_for_each_entry(entry, &dev_info->seg_list, lh) { 344 rc = segment_modify_shared(entry->segment_name, 345 SEGMENT_SHARED); 346 if (rc < 0) { 347 BUG_ON(rc == -EINVAL); 348 if (rc != -EAGAIN) 349 goto removeseg; 350 } 351 } 352 dev_info->is_shared = 1; 353 switch (dev_info->segment_type) { 354 case SEG_TYPE_SR: 355 case SEG_TYPE_ER: 356 case SEG_TYPE_SC: 357 set_disk_ro(dev_info->gd, 1); 358 } 359 } else if (inbuf[0] == '0') { 360 /* reload segments in exclusive mode */ 361 if (dev_info->segment_type == SEG_TYPE_SC) { 362 pr_err("DCSS %s is of type SC and cannot be " 363 "loaded as exclusive-writable\n", 364 dev_info->segment_name); 365 rc = -EINVAL; 366 goto out; 367 } 368 list_for_each_entry(entry, &dev_info->seg_list, lh) { 369 rc = segment_modify_shared(entry->segment_name, 370 SEGMENT_EXCLUSIVE); 371 if (rc < 0) { 372 BUG_ON(rc == -EINVAL); 373 if (rc != -EAGAIN) 374 goto removeseg; 375 } 376 } 377 dev_info->is_shared = 0; 378 set_disk_ro(dev_info->gd, 0); 379 } else { 380 rc = -EINVAL; 381 goto out; 382 } 383 rc = count; 384 goto out; 385 386removeseg: 387 pr_err("DCSS device %s is removed after a failed access mode " 388 "change\n", dev_info->segment_name); 389 temp = entry; 390 list_for_each_entry(entry, &dev_info->seg_list, lh) { 391 if (entry != temp) 392 segment_unload(entry->segment_name); 393 } 394 list_del(&dev_info->lh); 395 396 del_gendisk(dev_info->gd); 397 blk_cleanup_queue(dev_info->dcssblk_queue); 398 dev_info->gd->queue = NULL; 399 put_disk(dev_info->gd); 400 rc = device_schedule_callback(dev, dcssblk_unregister_callback); 401out: 402 up_write(&dcssblk_devices_sem); 403 return rc; 404} 405static 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 */ 415static ssize_t 416dcssblk_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 424static ssize_t 425dcssblk_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 segment_save(entry->segment_name); 442 } 443 } else { 444 // device is busy => we save it when it becomes 445 // idle in dcssblk_release 446 pr_info("Device %s is in use, its DCSSs will be " 447 "saved when it becomes idle\n", 448 dev_info->segment_name); 449 dev_info->save_pending = 1; 450 } 451 } else if (inbuf[0] == '0') { 452 if (dev_info->save_pending) { 453 // device is busy & the user wants to undo his save 454 // request 455 dev_info->save_pending = 0; 456 pr_info("A pending save request for device %s " 457 "has been canceled\n", 458 dev_info->segment_name); 459 } 460 } else { 461 up_write(&dcssblk_devices_sem); 462 return -EINVAL; 463 } 464 up_write(&dcssblk_devices_sem); 465 return count; 466} 467static DEVICE_ATTR(save, S_IWUSR | S_IRUSR, dcssblk_save_show, 468 dcssblk_save_store); 469 470/* 471 * device attribute for showing all segments in a device 472 */ 473static ssize_t 474dcssblk_seglist_show(struct device *dev, struct device_attribute *attr, 475 char *buf) 476{ 477 int i; 478 479 struct dcssblk_dev_info *dev_info; 480 struct segment_info *entry; 481 482 down_read(&dcssblk_devices_sem); 483 dev_info = container_of(dev, struct dcssblk_dev_info, dev); 484 i = 0; 485 buf[0] = '\0'; 486 list_for_each_entry(entry, &dev_info->seg_list, lh) { 487 strcpy(&buf[i], entry->segment_name); 488 i += strlen(entry->segment_name); 489 buf[i] = '\n'; 490 i++; 491 } 492 up_read(&dcssblk_devices_sem); 493 return i; 494} 495static DEVICE_ATTR(seglist, S_IRUSR, dcssblk_seglist_show, NULL); 496 497static struct attribute *dcssblk_dev_attrs[] = { 498 &dev_attr_shared.attr, 499 &dev_attr_save.attr, 500 &dev_attr_seglist.attr, 501 NULL, 502}; 503static struct attribute_group dcssblk_dev_attr_group = { 504 .attrs = dcssblk_dev_attrs, 505}; 506static const struct attribute_group *dcssblk_dev_attr_groups[] = { 507 &dcssblk_dev_attr_group, 508 NULL, 509}; 510 511/* 512 * device attribute for adding devices 513 */ 514static ssize_t 515dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 516{ 517 int rc, i, j, num_of_segments; 518 struct dcssblk_dev_info *dev_info; 519 struct segment_info *seg_info, *temp; 520 char *local_buf; 521 unsigned long seg_byte_size; 522 523 dev_info = NULL; 524 seg_info = NULL; 525 if (dev != dcssblk_root_dev) { 526 rc = -EINVAL; 527 goto out_nobuf; 528 } 529 if ((count < 1) || (buf[0] == '\0') || (buf[0] == '\n')) { 530 rc = -ENAMETOOLONG; 531 goto out_nobuf; 532 } 533 534 local_buf = kmalloc(count + 1, GFP_KERNEL); 535 if (local_buf == NULL) { 536 rc = -ENOMEM; 537 goto out_nobuf; 538 } 539 540 /* 541 * parse input 542 */ 543 num_of_segments = 0; 544 for (i = 0; ((buf[i] != '\0') && (buf[i] != '\n') && i < count); i++) { 545 for (j = i; (buf[j] != ':') && 546 (buf[j] != '\0') && 547 (buf[j] != '\n') && 548 j < count; j++) { 549 local_buf[j-i] = toupper(buf[j]); 550 } 551 local_buf[j-i] = '\0'; 552 if (((j - i) == 0) || ((j - i) > 8)) { 553 rc = -ENAMETOOLONG; 554 goto seg_list_del; 555 } 556 557 rc = dcssblk_load_segment(local_buf, &seg_info); 558 if (rc < 0) 559 goto seg_list_del; 560 /* 561 * get a struct dcssblk_dev_info 562 */ 563 if (num_of_segments == 0) { 564 dev_info = kzalloc(sizeof(struct dcssblk_dev_info), 565 GFP_KERNEL); 566 if (dev_info == NULL) { 567 rc = -ENOMEM; 568 goto out; 569 } 570 strcpy(dev_info->segment_name, local_buf); 571 dev_info->segment_type = seg_info->segment_type; 572 INIT_LIST_HEAD(&dev_info->seg_list); 573 } 574 list_add_tail(&seg_info->lh, &dev_info->seg_list); 575 num_of_segments++; 576 i = j; 577 578 if ((buf[j] == '\0') || (buf[j] == '\n')) 579 break; 580 } 581 582 /* no trailing colon at the end of the input */ 583 if ((i > 0) && (buf[i-1] == ':')) { 584 rc = -ENAMETOOLONG; 585 goto seg_list_del; 586 } 587 strlcpy(local_buf, buf, i + 1); 588 dev_info->num_of_segments = num_of_segments; 589 rc = dcssblk_is_continuous(dev_info); 590 if (rc < 0) 591 goto seg_list_del; 592 593 dev_info->start = dcssblk_find_lowest_addr(dev_info); 594 dev_info->end = dcssblk_find_highest_addr(dev_info); 595 596 dev_set_name(&dev_info->dev, dev_info->segment_name); 597 dev_info->dev.release = dcssblk_release_segment; 598 dev_info->dev.groups = dcssblk_dev_attr_groups; 599 INIT_LIST_HEAD(&dev_info->lh); 600 dev_info->gd = alloc_disk(DCSSBLK_MINORS_PER_DISK); 601 if (dev_info->gd == NULL) { 602 rc = -ENOMEM; 603 goto seg_list_del; 604 } 605 dev_info->gd->major = dcssblk_major; 606 dev_info->gd->fops = &dcssblk_devops; 607 dev_info->dcssblk_queue = blk_alloc_queue(GFP_KERNEL); 608 dev_info->gd->queue = dev_info->dcssblk_queue; 609 dev_info->gd->private_data = dev_info; 610 dev_info->gd->driverfs_dev = &dev_info->dev; 611 blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request); 612 blk_queue_logical_block_size(dev_info->dcssblk_queue, 4096); 613 614 seg_byte_size = (dev_info->end - dev_info->start + 1); 615 set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors 616 pr_info("Loaded %s with total size %lu bytes and capacity %lu " 617 "sectors\n", local_buf, seg_byte_size, seg_byte_size >> 9); 618 619 dev_info->save_pending = 0; 620 dev_info->is_shared = 1; 621 dev_info->dev.parent = dcssblk_root_dev; 622 623 /* 624 *get minor, add to list 625 */ 626 down_write(&dcssblk_devices_sem); 627 if (dcssblk_get_segment_by_name(local_buf)) { 628 rc = -EEXIST; 629 goto release_gd; 630 } 631 rc = dcssblk_assign_free_minor(dev_info); 632 if (rc) 633 goto release_gd; 634 sprintf(dev_info->gd->disk_name, "dcssblk%d", 635 dev_info->gd->first_minor); 636 list_add_tail(&dev_info->lh, &dcssblk_devices); 637 638 if (!try_module_get(THIS_MODULE)) { 639 rc = -ENODEV; 640 goto dev_list_del; 641 } 642 /* 643 * register the device 644 */ 645 rc = device_register(&dev_info->dev); 646 if (rc) 647 goto put_dev; 648 649 get_device(&dev_info->dev); 650 add_disk(dev_info->gd); 651 652 switch (dev_info->segment_type) { 653 case SEG_TYPE_SR: 654 case SEG_TYPE_ER: 655 case SEG_TYPE_SC: 656 set_disk_ro(dev_info->gd,1); 657 break; 658 default: 659 set_disk_ro(dev_info->gd,0); 660 break; 661 } 662 up_write(&dcssblk_devices_sem); 663 rc = count; 664 goto out; 665 666put_dev: 667 list_del(&dev_info->lh); 668 blk_cleanup_queue(dev_info->dcssblk_queue); 669 dev_info->gd->queue = NULL; 670 put_disk(dev_info->gd); 671 list_for_each_entry(seg_info, &dev_info->seg_list, lh) { 672 segment_unload(seg_info->segment_name); 673 } 674 put_device(&dev_info->dev); 675 up_write(&dcssblk_devices_sem); 676 goto out; 677dev_list_del: 678 list_del(&dev_info->lh); 679release_gd: 680 blk_cleanup_queue(dev_info->dcssblk_queue); 681 dev_info->gd->queue = NULL; 682 put_disk(dev_info->gd); 683 up_write(&dcssblk_devices_sem); 684seg_list_del: 685 if (dev_info == NULL) 686 goto out; 687 list_for_each_entry_safe(seg_info, temp, &dev_info->seg_list, lh) { 688 list_del(&seg_info->lh); 689 segment_unload(seg_info->segment_name); 690 kfree(seg_info); 691 } 692 kfree(dev_info); 693out: 694 kfree(local_buf); 695out_nobuf: 696 return rc; 697} 698 699/* 700 * device attribute for removing devices 701 */ 702static ssize_t 703dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 704{ 705 struct dcssblk_dev_info *dev_info; 706 struct segment_info *entry; 707 int rc, i; 708 char *local_buf; 709 710 if (dev != dcssblk_root_dev) { 711 return -EINVAL; 712 } 713 local_buf = kmalloc(count + 1, GFP_KERNEL); 714 if (local_buf == NULL) { 715 return -ENOMEM; 716 } 717 /* 718 * parse input 719 */ 720 for (i = 0; ((*(buf+i)!='\0') && (*(buf+i)!='\n') && i < count); i++) { 721 local_buf[i] = toupper(buf[i]); 722 } 723 local_buf[i] = '\0'; 724 if ((i == 0) || (i > 8)) { 725 rc = -ENAMETOOLONG; 726 goto out_buf; 727 } 728 729 down_write(&dcssblk_devices_sem); 730 dev_info = dcssblk_get_device_by_name(local_buf); 731 if (dev_info == NULL) { 732 up_write(&dcssblk_devices_sem); 733 pr_warning("Device %s cannot be removed because it is not a " 734 "known device\n", local_buf); 735 rc = -ENODEV; 736 goto out_buf; 737 } 738 if (atomic_read(&dev_info->use_count) != 0) { 739 up_write(&dcssblk_devices_sem); 740 pr_warning("Device %s cannot be removed while it is in " 741 "use\n", local_buf); 742 rc = -EBUSY; 743 goto out_buf; 744 } 745 746 list_del(&dev_info->lh); 747 del_gendisk(dev_info->gd); 748 blk_cleanup_queue(dev_info->dcssblk_queue); 749 dev_info->gd->queue = NULL; 750 put_disk(dev_info->gd); 751 device_unregister(&dev_info->dev); 752 753 /* unload all related segments */ 754 list_for_each_entry(entry, &dev_info->seg_list, lh) 755 segment_unload(entry->segment_name); 756 757 put_device(&dev_info->dev); 758 up_write(&dcssblk_devices_sem); 759 760 rc = count; 761out_buf: 762 kfree(local_buf); 763 return rc; 764} 765 766static int 767dcssblk_open(struct block_device *bdev, fmode_t mode) 768{ 769 struct dcssblk_dev_info *dev_info; 770 int rc; 771 772 dev_info = bdev->bd_disk->private_data; 773 if (NULL == dev_info) { 774 rc = -ENODEV; 775 goto out; 776 } 777 atomic_inc(&dev_info->use_count); 778 bdev->bd_block_size = 4096; 779 rc = 0; 780out: 781 return rc; 782} 783 784static void 785dcssblk_release(struct gendisk *disk, fmode_t mode) 786{ 787 struct dcssblk_dev_info *dev_info = disk->private_data; 788 struct segment_info *entry; 789 790 if (!dev_info) { 791 WARN_ON(1); 792 return; 793 } 794 down_write(&dcssblk_devices_sem); 795 if (atomic_dec_and_test(&dev_info->use_count) 796 && (dev_info->save_pending)) { 797 pr_info("Device %s has become idle and is being saved " 798 "now\n", dev_info->segment_name); 799 list_for_each_entry(entry, &dev_info->seg_list, lh) { 800 segment_save(entry->segment_name); 801 } 802 dev_info->save_pending = 0; 803 } 804 up_write(&dcssblk_devices_sem); 805} 806 807static void 808dcssblk_make_request(struct request_queue *q, struct bio *bio) 809{ 810 struct dcssblk_dev_info *dev_info; 811 struct bio_vec *bvec; 812 unsigned long index; 813 unsigned long page_addr; 814 unsigned long source_addr; 815 unsigned long bytes_done; 816 int i; 817 818 bytes_done = 0; 819 dev_info = bio->bi_bdev->bd_disk->private_data; 820 if (dev_info == NULL) 821 goto fail; 822 if ((bio->bi_sector & 7) != 0 || (bio->bi_size & 4095) != 0) 823 /* Request is not page-aligned. */ 824 goto fail; 825 if (bio_end_sector(bio) > get_capacity(bio->bi_bdev->bd_disk)) { 826 /* Request beyond end of DCSS segment. */ 827 goto fail; 828 } 829 /* verify data transfer direction */ 830 if (dev_info->is_shared) { 831 switch (dev_info->segment_type) { 832 case SEG_TYPE_SR: 833 case SEG_TYPE_ER: 834 case SEG_TYPE_SC: 835 /* cannot write to these segments */ 836 if (bio_data_dir(bio) == WRITE) { 837 pr_warning("Writing to %s failed because it " 838 "is a read-only device\n", 839 dev_name(&dev_info->dev)); 840 goto fail; 841 } 842 } 843 } 844 845 index = (bio->bi_sector >> 3); 846 bio_for_each_segment(bvec, bio, i) { 847 page_addr = (unsigned long) 848 page_address(bvec->bv_page) + bvec->bv_offset; 849 source_addr = dev_info->start + (index<<12) + bytes_done; 850 if (unlikely((page_addr & 4095) != 0) || (bvec->bv_len & 4095) != 0) 851 // More paranoia. 852 goto fail; 853 if (bio_data_dir(bio) == READ) { 854 memcpy((void*)page_addr, (void*)source_addr, 855 bvec->bv_len); 856 } else { 857 memcpy((void*)source_addr, (void*)page_addr, 858 bvec->bv_len); 859 } 860 bytes_done += bvec->bv_len; 861 } 862 bio_endio(bio, 0); 863 return; 864fail: 865 bio_io_error(bio); 866} 867 868static int 869dcssblk_direct_access (struct block_device *bdev, sector_t secnum, 870 void **kaddr, unsigned long *pfn) 871{ 872 struct dcssblk_dev_info *dev_info; 873 unsigned long pgoff; 874 875 dev_info = bdev->bd_disk->private_data; 876 if (!dev_info) 877 return -ENODEV; 878 if (secnum % (PAGE_SIZE/512)) 879 return -EINVAL; 880 pgoff = secnum / (PAGE_SIZE / 512); 881 if ((pgoff+1)*PAGE_SIZE-1 > dev_info->end - dev_info->start) 882 return -ERANGE; 883 *kaddr = (void *) (dev_info->start+pgoff*PAGE_SIZE); 884 *pfn = virt_to_phys(*kaddr) >> PAGE_SHIFT; 885 886 return 0; 887} 888 889static void 890dcssblk_check_params(void) 891{ 892 int rc, i, j, k; 893 char buf[DCSSBLK_PARM_LEN + 1]; 894 struct dcssblk_dev_info *dev_info; 895 896 for (i = 0; (i < DCSSBLK_PARM_LEN) && (dcssblk_segments[i] != '\0'); 897 i++) { 898 for (j = i; (dcssblk_segments[j] != ',') && 899 (dcssblk_segments[j] != '\0') && 900 (dcssblk_segments[j] != '(') && 901 (j < DCSSBLK_PARM_LEN); j++) 902 { 903 buf[j-i] = dcssblk_segments[j]; 904 } 905 buf[j-i] = '\0'; 906 rc = dcssblk_add_store(dcssblk_root_dev, NULL, buf, j-i); 907 if ((rc >= 0) && (dcssblk_segments[j] == '(')) { 908 for (k = 0; (buf[k] != ':') && (buf[k] != '\0'); k++) 909 buf[k] = toupper(buf[k]); 910 buf[k] = '\0'; 911 if (!strncmp(&dcssblk_segments[j], "(local)", 7)) { 912 down_read(&dcssblk_devices_sem); 913 dev_info = dcssblk_get_device_by_name(buf); 914 up_read(&dcssblk_devices_sem); 915 if (dev_info) 916 dcssblk_shared_store(&dev_info->dev, 917 NULL, "0\n", 2); 918 } 919 } 920 while ((dcssblk_segments[j] != ',') && 921 (dcssblk_segments[j] != '\0')) 922 { 923 j++; 924 } 925 if (dcssblk_segments[j] == '\0') 926 break; 927 i = j; 928 } 929} 930 931/* 932 * Suspend / Resume 933 */ 934static int dcssblk_freeze(struct device *dev) 935{ 936 struct dcssblk_dev_info *dev_info; 937 int rc = 0; 938 939 list_for_each_entry(dev_info, &dcssblk_devices, lh) { 940 switch (dev_info->segment_type) { 941 case SEG_TYPE_SR: 942 case SEG_TYPE_ER: 943 case SEG_TYPE_SC: 944 if (!dev_info->is_shared) 945 rc = -EINVAL; 946 break; 947 default: 948 rc = -EINVAL; 949 break; 950 } 951 if (rc) 952 break; 953 } 954 if (rc) 955 pr_err("Suspending the system failed because DCSS device %s " 956 "is writable\n", 957 dev_info->segment_name); 958 return rc; 959} 960 961static int dcssblk_restore(struct device *dev) 962{ 963 struct dcssblk_dev_info *dev_info; 964 struct segment_info *entry; 965 unsigned long start, end; 966 int rc = 0; 967 968 list_for_each_entry(dev_info, &dcssblk_devices, lh) { 969 list_for_each_entry(entry, &dev_info->seg_list, lh) { 970 segment_unload(entry->segment_name); 971 rc = segment_load(entry->segment_name, SEGMENT_SHARED, 972 &start, &end); 973 if (rc < 0) { 974// TODO in_use check ? 975 segment_warning(rc, entry->segment_name); 976 goto out_panic; 977 } 978 if (start != entry->start || end != entry->end) { 979 pr_err("The address range of DCSS %s changed " 980 "while the system was suspended\n", 981 entry->segment_name); 982 goto out_panic; 983 } 984 } 985 } 986 return 0; 987out_panic: 988 panic("fatal dcssblk resume error\n"); 989} 990 991static int dcssblk_thaw(struct device *dev) 992{ 993 return 0; 994} 995 996static const struct dev_pm_ops dcssblk_pm_ops = { 997 .freeze = dcssblk_freeze, 998 .thaw = dcssblk_thaw, 999 .restore = dcssblk_restore, 1000}; 1001 1002static struct platform_driver dcssblk_pdrv = { 1003 .driver = { 1004 .name = "dcssblk", 1005 .owner = THIS_MODULE, 1006 .pm = &dcssblk_pm_ops, 1007 }, 1008}; 1009 1010static struct platform_device *dcssblk_pdev; 1011 1012 1013/* 1014 * The init/exit functions. 1015 */ 1016static void __exit 1017dcssblk_exit(void) 1018{ 1019 platform_device_unregister(dcssblk_pdev); 1020 platform_driver_unregister(&dcssblk_pdrv); 1021 root_device_unregister(dcssblk_root_dev); 1022 unregister_blkdev(dcssblk_major, DCSSBLK_NAME); 1023} 1024 1025static int __init 1026dcssblk_init(void) 1027{ 1028 int rc; 1029 1030 rc = platform_driver_register(&dcssblk_pdrv); 1031 if (rc) 1032 return rc; 1033 1034 dcssblk_pdev = platform_device_register_simple("dcssblk", -1, NULL, 1035 0); 1036 if (IS_ERR(dcssblk_pdev)) { 1037 rc = PTR_ERR(dcssblk_pdev); 1038 goto out_pdrv; 1039 } 1040 1041 dcssblk_root_dev = root_device_register("dcssblk"); 1042 if (IS_ERR(dcssblk_root_dev)) { 1043 rc = PTR_ERR(dcssblk_root_dev); 1044 goto out_pdev; 1045 } 1046 rc = device_create_file(dcssblk_root_dev, &dev_attr_add); 1047 if (rc) 1048 goto out_root; 1049 rc = device_create_file(dcssblk_root_dev, &dev_attr_remove); 1050 if (rc) 1051 goto out_root; 1052 rc = register_blkdev(0, DCSSBLK_NAME); 1053 if (rc < 0) 1054 goto out_root; 1055 dcssblk_major = rc; 1056 init_rwsem(&dcssblk_devices_sem); 1057 1058 dcssblk_check_params(); 1059 return 0; 1060 1061out_root: 1062 root_device_unregister(dcssblk_root_dev); 1063out_pdev: 1064 platform_device_unregister(dcssblk_pdev); 1065out_pdrv: 1066 platform_driver_unregister(&dcssblk_pdrv); 1067 return rc; 1068} 1069 1070module_init(dcssblk_init); 1071module_exit(dcssblk_exit); 1072 1073module_param_string(segments, dcssblk_segments, DCSSBLK_PARM_LEN, 0444); 1074MODULE_PARM_DESC(segments, "Name of DCSS segment(s) to be loaded, " 1075 "comma-separated list, names in each set separated " 1076 "by commas are separated by colons, each set contains " 1077 "names of contiguous segments and each name max. 8 chars.\n" 1078 "Adding \"(local)\" to the end of each set equals echoing 0 " 1079 "to /sys/devices/dcssblk/<device name>/shared after loading " 1080 "the contiguous segments - \n" 1081 "e.g. segments=\"mydcss1,mydcss2:mydcss3,mydcss4(local)\""); 1082 1083MODULE_LICENSE("GPL"); 1084