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