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