dcssblk.c revision dbe13d9981e55c60a030d0509acc9a8968b9c5bf
1/* 2 * dcssblk.c -- the S/390 block driver for dcss memory 3 * 4 * Authors: Carsten Otte, Stefan Weinhuber, Gerald Schaefer 5 */ 6 7#include <linux/module.h> 8#include <linux/moduleparam.h> 9#include <linux/ctype.h> 10#include <linux/errno.h> 11#include <linux/init.h> 12#include <linux/slab.h> 13#include <linux/blkdev.h> 14#include <asm/extmem.h> 15#include <asm/io.h> 16#include <linux/completion.h> 17#include <linux/interrupt.h> 18#include <asm/s390_rdev.h> 19 20//#define DCSSBLK_DEBUG /* Debug messages on/off */ 21#define DCSSBLK_NAME "dcssblk" 22#define DCSSBLK_MINORS_PER_DISK 1 23#define DCSSBLK_PARM_LEN 400 24 25#ifdef DCSSBLK_DEBUG 26#define PRINT_DEBUG(x...) printk(KERN_DEBUG DCSSBLK_NAME " debug: " x) 27#else 28#define PRINT_DEBUG(x...) do {} while (0) 29#endif 30#define PRINT_INFO(x...) printk(KERN_INFO DCSSBLK_NAME " info: " x) 31#define PRINT_WARN(x...) printk(KERN_WARNING DCSSBLK_NAME " warning: " x) 32#define PRINT_ERR(x...) printk(KERN_ERR DCSSBLK_NAME " error: " x) 33 34 35static int dcssblk_open(struct inode *inode, struct file *filp); 36static int dcssblk_release(struct inode *inode, struct file *filp); 37static int dcssblk_make_request(struct request_queue *q, struct bio *bio); 38static int dcssblk_direct_access(struct block_device *bdev, sector_t secnum, 39 void **kaddr, unsigned long *pfn); 40 41static char dcssblk_segments[DCSSBLK_PARM_LEN] = "\0"; 42 43static int dcssblk_major; 44static struct block_device_operations dcssblk_devops = { 45 .owner = THIS_MODULE, 46 .open = dcssblk_open, 47 .release = dcssblk_release, 48 .direct_access = dcssblk_direct_access, 49}; 50 51static ssize_t dcssblk_add_store(struct device * dev, struct device_attribute *attr, const char * buf, 52 size_t count); 53static ssize_t dcssblk_remove_store(struct device * dev, struct device_attribute *attr, const char * buf, 54 size_t count); 55static ssize_t dcssblk_save_store(struct device * dev, struct device_attribute *attr, const char * buf, 56 size_t count); 57static ssize_t dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf); 58static ssize_t dcssblk_shared_store(struct device * dev, struct device_attribute *attr, const char * buf, 59 size_t count); 60static ssize_t dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf); 61 62static DEVICE_ATTR(add, S_IWUSR, NULL, dcssblk_add_store); 63static DEVICE_ATTR(remove, S_IWUSR, NULL, dcssblk_remove_store); 64static DEVICE_ATTR(save, S_IWUSR | S_IRUGO, dcssblk_save_show, 65 dcssblk_save_store); 66static DEVICE_ATTR(shared, S_IWUSR | S_IRUGO, dcssblk_shared_show, 67 dcssblk_shared_store); 68 69static struct device *dcssblk_root_dev; 70 71struct dcssblk_dev_info { 72 struct list_head lh; 73 struct device dev; 74 char segment_name[BUS_ID_SIZE]; 75 atomic_t use_count; 76 struct gendisk *gd; 77 unsigned long start; 78 unsigned long end; 79 int segment_type; 80 unsigned char save_pending; 81 unsigned char is_shared; 82 struct request_queue *dcssblk_queue; 83}; 84 85static LIST_HEAD(dcssblk_devices); 86static struct rw_semaphore dcssblk_devices_sem; 87 88/* 89 * release function for segment device. 90 */ 91static void 92dcssblk_release_segment(struct device *dev) 93{ 94 PRINT_DEBUG("segment release fn called for %s\n", dev->bus_id); 95 kfree(container_of(dev, struct dcssblk_dev_info, dev)); 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 145static void dcssblk_unregister_callback(struct device *dev) 146{ 147 device_unregister(dev); 148 put_device(dev); 149} 150 151/* 152 * device attribute for switching shared/nonshared (exclusive) 153 * operation (show + store) 154 */ 155static ssize_t 156dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf) 157{ 158 struct dcssblk_dev_info *dev_info; 159 160 dev_info = container_of(dev, struct dcssblk_dev_info, dev); 161 return sprintf(buf, dev_info->is_shared ? "1\n" : "0\n"); 162} 163 164static ssize_t 165dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count) 166{ 167 struct dcssblk_dev_info *dev_info; 168 int rc; 169 170 if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0')) 171 return -EINVAL; 172 down_write(&dcssblk_devices_sem); 173 dev_info = container_of(dev, struct dcssblk_dev_info, dev); 174 if (atomic_read(&dev_info->use_count)) { 175 PRINT_ERR("share: segment %s is busy!\n", 176 dev_info->segment_name); 177 rc = -EBUSY; 178 goto out; 179 } 180 if (inbuf[0] == '1') { 181 // reload segment in shared mode 182 rc = segment_modify_shared(dev_info->segment_name, 183 SEGMENT_SHARED); 184 if (rc < 0) { 185 BUG_ON(rc == -EINVAL); 186 if (rc != -EAGAIN) 187 goto removeseg; 188 } else { 189 dev_info->is_shared = 1; 190 switch (dev_info->segment_type) { 191 case SEG_TYPE_SR: 192 case SEG_TYPE_ER: 193 case SEG_TYPE_SC: 194 set_disk_ro(dev_info->gd,1); 195 } 196 } 197 } else if (inbuf[0] == '0') { 198 // reload segment in exclusive mode 199 if (dev_info->segment_type == SEG_TYPE_SC) { 200 PRINT_ERR("Segment type SC (%s) cannot be loaded in " 201 "non-shared mode\n", dev_info->segment_name); 202 rc = -EINVAL; 203 goto out; 204 } 205 rc = segment_modify_shared(dev_info->segment_name, 206 SEGMENT_EXCLUSIVE); 207 if (rc < 0) { 208 BUG_ON(rc == -EINVAL); 209 if (rc != -EAGAIN) 210 goto removeseg; 211 } else { 212 dev_info->is_shared = 0; 213 set_disk_ro(dev_info->gd, 0); 214 } 215 } else { 216 rc = -EINVAL; 217 goto out; 218 } 219 rc = count; 220 goto out; 221 222removeseg: 223 PRINT_ERR("Could not reload segment %s, removing it now!\n", 224 dev_info->segment_name); 225 list_del(&dev_info->lh); 226 227 del_gendisk(dev_info->gd); 228 blk_cleanup_queue(dev_info->dcssblk_queue); 229 dev_info->gd->queue = NULL; 230 put_disk(dev_info->gd); 231 rc = device_schedule_callback(dev, dcssblk_unregister_callback); 232out: 233 up_write(&dcssblk_devices_sem); 234 return rc; 235} 236 237/* 238 * device attribute for save operation on current copy 239 * of the segment. If the segment is busy, saving will 240 * become pending until it gets released, which can be 241 * undone by storing a non-true value to this entry. 242 * (show + store) 243 */ 244static ssize_t 245dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf) 246{ 247 struct dcssblk_dev_info *dev_info; 248 249 dev_info = container_of(dev, struct dcssblk_dev_info, dev); 250 return sprintf(buf, dev_info->save_pending ? "1\n" : "0\n"); 251} 252 253static ssize_t 254dcssblk_save_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count) 255{ 256 struct dcssblk_dev_info *dev_info; 257 258 if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0')) 259 return -EINVAL; 260 dev_info = container_of(dev, struct dcssblk_dev_info, dev); 261 262 down_write(&dcssblk_devices_sem); 263 if (inbuf[0] == '1') { 264 if (atomic_read(&dev_info->use_count) == 0) { 265 // device is idle => we save immediately 266 PRINT_INFO("Saving segment %s\n", 267 dev_info->segment_name); 268 segment_save(dev_info->segment_name); 269 } else { 270 // device is busy => we save it when it becomes 271 // idle in dcssblk_release 272 PRINT_INFO("Segment %s is currently busy, it will " 273 "be saved when it becomes idle...\n", 274 dev_info->segment_name); 275 dev_info->save_pending = 1; 276 } 277 } else if (inbuf[0] == '0') { 278 if (dev_info->save_pending) { 279 // device is busy & the user wants to undo his save 280 // request 281 dev_info->save_pending = 0; 282 PRINT_INFO("Pending save for segment %s deactivated\n", 283 dev_info->segment_name); 284 } 285 } else { 286 up_write(&dcssblk_devices_sem); 287 return -EINVAL; 288 } 289 up_write(&dcssblk_devices_sem); 290 return count; 291} 292 293/* 294 * device attribute for adding devices 295 */ 296static ssize_t 297dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 298{ 299 int rc, i; 300 struct dcssblk_dev_info *dev_info; 301 char *local_buf; 302 unsigned long seg_byte_size; 303 304 dev_info = NULL; 305 if (dev != dcssblk_root_dev) { 306 rc = -EINVAL; 307 goto out_nobuf; 308 } 309 local_buf = kmalloc(count + 1, GFP_KERNEL); 310 if (local_buf == NULL) { 311 rc = -ENOMEM; 312 goto out_nobuf; 313 } 314 /* 315 * parse input 316 */ 317 for (i = 0; ((buf[i] != '\0') && (buf[i] != '\n') && i < count); i++) { 318 local_buf[i] = toupper(buf[i]); 319 } 320 local_buf[i] = '\0'; 321 if ((i == 0) || (i > 8)) { 322 rc = -ENAMETOOLONG; 323 goto out; 324 } 325 /* 326 * already loaded? 327 */ 328 down_read(&dcssblk_devices_sem); 329 dev_info = dcssblk_get_device_by_name(local_buf); 330 up_read(&dcssblk_devices_sem); 331 if (dev_info != NULL) { 332 PRINT_WARN("Segment %s already loaded!\n", local_buf); 333 rc = -EEXIST; 334 goto out; 335 } 336 /* 337 * get a struct dcssblk_dev_info 338 */ 339 dev_info = kzalloc(sizeof(struct dcssblk_dev_info), GFP_KERNEL); 340 if (dev_info == NULL) { 341 rc = -ENOMEM; 342 goto out; 343 } 344 345 strcpy(dev_info->segment_name, local_buf); 346 strlcpy(dev_info->dev.bus_id, local_buf, BUS_ID_SIZE); 347 dev_info->dev.release = dcssblk_release_segment; 348 INIT_LIST_HEAD(&dev_info->lh); 349 350 dev_info->gd = alloc_disk(DCSSBLK_MINORS_PER_DISK); 351 if (dev_info->gd == NULL) { 352 rc = -ENOMEM; 353 goto free_dev_info; 354 } 355 dev_info->gd->major = dcssblk_major; 356 dev_info->gd->fops = &dcssblk_devops; 357 dev_info->dcssblk_queue = blk_alloc_queue(GFP_KERNEL); 358 dev_info->gd->queue = dev_info->dcssblk_queue; 359 dev_info->gd->private_data = dev_info; 360 dev_info->gd->driverfs_dev = &dev_info->dev; 361 blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request); 362 blk_queue_hardsect_size(dev_info->dcssblk_queue, 4096); 363 /* 364 * load the segment 365 */ 366 rc = segment_load(local_buf, SEGMENT_SHARED, 367 &dev_info->start, &dev_info->end); 368 if (rc < 0) { 369 segment_warning(rc, dev_info->segment_name); 370 goto dealloc_gendisk; 371 } 372 seg_byte_size = (dev_info->end - dev_info->start + 1); 373 set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors 374 PRINT_INFO("Loaded segment %s, size = %lu Byte, " 375 "capacity = %lu (512 Byte) sectors\n", local_buf, 376 seg_byte_size, seg_byte_size >> 9); 377 378 dev_info->segment_type = rc; 379 dev_info->save_pending = 0; 380 dev_info->is_shared = 1; 381 dev_info->dev.parent = dcssblk_root_dev; 382 383 /* 384 * get minor, add to list 385 */ 386 down_write(&dcssblk_devices_sem); 387 if (dcssblk_get_device_by_name(local_buf)) { 388 up_write(&dcssblk_devices_sem); 389 rc = -EEXIST; 390 goto unload_seg; 391 } 392 rc = dcssblk_assign_free_minor(dev_info); 393 if (rc) { 394 up_write(&dcssblk_devices_sem); 395 PRINT_ERR("No free minor number available! " 396 "Unloading segment...\n"); 397 goto unload_seg; 398 } 399 sprintf(dev_info->gd->disk_name, "dcssblk%d", 400 dev_info->gd->first_minor); 401 list_add_tail(&dev_info->lh, &dcssblk_devices); 402 403 if (!try_module_get(THIS_MODULE)) { 404 rc = -ENODEV; 405 goto list_del; 406 } 407 /* 408 * register the device 409 */ 410 rc = device_register(&dev_info->dev); 411 if (rc) { 412 PRINT_ERR("Segment %s could not be registered RC=%d\n", 413 local_buf, rc); 414 module_put(THIS_MODULE); 415 goto list_del; 416 } 417 get_device(&dev_info->dev); 418 rc = device_create_file(&dev_info->dev, &dev_attr_shared); 419 if (rc) 420 goto unregister_dev; 421 rc = device_create_file(&dev_info->dev, &dev_attr_save); 422 if (rc) 423 goto unregister_dev; 424 425 add_disk(dev_info->gd); 426 427 switch (dev_info->segment_type) { 428 case SEG_TYPE_SR: 429 case SEG_TYPE_ER: 430 case SEG_TYPE_SC: 431 set_disk_ro(dev_info->gd,1); 432 break; 433 default: 434 set_disk_ro(dev_info->gd,0); 435 break; 436 } 437 PRINT_DEBUG("Segment %s loaded successfully\n", local_buf); 438 up_write(&dcssblk_devices_sem); 439 rc = count; 440 goto out; 441 442unregister_dev: 443 list_del(&dev_info->lh); 444 blk_cleanup_queue(dev_info->dcssblk_queue); 445 dev_info->gd->queue = NULL; 446 put_disk(dev_info->gd); 447 device_unregister(&dev_info->dev); 448 segment_unload(dev_info->segment_name); 449 put_device(&dev_info->dev); 450 up_write(&dcssblk_devices_sem); 451 goto out; 452list_del: 453 list_del(&dev_info->lh); 454 up_write(&dcssblk_devices_sem); 455unload_seg: 456 segment_unload(local_buf); 457dealloc_gendisk: 458 blk_cleanup_queue(dev_info->dcssblk_queue); 459 dev_info->gd->queue = NULL; 460 put_disk(dev_info->gd); 461free_dev_info: 462 kfree(dev_info); 463out: 464 kfree(local_buf); 465out_nobuf: 466 return rc; 467} 468 469/* 470 * device attribute for removing devices 471 */ 472static ssize_t 473dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 474{ 475 struct dcssblk_dev_info *dev_info; 476 int rc, i; 477 char *local_buf; 478 479 if (dev != dcssblk_root_dev) { 480 return -EINVAL; 481 } 482 local_buf = kmalloc(count + 1, GFP_KERNEL); 483 if (local_buf == NULL) { 484 return -ENOMEM; 485 } 486 /* 487 * parse input 488 */ 489 for (i = 0; ((*(buf+i)!='\0') && (*(buf+i)!='\n') && i < count); i++) { 490 local_buf[i] = toupper(buf[i]); 491 } 492 local_buf[i] = '\0'; 493 if ((i == 0) || (i > 8)) { 494 rc = -ENAMETOOLONG; 495 goto out_buf; 496 } 497 498 down_write(&dcssblk_devices_sem); 499 dev_info = dcssblk_get_device_by_name(local_buf); 500 if (dev_info == NULL) { 501 up_write(&dcssblk_devices_sem); 502 PRINT_WARN("Segment %s is not loaded!\n", local_buf); 503 rc = -ENODEV; 504 goto out_buf; 505 } 506 if (atomic_read(&dev_info->use_count) != 0) { 507 up_write(&dcssblk_devices_sem); 508 PRINT_WARN("Segment %s is in use!\n", local_buf); 509 rc = -EBUSY; 510 goto out_buf; 511 } 512 list_del(&dev_info->lh); 513 514 del_gendisk(dev_info->gd); 515 blk_cleanup_queue(dev_info->dcssblk_queue); 516 dev_info->gd->queue = NULL; 517 put_disk(dev_info->gd); 518 device_unregister(&dev_info->dev); 519 segment_unload(dev_info->segment_name); 520 PRINT_DEBUG("Segment %s unloaded successfully\n", 521 dev_info->segment_name); 522 put_device(&dev_info->dev); 523 up_write(&dcssblk_devices_sem); 524 525 rc = count; 526out_buf: 527 kfree(local_buf); 528 return rc; 529} 530 531static int 532dcssblk_open(struct inode *inode, struct file *filp) 533{ 534 struct dcssblk_dev_info *dev_info; 535 int rc; 536 537 dev_info = inode->i_bdev->bd_disk->private_data; 538 if (NULL == dev_info) { 539 rc = -ENODEV; 540 goto out; 541 } 542 atomic_inc(&dev_info->use_count); 543 inode->i_bdev->bd_block_size = 4096; 544 rc = 0; 545out: 546 return rc; 547} 548 549static int 550dcssblk_release(struct inode *inode, struct file *filp) 551{ 552 struct dcssblk_dev_info *dev_info; 553 int rc; 554 555 dev_info = inode->i_bdev->bd_disk->private_data; 556 if (NULL == dev_info) { 557 rc = -ENODEV; 558 goto out; 559 } 560 down_write(&dcssblk_devices_sem); 561 if (atomic_dec_and_test(&dev_info->use_count) 562 && (dev_info->save_pending)) { 563 PRINT_INFO("Segment %s became idle and is being saved now\n", 564 dev_info->segment_name); 565 segment_save(dev_info->segment_name); 566 dev_info->save_pending = 0; 567 } 568 up_write(&dcssblk_devices_sem); 569 rc = 0; 570out: 571 return rc; 572} 573 574static int 575dcssblk_make_request(struct request_queue *q, struct bio *bio) 576{ 577 struct dcssblk_dev_info *dev_info; 578 struct bio_vec *bvec; 579 unsigned long index; 580 unsigned long page_addr; 581 unsigned long source_addr; 582 unsigned long bytes_done; 583 int i; 584 585 bytes_done = 0; 586 dev_info = bio->bi_bdev->bd_disk->private_data; 587 if (dev_info == NULL) 588 goto fail; 589 if ((bio->bi_sector & 7) != 0 || (bio->bi_size & 4095) != 0) 590 /* Request is not page-aligned. */ 591 goto fail; 592 if (((bio->bi_size >> 9) + bio->bi_sector) 593 > get_capacity(bio->bi_bdev->bd_disk)) { 594 /* Request beyond end of DCSS segment. */ 595 goto fail; 596 } 597 /* verify data transfer direction */ 598 if (dev_info->is_shared) { 599 switch (dev_info->segment_type) { 600 case SEG_TYPE_SR: 601 case SEG_TYPE_ER: 602 case SEG_TYPE_SC: 603 /* cannot write to these segments */ 604 if (bio_data_dir(bio) == WRITE) { 605 PRINT_WARN("rejecting write to ro segment %s\n", dev_info->dev.bus_id); 606 goto fail; 607 } 608 } 609 } 610 611 index = (bio->bi_sector >> 3); 612 bio_for_each_segment(bvec, bio, i) { 613 page_addr = (unsigned long) 614 page_address(bvec->bv_page) + bvec->bv_offset; 615 source_addr = dev_info->start + (index<<12) + bytes_done; 616 if (unlikely((page_addr & 4095) != 0) || (bvec->bv_len & 4095) != 0) 617 // More paranoia. 618 goto fail; 619 if (bio_data_dir(bio) == READ) { 620 memcpy((void*)page_addr, (void*)source_addr, 621 bvec->bv_len); 622 } else { 623 memcpy((void*)source_addr, (void*)page_addr, 624 bvec->bv_len); 625 } 626 bytes_done += bvec->bv_len; 627 } 628 bio_endio(bio, 0); 629 return 0; 630fail: 631 bio_io_error(bio); 632 return 0; 633} 634 635static int 636dcssblk_direct_access (struct block_device *bdev, sector_t secnum, 637 void **kaddr, unsigned long *pfn) 638{ 639 struct dcssblk_dev_info *dev_info; 640 unsigned long pgoff; 641 642 dev_info = bdev->bd_disk->private_data; 643 if (!dev_info) 644 return -ENODEV; 645 if (secnum % (PAGE_SIZE/512)) 646 return -EINVAL; 647 pgoff = secnum / (PAGE_SIZE / 512); 648 if ((pgoff+1)*PAGE_SIZE-1 > dev_info->end - dev_info->start) 649 return -ERANGE; 650 *kaddr = (void *) (dev_info->start+pgoff*PAGE_SIZE); 651 *pfn = virt_to_phys(*kaddr) >> PAGE_SHIFT; 652 653 return 0; 654} 655 656static void 657dcssblk_check_params(void) 658{ 659 int rc, i, j, k; 660 char buf[9]; 661 struct dcssblk_dev_info *dev_info; 662 663 for (i = 0; (i < DCSSBLK_PARM_LEN) && (dcssblk_segments[i] != '\0'); 664 i++) { 665 for (j = i; (dcssblk_segments[j] != ',') && 666 (dcssblk_segments[j] != '\0') && 667 (dcssblk_segments[j] != '(') && 668 (j - i) < 8; j++) 669 { 670 buf[j-i] = dcssblk_segments[j]; 671 } 672 buf[j-i] = '\0'; 673 rc = dcssblk_add_store(dcssblk_root_dev, NULL, buf, j-i); 674 if ((rc >= 0) && (dcssblk_segments[j] == '(')) { 675 for (k = 0; buf[k] != '\0'; k++) 676 buf[k] = toupper(buf[k]); 677 if (!strncmp(&dcssblk_segments[j], "(local)", 7)) { 678 down_read(&dcssblk_devices_sem); 679 dev_info = dcssblk_get_device_by_name(buf); 680 up_read(&dcssblk_devices_sem); 681 if (dev_info) 682 dcssblk_shared_store(&dev_info->dev, 683 NULL, "0\n", 2); 684 } 685 } 686 while ((dcssblk_segments[j] != ',') && 687 (dcssblk_segments[j] != '\0')) 688 { 689 j++; 690 } 691 if (dcssblk_segments[j] == '\0') 692 break; 693 i = j; 694 } 695} 696 697/* 698 * The init/exit functions. 699 */ 700static void __exit 701dcssblk_exit(void) 702{ 703 s390_root_dev_unregister(dcssblk_root_dev); 704 unregister_blkdev(dcssblk_major, DCSSBLK_NAME); 705} 706 707static int __init 708dcssblk_init(void) 709{ 710 int rc; 711 712 dcssblk_root_dev = s390_root_dev_register("dcssblk"); 713 if (IS_ERR(dcssblk_root_dev)) 714 return PTR_ERR(dcssblk_root_dev); 715 rc = device_create_file(dcssblk_root_dev, &dev_attr_add); 716 if (rc) { 717 s390_root_dev_unregister(dcssblk_root_dev); 718 return rc; 719 } 720 rc = device_create_file(dcssblk_root_dev, &dev_attr_remove); 721 if (rc) { 722 s390_root_dev_unregister(dcssblk_root_dev); 723 return rc; 724 } 725 rc = register_blkdev(0, DCSSBLK_NAME); 726 if (rc < 0) { 727 s390_root_dev_unregister(dcssblk_root_dev); 728 return rc; 729 } 730 dcssblk_major = rc; 731 init_rwsem(&dcssblk_devices_sem); 732 733 dcssblk_check_params(); 734 735 return 0; 736} 737 738module_init(dcssblk_init); 739module_exit(dcssblk_exit); 740 741module_param_string(segments, dcssblk_segments, DCSSBLK_PARM_LEN, 0444); 742MODULE_PARM_DESC(segments, "Name of DCSS segment(s) to be loaded, " 743 "comma-separated list, each name max. 8 chars.\n" 744 "Adding \"(local)\" to segment name equals echoing 0 to " 745 "/sys/devices/dcssblk/<segment name>/shared after loading " 746 "the segment - \n" 747 "e.g. segments=\"mydcss1,mydcss2,mydcss3(local)\""); 748 749MODULE_LICENSE("GPL"); 750