1 /* 2 * Linux driver for System z and s390 unit record devices 3 * (z/VM virtual punch, reader, printer) 4 * 5 * Copyright IBM Corp. 2001, 2009 6 * Authors: Malcolm Beattie <beattiem@uk.ibm.com> 7 * Michael Holzheu <holzheu@de.ibm.com> 8 * Frank Munzert <munzert@de.ibm.com> 9 */ 10 11 #define KMSG_COMPONENT "vmur" 12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 13 14 #include <linux/cdev.h> 15 #include <linux/slab.h> 16 #include <linux/smp_lock.h> 17 18 #include <asm/uaccess.h> 19 #include <asm/cio.h> 20 #include <asm/ccwdev.h> 21 #include <asm/debug.h> 22 #include <asm/diag.h> 23 24 #include "vmur.h" 25 26 /* 27 * Driver overview 28 * 29 * Unit record device support is implemented as a character device driver. 30 * We can fit at least 16 bits into a device minor number and use the 31 * simple method of mapping a character device number with minor abcd 32 * to the unit record device with devno abcd. 33 * I/O to virtual unit record devices is handled as follows: 34 * Reads: Diagnose code 0x14 (input spool file manipulation) 35 * is used to read spool data page-wise. 36 * Writes: The CCW used is WRITE_CCW_CMD (0x01). The device's record length 37 * is available by reading sysfs attr reclen. Each write() to the device 38 * must specify an integral multiple (maximal 511) of reclen. 39 */ 40 41 static char ur_banner[] = "z/VM virtual unit record device driver"; 42 43 MODULE_AUTHOR("IBM Corporation"); 44 MODULE_DESCRIPTION("s390 z/VM virtual unit record device driver"); 45 MODULE_LICENSE("GPL"); 46 47 static dev_t ur_first_dev_maj_min; 48 static struct class *vmur_class; 49 static struct debug_info *vmur_dbf; 50 51 /* We put the device's record length (for writes) in the driver_info field */ 52 static struct ccw_device_id ur_ids[] = { 53 { CCWDEV_CU_DI(READER_PUNCH_DEVTYPE, 80) }, 54 { CCWDEV_CU_DI(PRINTER_DEVTYPE, 132) }, 55 { /* end of list */ } 56 }; 57 58 MODULE_DEVICE_TABLE(ccw, ur_ids); 59 60 static int ur_probe(struct ccw_device *cdev); 61 static void ur_remove(struct ccw_device *cdev); 62 static int ur_set_online(struct ccw_device *cdev); 63 static int ur_set_offline(struct ccw_device *cdev); 64 static int ur_pm_suspend(struct ccw_device *cdev); 65 66 static struct ccw_driver ur_driver = { 67 .name = "vmur", 68 .owner = THIS_MODULE, 69 .ids = ur_ids, 70 .probe = ur_probe, 71 .remove = ur_remove, 72 .set_online = ur_set_online, 73 .set_offline = ur_set_offline, 74 .freeze = ur_pm_suspend, 75 }; 76 77 static DEFINE_MUTEX(vmur_mutex); 78 79 /* 80 * Allocation, freeing, getting and putting of urdev structures 81 * 82 * Each ur device (urd) contains a reference to its corresponding ccw device 83 * (cdev) using the urd->cdev pointer. Each ccw device has a reference to the 84 * ur device using dev_get_drvdata(&cdev->dev) pointer. 85 * 86 * urd references: 87 * - ur_probe gets a urd reference, ur_remove drops the reference 88 * dev_get_drvdata(&cdev->dev) 89 * - ur_open gets a urd reference, ur_relase drops the reference 90 * (urf->urd) 91 * 92 * cdev references: 93 * - urdev_alloc get a cdev reference (urd->cdev) 94 * - urdev_free drops the cdev reference (urd->cdev) 95 * 96 * Setting and clearing of dev_get_drvdata(&cdev->dev) is protected by the ccwdev lock 97 */ 98 static struct urdev *urdev_alloc(struct ccw_device *cdev) 99 { 100 struct urdev *urd; 101 102 urd = kzalloc(sizeof(struct urdev), GFP_KERNEL); 103 if (!urd) 104 return NULL; 105 urd->reclen = cdev->id.driver_info; 106 ccw_device_get_id(cdev, &urd->dev_id); 107 mutex_init(&urd->io_mutex); 108 init_waitqueue_head(&urd->wait); 109 spin_lock_init(&urd->open_lock); 110 atomic_set(&urd->ref_count, 1); 111 urd->cdev = cdev; 112 get_device(&cdev->dev); 113 return urd; 114 } 115 116 static void urdev_free(struct urdev *urd) 117 { 118 TRACE("urdev_free: %p\n", urd); 119 if (urd->cdev) 120 put_device(&urd->cdev->dev); 121 kfree(urd); 122 } 123 124 static void urdev_get(struct urdev *urd) 125 { 126 atomic_inc(&urd->ref_count); 127 } 128 129 static struct urdev *urdev_get_from_cdev(struct ccw_device *cdev) 130 { 131 struct urdev *urd; 132 unsigned long flags; 133 134 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 135 urd = dev_get_drvdata(&cdev->dev); 136 if (urd) 137 urdev_get(urd); 138 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 139 return urd; 140 } 141 142 static struct urdev *urdev_get_from_devno(u16 devno) 143 { 144 char bus_id[16]; 145 struct ccw_device *cdev; 146 struct urdev *urd; 147 148 sprintf(bus_id, "0.0.%04x", devno); 149 cdev = get_ccwdev_by_busid(&ur_driver, bus_id); 150 if (!cdev) 151 return NULL; 152 urd = urdev_get_from_cdev(cdev); 153 put_device(&cdev->dev); 154 return urd; 155 } 156 157 static void urdev_put(struct urdev *urd) 158 { 159 if (atomic_dec_and_test(&urd->ref_count)) 160 urdev_free(urd); 161 } 162 163 /* 164 * State and contents of ur devices can be changed by class D users issuing 165 * CP commands such as PURGE or TRANSFER, while the Linux guest is suspended. 166 * Also the Linux guest might be logged off, which causes all active spool 167 * files to be closed. 168 * So we cannot guarantee that spool files are still the same when the Linux 169 * guest is resumed. In order to avoid unpredictable results at resume time 170 * we simply refuse to suspend if a ur device node is open. 171 */ 172 static int ur_pm_suspend(struct ccw_device *cdev) 173 { 174 struct urdev *urd = dev_get_drvdata(&cdev->dev); 175 176 TRACE("ur_pm_suspend: cdev=%p\n", cdev); 177 if (urd->open_flag) { 178 pr_err("Unit record device %s is busy, %s refusing to " 179 "suspend.\n", dev_name(&cdev->dev), ur_banner); 180 return -EBUSY; 181 } 182 return 0; 183 } 184 185 /* 186 * Low-level functions to do I/O to a ur device. 187 * alloc_chan_prog 188 * free_chan_prog 189 * do_ur_io 190 * ur_int_handler 191 * 192 * alloc_chan_prog allocates and builds the channel program 193 * free_chan_prog frees memory of the channel program 194 * 195 * do_ur_io issues the channel program to the device and blocks waiting 196 * on a completion event it publishes at urd->io_done. The function 197 * serialises itself on the device's mutex so that only one I/O 198 * is issued at a time (and that I/O is synchronous). 199 * 200 * ur_int_handler catches the "I/O done" interrupt, writes the 201 * subchannel status word into the scsw member of the urdev structure 202 * and complete()s the io_done to wake the waiting do_ur_io. 203 * 204 * The caller of do_ur_io is responsible for kfree()ing the channel program 205 * address pointer that alloc_chan_prog returned. 206 */ 207 208 static void free_chan_prog(struct ccw1 *cpa) 209 { 210 struct ccw1 *ptr = cpa; 211 212 while (ptr->cda) { 213 kfree((void *)(addr_t) ptr->cda); 214 ptr++; 215 } 216 kfree(cpa); 217 } 218 219 /* 220 * alloc_chan_prog 221 * The channel program we use is write commands chained together 222 * with a final NOP CCW command-chained on (which ensures that CE and DE 223 * are presented together in a single interrupt instead of as separate 224 * interrupts unless an incorrect length indication kicks in first). The 225 * data length in each CCW is reclen. 226 */ 227 static struct ccw1 *alloc_chan_prog(const char __user *ubuf, int rec_count, 228 int reclen) 229 { 230 struct ccw1 *cpa; 231 void *kbuf; 232 int i; 233 234 TRACE("alloc_chan_prog(%p, %i, %i)\n", ubuf, rec_count, reclen); 235 236 /* 237 * We chain a NOP onto the writes to force CE+DE together. 238 * That means we allocate room for CCWs to cover count/reclen 239 * records plus a NOP. 240 */ 241 cpa = kzalloc((rec_count + 1) * sizeof(struct ccw1), 242 GFP_KERNEL | GFP_DMA); 243 if (!cpa) 244 return ERR_PTR(-ENOMEM); 245 246 for (i = 0; i < rec_count; i++) { 247 cpa[i].cmd_code = WRITE_CCW_CMD; 248 cpa[i].flags = CCW_FLAG_CC | CCW_FLAG_SLI; 249 cpa[i].count = reclen; 250 kbuf = kmalloc(reclen, GFP_KERNEL | GFP_DMA); 251 if (!kbuf) { 252 free_chan_prog(cpa); 253 return ERR_PTR(-ENOMEM); 254 } 255 cpa[i].cda = (u32)(addr_t) kbuf; 256 if (copy_from_user(kbuf, ubuf, reclen)) { 257 free_chan_prog(cpa); 258 return ERR_PTR(-EFAULT); 259 } 260 ubuf += reclen; 261 } 262 /* The following NOP CCW forces CE+DE to be presented together */ 263 cpa[i].cmd_code = CCW_CMD_NOOP; 264 return cpa; 265 } 266 267 static int do_ur_io(struct urdev *urd, struct ccw1 *cpa) 268 { 269 int rc; 270 struct ccw_device *cdev = urd->cdev; 271 DECLARE_COMPLETION_ONSTACK(event); 272 273 TRACE("do_ur_io: cpa=%p\n", cpa); 274 275 rc = mutex_lock_interruptible(&urd->io_mutex); 276 if (rc) 277 return rc; 278 279 urd->io_done = &event; 280 281 spin_lock_irq(get_ccwdev_lock(cdev)); 282 rc = ccw_device_start(cdev, cpa, 1, 0, 0); 283 spin_unlock_irq(get_ccwdev_lock(cdev)); 284 285 TRACE("do_ur_io: ccw_device_start returned %d\n", rc); 286 if (rc) 287 goto out; 288 289 wait_for_completion(&event); 290 TRACE("do_ur_io: I/O complete\n"); 291 rc = 0; 292 293 out: 294 mutex_unlock(&urd->io_mutex); 295 return rc; 296 } 297 298 /* 299 * ur interrupt handler, called from the ccw_device layer 300 */ 301 static void ur_int_handler(struct ccw_device *cdev, unsigned long intparm, 302 struct irb *irb) 303 { 304 struct urdev *urd; 305 306 TRACE("ur_int_handler: intparm=0x%lx cstat=%02x dstat=%02x res=%u\n", 307 intparm, irb->scsw.cmd.cstat, irb->scsw.cmd.dstat, 308 irb->scsw.cmd.count); 309 310 if (!intparm) { 311 TRACE("ur_int_handler: unsolicited interrupt\n"); 312 return; 313 } 314 urd = dev_get_drvdata(&cdev->dev); 315 BUG_ON(!urd); 316 /* On special conditions irb is an error pointer */ 317 if (IS_ERR(irb)) 318 urd->io_request_rc = PTR_ERR(irb); 319 else if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END)) 320 urd->io_request_rc = 0; 321 else 322 urd->io_request_rc = -EIO; 323 324 complete(urd->io_done); 325 } 326 327 /* 328 * reclen sysfs attribute - The record length to be used for write CCWs 329 */ 330 static ssize_t ur_attr_reclen_show(struct device *dev, 331 struct device_attribute *attr, char *buf) 332 { 333 struct urdev *urd; 334 int rc; 335 336 urd = urdev_get_from_cdev(to_ccwdev(dev)); 337 if (!urd) 338 return -ENODEV; 339 rc = sprintf(buf, "%zu\n", urd->reclen); 340 urdev_put(urd); 341 return rc; 342 } 343 344 static DEVICE_ATTR(reclen, 0444, ur_attr_reclen_show, NULL); 345 346 static int ur_create_attributes(struct device *dev) 347 { 348 return device_create_file(dev, &dev_attr_reclen); 349 } 350 351 static void ur_remove_attributes(struct device *dev) 352 { 353 device_remove_file(dev, &dev_attr_reclen); 354 } 355 356 /* 357 * diagnose code 0x210 - retrieve device information 358 * cc=0 normal completion, we have a real device 359 * cc=1 CP paging error 360 * cc=2 The virtual device exists, but is not associated with a real device 361 * cc=3 Invalid device address, or the virtual device does not exist 362 */ 363 static int get_urd_class(struct urdev *urd) 364 { 365 static struct diag210 ur_diag210; 366 int cc; 367 368 ur_diag210.vrdcdvno = urd->dev_id.devno; 369 ur_diag210.vrdclen = sizeof(struct diag210); 370 371 cc = diag210(&ur_diag210); 372 switch (cc) { 373 case 0: 374 return -EOPNOTSUPP; 375 case 2: 376 return ur_diag210.vrdcvcla; /* virtual device class */ 377 case 3: 378 return -ENODEV; 379 default: 380 return -EIO; 381 } 382 } 383 384 /* 385 * Allocation and freeing of urfile structures 386 */ 387 static struct urfile *urfile_alloc(struct urdev *urd) 388 { 389 struct urfile *urf; 390 391 urf = kzalloc(sizeof(struct urfile), GFP_KERNEL); 392 if (!urf) 393 return NULL; 394 urf->urd = urd; 395 396 TRACE("urfile_alloc: urd=%p urf=%p rl=%zu\n", urd, urf, 397 urf->dev_reclen); 398 399 return urf; 400 } 401 402 static void urfile_free(struct urfile *urf) 403 { 404 TRACE("urfile_free: urf=%p urd=%p\n", urf, urf->urd); 405 kfree(urf); 406 } 407 408 /* 409 * The fops implementation of the character device driver 410 */ 411 static ssize_t do_write(struct urdev *urd, const char __user *udata, 412 size_t count, size_t reclen, loff_t *ppos) 413 { 414 struct ccw1 *cpa; 415 int rc; 416 417 cpa = alloc_chan_prog(udata, count / reclen, reclen); 418 if (IS_ERR(cpa)) 419 return PTR_ERR(cpa); 420 421 rc = do_ur_io(urd, cpa); 422 if (rc) 423 goto fail_kfree_cpa; 424 425 if (urd->io_request_rc) { 426 rc = urd->io_request_rc; 427 goto fail_kfree_cpa; 428 } 429 *ppos += count; 430 rc = count; 431 432 fail_kfree_cpa: 433 free_chan_prog(cpa); 434 return rc; 435 } 436 437 static ssize_t ur_write(struct file *file, const char __user *udata, 438 size_t count, loff_t *ppos) 439 { 440 struct urfile *urf = file->private_data; 441 442 TRACE("ur_write: count=%zu\n", count); 443 444 if (count == 0) 445 return 0; 446 447 if (count % urf->dev_reclen) 448 return -EINVAL; /* count must be a multiple of reclen */ 449 450 if (count > urf->dev_reclen * MAX_RECS_PER_IO) 451 count = urf->dev_reclen * MAX_RECS_PER_IO; 452 453 return do_write(urf->urd, udata, count, urf->dev_reclen, ppos); 454 } 455 456 /* 457 * diagnose code 0x14 subcode 0x0028 - position spool file to designated 458 * record 459 * cc=0 normal completion 460 * cc=2 no file active on the virtual reader or device not ready 461 * cc=3 record specified is beyond EOF 462 */ 463 static int diag_position_to_record(int devno, int record) 464 { 465 int cc; 466 467 cc = diag14(record, devno, 0x28); 468 switch (cc) { 469 case 0: 470 return 0; 471 case 2: 472 return -ENOMEDIUM; 473 case 3: 474 return -ENODATA; /* position beyond end of file */ 475 default: 476 return -EIO; 477 } 478 } 479 480 /* 481 * diagnose code 0x14 subcode 0x0000 - read next spool file buffer 482 * cc=0 normal completion 483 * cc=1 EOF reached 484 * cc=2 no file active on the virtual reader, and no file eligible 485 * cc=3 file already active on the virtual reader or specified virtual 486 * reader does not exist or is not a reader 487 */ 488 static int diag_read_file(int devno, char *buf) 489 { 490 int cc; 491 492 cc = diag14((unsigned long) buf, devno, 0x00); 493 switch (cc) { 494 case 0: 495 return 0; 496 case 1: 497 return -ENODATA; 498 case 2: 499 return -ENOMEDIUM; 500 default: 501 return -EIO; 502 } 503 } 504 505 static ssize_t diag14_read(struct file *file, char __user *ubuf, size_t count, 506 loff_t *offs) 507 { 508 size_t len, copied, res; 509 char *buf; 510 int rc; 511 u16 reclen; 512 struct urdev *urd; 513 514 urd = ((struct urfile *) file->private_data)->urd; 515 reclen = ((struct urfile *) file->private_data)->file_reclen; 516 517 rc = diag_position_to_record(urd->dev_id.devno, *offs / PAGE_SIZE + 1); 518 if (rc == -ENODATA) 519 return 0; 520 if (rc) 521 return rc; 522 523 len = min((size_t) PAGE_SIZE, count); 524 buf = (char *) __get_free_page(GFP_KERNEL | GFP_DMA); 525 if (!buf) 526 return -ENOMEM; 527 528 copied = 0; 529 res = (size_t) (*offs % PAGE_SIZE); 530 do { 531 rc = diag_read_file(urd->dev_id.devno, buf); 532 if (rc == -ENODATA) { 533 break; 534 } 535 if (rc) 536 goto fail; 537 if (reclen && (copied == 0) && (*offs < PAGE_SIZE)) 538 *((u16 *) &buf[FILE_RECLEN_OFFSET]) = reclen; 539 len = min(count - copied, PAGE_SIZE - res); 540 if (copy_to_user(ubuf + copied, buf + res, len)) { 541 rc = -EFAULT; 542 goto fail; 543 } 544 res = 0; 545 copied += len; 546 } while (copied != count); 547 548 *offs += copied; 549 rc = copied; 550 fail: 551 free_page((unsigned long) buf); 552 return rc; 553 } 554 555 static ssize_t ur_read(struct file *file, char __user *ubuf, size_t count, 556 loff_t *offs) 557 { 558 struct urdev *urd; 559 int rc; 560 561 TRACE("ur_read: count=%zu ppos=%li\n", count, (unsigned long) *offs); 562 563 if (count == 0) 564 return 0; 565 566 urd = ((struct urfile *) file->private_data)->urd; 567 rc = mutex_lock_interruptible(&urd->io_mutex); 568 if (rc) 569 return rc; 570 rc = diag14_read(file, ubuf, count, offs); 571 mutex_unlock(&urd->io_mutex); 572 return rc; 573 } 574 575 /* 576 * diagnose code 0x14 subcode 0x0fff - retrieve next file descriptor 577 * cc=0 normal completion 578 * cc=1 no files on reader queue or no subsequent file 579 * cc=2 spid specified is invalid 580 */ 581 static int diag_read_next_file_info(struct file_control_block *buf, int spid) 582 { 583 int cc; 584 585 cc = diag14((unsigned long) buf, spid, 0xfff); 586 switch (cc) { 587 case 0: 588 return 0; 589 default: 590 return -ENODATA; 591 } 592 } 593 594 static int verify_uri_device(struct urdev *urd) 595 { 596 struct file_control_block *fcb; 597 char *buf; 598 int rc; 599 600 fcb = kmalloc(sizeof(*fcb), GFP_KERNEL | GFP_DMA); 601 if (!fcb) 602 return -ENOMEM; 603 604 /* check for empty reader device (beginning of chain) */ 605 rc = diag_read_next_file_info(fcb, 0); 606 if (rc) 607 goto fail_free_fcb; 608 609 /* if file is in hold status, we do not read it */ 610 if (fcb->file_stat & (FLG_SYSTEM_HOLD | FLG_USER_HOLD)) { 611 rc = -EPERM; 612 goto fail_free_fcb; 613 } 614 615 /* open file on virtual reader */ 616 buf = (char *) __get_free_page(GFP_KERNEL | GFP_DMA); 617 if (!buf) { 618 rc = -ENOMEM; 619 goto fail_free_fcb; 620 } 621 rc = diag_read_file(urd->dev_id.devno, buf); 622 if ((rc != 0) && (rc != -ENODATA)) /* EOF does not hurt */ 623 goto fail_free_buf; 624 625 /* check if the file on top of the queue is open now */ 626 rc = diag_read_next_file_info(fcb, 0); 627 if (rc) 628 goto fail_free_buf; 629 if (!(fcb->file_stat & FLG_IN_USE)) { 630 rc = -EMFILE; 631 goto fail_free_buf; 632 } 633 rc = 0; 634 635 fail_free_buf: 636 free_page((unsigned long) buf); 637 fail_free_fcb: 638 kfree(fcb); 639 return rc; 640 } 641 642 static int verify_device(struct urdev *urd) 643 { 644 switch (urd->class) { 645 case DEV_CLASS_UR_O: 646 return 0; /* no check needed here */ 647 case DEV_CLASS_UR_I: 648 return verify_uri_device(urd); 649 default: 650 return -EOPNOTSUPP; 651 } 652 } 653 654 static int get_uri_file_reclen(struct urdev *urd) 655 { 656 struct file_control_block *fcb; 657 int rc; 658 659 fcb = kmalloc(sizeof(*fcb), GFP_KERNEL | GFP_DMA); 660 if (!fcb) 661 return -ENOMEM; 662 rc = diag_read_next_file_info(fcb, 0); 663 if (rc) 664 goto fail_free; 665 if (fcb->file_stat & FLG_CP_DUMP) 666 rc = 0; 667 else 668 rc = fcb->rec_len; 669 670 fail_free: 671 kfree(fcb); 672 return rc; 673 } 674 675 static int get_file_reclen(struct urdev *urd) 676 { 677 switch (urd->class) { 678 case DEV_CLASS_UR_O: 679 return 0; 680 case DEV_CLASS_UR_I: 681 return get_uri_file_reclen(urd); 682 default: 683 return -EOPNOTSUPP; 684 } 685 } 686 687 static int ur_open(struct inode *inode, struct file *file) 688 { 689 u16 devno; 690 struct urdev *urd; 691 struct urfile *urf; 692 unsigned short accmode; 693 int rc; 694 695 accmode = file->f_flags & O_ACCMODE; 696 697 if (accmode == O_RDWR) 698 return -EACCES; 699 /* 700 * We treat the minor number as the devno of the ur device 701 * to find in the driver tree. 702 */ 703 devno = MINOR(file->f_dentry->d_inode->i_rdev); 704 705 urd = urdev_get_from_devno(devno); 706 if (!urd) { 707 rc = -ENXIO; 708 goto out; 709 } 710 711 spin_lock(&urd->open_lock); 712 while (urd->open_flag) { 713 spin_unlock(&urd->open_lock); 714 if (file->f_flags & O_NONBLOCK) { 715 rc = -EBUSY; 716 goto fail_put; 717 } 718 if (wait_event_interruptible(urd->wait, urd->open_flag == 0)) { 719 rc = -ERESTARTSYS; 720 goto fail_put; 721 } 722 spin_lock(&urd->open_lock); 723 } 724 urd->open_flag++; 725 spin_unlock(&urd->open_lock); 726 727 TRACE("ur_open\n"); 728 729 if (((accmode == O_RDONLY) && (urd->class != DEV_CLASS_UR_I)) || 730 ((accmode == O_WRONLY) && (urd->class != DEV_CLASS_UR_O))) { 731 TRACE("ur_open: unsupported dev class (%d)\n", urd->class); 732 rc = -EACCES; 733 goto fail_unlock; 734 } 735 736 rc = verify_device(urd); 737 if (rc) 738 goto fail_unlock; 739 740 urf = urfile_alloc(urd); 741 if (!urf) { 742 rc = -ENOMEM; 743 goto fail_unlock; 744 } 745 746 urf->dev_reclen = urd->reclen; 747 rc = get_file_reclen(urd); 748 if (rc < 0) 749 goto fail_urfile_free; 750 urf->file_reclen = rc; 751 file->private_data = urf; 752 return 0; 753 754 fail_urfile_free: 755 urfile_free(urf); 756 fail_unlock: 757 spin_lock(&urd->open_lock); 758 urd->open_flag--; 759 spin_unlock(&urd->open_lock); 760 fail_put: 761 urdev_put(urd); 762 out: 763 return rc; 764 } 765 766 static int ur_release(struct inode *inode, struct file *file) 767 { 768 struct urfile *urf = file->private_data; 769 770 TRACE("ur_release\n"); 771 spin_lock(&urf->urd->open_lock); 772 urf->urd->open_flag--; 773 spin_unlock(&urf->urd->open_lock); 774 wake_up_interruptible(&urf->urd->wait); 775 urdev_put(urf->urd); 776 urfile_free(urf); 777 return 0; 778 } 779 780 static loff_t ur_llseek(struct file *file, loff_t offset, int whence) 781 { 782 loff_t newpos; 783 784 if ((file->f_flags & O_ACCMODE) != O_RDONLY) 785 return -ESPIPE; /* seek allowed only for reader */ 786 if (offset % PAGE_SIZE) 787 return -ESPIPE; /* only multiples of 4K allowed */ 788 switch (whence) { 789 case 0: /* SEEK_SET */ 790 newpos = offset; 791 break; 792 case 1: /* SEEK_CUR */ 793 newpos = file->f_pos + offset; 794 break; 795 default: 796 return -EINVAL; 797 } 798 file->f_pos = newpos; 799 return newpos; 800 } 801 802 static const struct file_operations ur_fops = { 803 .owner = THIS_MODULE, 804 .open = ur_open, 805 .release = ur_release, 806 .read = ur_read, 807 .write = ur_write, 808 .llseek = ur_llseek, 809 }; 810 811 /* 812 * ccw_device infrastructure: 813 * ur_probe creates the struct urdev (with refcount = 1), the device 814 * attributes, sets up the interrupt handler and validates the virtual 815 * unit record device. 816 * ur_remove removes the device attributes and drops the reference to 817 * struct urdev. 818 * 819 * ur_probe, ur_remove, ur_set_online and ur_set_offline are serialized 820 * by the vmur_mutex lock. 821 * 822 * urd->char_device is used as indication that the online function has 823 * been completed successfully. 824 */ 825 static int ur_probe(struct ccw_device *cdev) 826 { 827 struct urdev *urd; 828 int rc; 829 830 TRACE("ur_probe: cdev=%p\n", cdev); 831 832 mutex_lock(&vmur_mutex); 833 urd = urdev_alloc(cdev); 834 if (!urd) { 835 rc = -ENOMEM; 836 goto fail_unlock; 837 } 838 839 rc = ur_create_attributes(&cdev->dev); 840 if (rc) { 841 rc = -ENOMEM; 842 goto fail_urdev_put; 843 } 844 cdev->handler = ur_int_handler; 845 846 /* validate virtual unit record device */ 847 urd->class = get_urd_class(urd); 848 if (urd->class < 0) { 849 rc = urd->class; 850 goto fail_remove_attr; 851 } 852 if ((urd->class != DEV_CLASS_UR_I) && (urd->class != DEV_CLASS_UR_O)) { 853 rc = -EOPNOTSUPP; 854 goto fail_remove_attr; 855 } 856 spin_lock_irq(get_ccwdev_lock(cdev)); 857 dev_set_drvdata(&cdev->dev, urd); 858 spin_unlock_irq(get_ccwdev_lock(cdev)); 859 860 mutex_unlock(&vmur_mutex); 861 return 0; 862 863 fail_remove_attr: 864 ur_remove_attributes(&cdev->dev); 865 fail_urdev_put: 866 urdev_put(urd); 867 fail_unlock: 868 mutex_unlock(&vmur_mutex); 869 return rc; 870 } 871 872 static int ur_set_online(struct ccw_device *cdev) 873 { 874 struct urdev *urd; 875 int minor, major, rc; 876 char node_id[16]; 877 878 TRACE("ur_set_online: cdev=%p\n", cdev); 879 880 mutex_lock(&vmur_mutex); 881 urd = urdev_get_from_cdev(cdev); 882 if (!urd) { 883 /* ur_remove already deleted our urd */ 884 rc = -ENODEV; 885 goto fail_unlock; 886 } 887 888 if (urd->char_device) { 889 /* Another ur_set_online was faster */ 890 rc = -EBUSY; 891 goto fail_urdev_put; 892 } 893 894 minor = urd->dev_id.devno; 895 major = MAJOR(ur_first_dev_maj_min); 896 897 urd->char_device = cdev_alloc(); 898 if (!urd->char_device) { 899 rc = -ENOMEM; 900 goto fail_urdev_put; 901 } 902 903 cdev_init(urd->char_device, &ur_fops); 904 urd->char_device->dev = MKDEV(major, minor); 905 urd->char_device->owner = ur_fops.owner; 906 907 rc = cdev_add(urd->char_device, urd->char_device->dev, 1); 908 if (rc) 909 goto fail_free_cdev; 910 if (urd->cdev->id.cu_type == READER_PUNCH_DEVTYPE) { 911 if (urd->class == DEV_CLASS_UR_I) 912 sprintf(node_id, "vmrdr-%s", dev_name(&cdev->dev)); 913 if (urd->class == DEV_CLASS_UR_O) 914 sprintf(node_id, "vmpun-%s", dev_name(&cdev->dev)); 915 } else if (urd->cdev->id.cu_type == PRINTER_DEVTYPE) { 916 sprintf(node_id, "vmprt-%s", dev_name(&cdev->dev)); 917 } else { 918 rc = -EOPNOTSUPP; 919 goto fail_free_cdev; 920 } 921 922 urd->device = device_create(vmur_class, NULL, urd->char_device->dev, 923 NULL, "%s", node_id); 924 if (IS_ERR(urd->device)) { 925 rc = PTR_ERR(urd->device); 926 TRACE("ur_set_online: device_create rc=%d\n", rc); 927 goto fail_free_cdev; 928 } 929 urdev_put(urd); 930 mutex_unlock(&vmur_mutex); 931 return 0; 932 933 fail_free_cdev: 934 cdev_del(urd->char_device); 935 urd->char_device = NULL; 936 fail_urdev_put: 937 urdev_put(urd); 938 fail_unlock: 939 mutex_unlock(&vmur_mutex); 940 return rc; 941 } 942 943 static int ur_set_offline_force(struct ccw_device *cdev, int force) 944 { 945 struct urdev *urd; 946 int rc; 947 948 TRACE("ur_set_offline: cdev=%p\n", cdev); 949 urd = urdev_get_from_cdev(cdev); 950 if (!urd) 951 /* ur_remove already deleted our urd */ 952 return -ENODEV; 953 if (!urd->char_device) { 954 /* Another ur_set_offline was faster */ 955 rc = -EBUSY; 956 goto fail_urdev_put; 957 } 958 if (!force && (atomic_read(&urd->ref_count) > 2)) { 959 /* There is still a user of urd (e.g. ur_open) */ 960 TRACE("ur_set_offline: BUSY\n"); 961 rc = -EBUSY; 962 goto fail_urdev_put; 963 } 964 device_destroy(vmur_class, urd->char_device->dev); 965 cdev_del(urd->char_device); 966 urd->char_device = NULL; 967 rc = 0; 968 969 fail_urdev_put: 970 urdev_put(urd); 971 return rc; 972 } 973 974 static int ur_set_offline(struct ccw_device *cdev) 975 { 976 int rc; 977 978 mutex_lock(&vmur_mutex); 979 rc = ur_set_offline_force(cdev, 0); 980 mutex_unlock(&vmur_mutex); 981 return rc; 982 } 983 984 static void ur_remove(struct ccw_device *cdev) 985 { 986 unsigned long flags; 987 988 TRACE("ur_remove\n"); 989 990 mutex_lock(&vmur_mutex); 991 992 if (cdev->online) 993 ur_set_offline_force(cdev, 1); 994 ur_remove_attributes(&cdev->dev); 995 996 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 997 urdev_put(dev_get_drvdata(&cdev->dev)); 998 dev_set_drvdata(&cdev->dev, NULL); 999 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 1000 1001 mutex_unlock(&vmur_mutex); 1002 } 1003 1004 /* 1005 * Module initialisation and cleanup 1006 */ 1007 static int __init ur_init(void) 1008 { 1009 int rc; 1010 dev_t dev; 1011 1012 if (!MACHINE_IS_VM) { 1013 pr_err("The %s cannot be loaded without z/VM\n", 1014 ur_banner); 1015 return -ENODEV; 1016 } 1017 1018 vmur_dbf = debug_register("vmur", 4, 1, 4 * sizeof(long)); 1019 if (!vmur_dbf) 1020 return -ENOMEM; 1021 rc = debug_register_view(vmur_dbf, &debug_sprintf_view); 1022 if (rc) 1023 goto fail_free_dbf; 1024 1025 debug_set_level(vmur_dbf, 6); 1026 1027 vmur_class = class_create(THIS_MODULE, "vmur"); 1028 if (IS_ERR(vmur_class)) { 1029 rc = PTR_ERR(vmur_class); 1030 goto fail_free_dbf; 1031 } 1032 1033 rc = ccw_driver_register(&ur_driver); 1034 if (rc) 1035 goto fail_class_destroy; 1036 1037 rc = alloc_chrdev_region(&dev, 0, NUM_MINORS, "vmur"); 1038 if (rc) { 1039 pr_err("Kernel function alloc_chrdev_region failed with " 1040 "error code %d\n", rc); 1041 goto fail_unregister_driver; 1042 } 1043 ur_first_dev_maj_min = MKDEV(MAJOR(dev), 0); 1044 1045 pr_info("%s loaded.\n", ur_banner); 1046 return 0; 1047 1048 fail_unregister_driver: 1049 ccw_driver_unregister(&ur_driver); 1050 fail_class_destroy: 1051 class_destroy(vmur_class); 1052 fail_free_dbf: 1053 debug_unregister(vmur_dbf); 1054 return rc; 1055 } 1056 1057 static void __exit ur_exit(void) 1058 { 1059 unregister_chrdev_region(ur_first_dev_maj_min, NUM_MINORS); 1060 ccw_driver_unregister(&ur_driver); 1061 class_destroy(vmur_class); 1062 debug_unregister(vmur_dbf); 1063 pr_info("%s unloaded.\n", ur_banner); 1064 } 1065 1066 module_init(ur_init); 1067 module_exit(ur_exit); 1068