1 /* 2 * Copyright (C) 2000 Jens Axboe <axboe@suse.de> 3 * Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com> 4 * Copyright (C) 2006 Thomas Maier <balagi@justmail.de> 5 * 6 * May be copied or modified under the terms of the GNU General Public 7 * License. See linux/COPYING for more information. 8 * 9 * Packet writing layer for ATAPI and SCSI CD-RW, DVD+RW, DVD-RW and 10 * DVD-RAM devices. 11 * 12 * Theory of operation: 13 * 14 * At the lowest level, there is the standard driver for the CD/DVD device, 15 * such as drivers/scsi/sr.c. This driver can handle read and write requests, 16 * but it doesn't know anything about the special restrictions that apply to 17 * packet writing. One restriction is that write requests must be aligned to 18 * packet boundaries on the physical media, and the size of a write request 19 * must be equal to the packet size. Another restriction is that a 20 * GPCMD_FLUSH_CACHE command has to be issued to the drive before a read 21 * command, if the previous command was a write. 22 * 23 * The purpose of the packet writing driver is to hide these restrictions from 24 * higher layers, such as file systems, and present a block device that can be 25 * randomly read and written using 2kB-sized blocks. 26 * 27 * The lowest layer in the packet writing driver is the packet I/O scheduler. 28 * Its data is defined by the struct packet_iosched and includes two bio 29 * queues with pending read and write requests. These queues are processed 30 * by the pkt_iosched_process_queue() function. The write requests in this 31 * queue are already properly aligned and sized. This layer is responsible for 32 * issuing the flush cache commands and scheduling the I/O in a good order. 33 * 34 * The next layer transforms unaligned write requests to aligned writes. This 35 * transformation requires reading missing pieces of data from the underlying 36 * block device, assembling the pieces to full packets and queuing them to the 37 * packet I/O scheduler. 38 * 39 * At the top layer there is a custom ->submit_bio function that forwards 40 * read requests directly to the iosched queue and puts write requests in the 41 * unaligned write queue. A kernel thread performs the necessary read 42 * gathering to convert the unaligned writes to aligned writes and then feeds 43 * them to the packet I/O scheduler. 44 * 45 *************************************************************************/ 46 47 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 48 49 #include <linux/backing-dev.h> 50 #include <linux/compat.h> 51 #include <linux/debugfs.h> 52 #include <linux/device.h> 53 #include <linux/errno.h> 54 #include <linux/file.h> 55 #include <linux/freezer.h> 56 #include <linux/kernel.h> 57 #include <linux/kthread.h> 58 #include <linux/miscdevice.h> 59 #include <linux/module.h> 60 #include <linux/mutex.h> 61 #include <linux/nospec.h> 62 #include <linux/pktcdvd.h> 63 #include <linux/proc_fs.h> 64 #include <linux/seq_file.h> 65 #include <linux/slab.h> 66 #include <linux/spinlock.h> 67 #include <linux/types.h> 68 #include <linux/uaccess.h> 69 70 #include <scsi/scsi.h> 71 #include <scsi/scsi_cmnd.h> 72 #include <scsi/scsi_ioctl.h> 73 74 #include <asm/unaligned.h> 75 76 #define DRIVER_NAME "pktcdvd" 77 78 #define MAX_SPEED 0xffff 79 80 static DEFINE_MUTEX(pktcdvd_mutex); 81 static struct pktcdvd_device *pkt_devs[MAX_WRITERS]; 82 static struct proc_dir_entry *pkt_proc; 83 static int pktdev_major; 84 static int write_congestion_on = PKT_WRITE_CONGESTION_ON; 85 static int write_congestion_off = PKT_WRITE_CONGESTION_OFF; 86 static struct mutex ctl_mutex; /* Serialize open/close/setup/teardown */ 87 static mempool_t psd_pool; 88 static struct bio_set pkt_bio_set; 89 90 /* /sys/class/pktcdvd */ 91 static struct class class_pktcdvd; 92 static struct dentry *pkt_debugfs_root = NULL; /* /sys/kernel/debug/pktcdvd */ 93 94 /* forward declaration */ 95 static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev); 96 static int pkt_remove_dev(dev_t pkt_dev); 97 98 static sector_t get_zone(sector_t sector, struct pktcdvd_device *pd) 99 { 100 return (sector + pd->offset) & ~(sector_t)(pd->settings.size - 1); 101 } 102 103 /********************************************************** 104 * sysfs interface for pktcdvd 105 * by (C) 2006 Thomas Maier <balagi@justmail.de> 106 107 /sys/class/pktcdvd/pktcdvd[0-7]/ 108 stat/reset 109 stat/packets_started 110 stat/packets_finished 111 stat/kb_written 112 stat/kb_read 113 stat/kb_read_gather 114 write_queue/size 115 write_queue/congestion_off 116 write_queue/congestion_on 117 **********************************************************/ 118 119 static ssize_t packets_started_show(struct device *dev, 120 struct device_attribute *attr, char *buf) 121 { 122 struct pktcdvd_device *pd = dev_get_drvdata(dev); 123 124 return sysfs_emit(buf, "%lu\n", pd->stats.pkt_started); 125 } 126 static DEVICE_ATTR_RO(packets_started); 127 128 static ssize_t packets_finished_show(struct device *dev, 129 struct device_attribute *attr, char *buf) 130 { 131 struct pktcdvd_device *pd = dev_get_drvdata(dev); 132 133 return sysfs_emit(buf, "%lu\n", pd->stats.pkt_ended); 134 } 135 static DEVICE_ATTR_RO(packets_finished); 136 137 static ssize_t kb_written_show(struct device *dev, 138 struct device_attribute *attr, char *buf) 139 { 140 struct pktcdvd_device *pd = dev_get_drvdata(dev); 141 142 return sysfs_emit(buf, "%lu\n", pd->stats.secs_w >> 1); 143 } 144 static DEVICE_ATTR_RO(kb_written); 145 146 static ssize_t kb_read_show(struct device *dev, 147 struct device_attribute *attr, char *buf) 148 { 149 struct pktcdvd_device *pd = dev_get_drvdata(dev); 150 151 return sysfs_emit(buf, "%lu\n", pd->stats.secs_r >> 1); 152 } 153 static DEVICE_ATTR_RO(kb_read); 154 155 static ssize_t kb_read_gather_show(struct device *dev, 156 struct device_attribute *attr, char *buf) 157 { 158 struct pktcdvd_device *pd = dev_get_drvdata(dev); 159 160 return sysfs_emit(buf, "%lu\n", pd->stats.secs_rg >> 1); 161 } 162 static DEVICE_ATTR_RO(kb_read_gather); 163 164 static ssize_t reset_store(struct device *dev, struct device_attribute *attr, 165 const char *buf, size_t len) 166 { 167 struct pktcdvd_device *pd = dev_get_drvdata(dev); 168 169 if (len > 0) { 170 pd->stats.pkt_started = 0; 171 pd->stats.pkt_ended = 0; 172 pd->stats.secs_w = 0; 173 pd->stats.secs_rg = 0; 174 pd->stats.secs_r = 0; 175 } 176 return len; 177 } 178 static DEVICE_ATTR_WO(reset); 179 180 static struct attribute *pkt_stat_attrs[] = { 181 &dev_attr_packets_finished.attr, 182 &dev_attr_packets_started.attr, 183 &dev_attr_kb_read.attr, 184 &dev_attr_kb_written.attr, 185 &dev_attr_kb_read_gather.attr, 186 &dev_attr_reset.attr, 187 NULL, 188 }; 189 190 static const struct attribute_group pkt_stat_group = { 191 .name = "stat", 192 .attrs = pkt_stat_attrs, 193 }; 194 195 static ssize_t size_show(struct device *dev, 196 struct device_attribute *attr, char *buf) 197 { 198 struct pktcdvd_device *pd = dev_get_drvdata(dev); 199 int n; 200 201 spin_lock(&pd->lock); 202 n = sysfs_emit(buf, "%d\n", pd->bio_queue_size); 203 spin_unlock(&pd->lock); 204 return n; 205 } 206 static DEVICE_ATTR_RO(size); 207 208 static void init_write_congestion_marks(int* lo, int* hi) 209 { 210 if (*hi > 0) { 211 *hi = max(*hi, 500); 212 *hi = min(*hi, 1000000); 213 if (*lo <= 0) 214 *lo = *hi - 100; 215 else { 216 *lo = min(*lo, *hi - 100); 217 *lo = max(*lo, 100); 218 } 219 } else { 220 *hi = -1; 221 *lo = -1; 222 } 223 } 224 225 static ssize_t congestion_off_show(struct device *dev, 226 struct device_attribute *attr, char *buf) 227 { 228 struct pktcdvd_device *pd = dev_get_drvdata(dev); 229 int n; 230 231 spin_lock(&pd->lock); 232 n = sysfs_emit(buf, "%d\n", pd->write_congestion_off); 233 spin_unlock(&pd->lock); 234 return n; 235 } 236 237 static ssize_t congestion_off_store(struct device *dev, 238 struct device_attribute *attr, 239 const char *buf, size_t len) 240 { 241 struct pktcdvd_device *pd = dev_get_drvdata(dev); 242 int val, ret; 243 244 ret = kstrtoint(buf, 10, &val); 245 if (ret) 246 return ret; 247 248 spin_lock(&pd->lock); 249 pd->write_congestion_off = val; 250 init_write_congestion_marks(&pd->write_congestion_off, &pd->write_congestion_on); 251 spin_unlock(&pd->lock); 252 return len; 253 } 254 static DEVICE_ATTR_RW(congestion_off); 255 256 static ssize_t congestion_on_show(struct device *dev, 257 struct device_attribute *attr, char *buf) 258 { 259 struct pktcdvd_device *pd = dev_get_drvdata(dev); 260 int n; 261 262 spin_lock(&pd->lock); 263 n = sysfs_emit(buf, "%d\n", pd->write_congestion_on); 264 spin_unlock(&pd->lock); 265 return n; 266 } 267 268 static ssize_t congestion_on_store(struct device *dev, 269 struct device_attribute *attr, 270 const char *buf, size_t len) 271 { 272 struct pktcdvd_device *pd = dev_get_drvdata(dev); 273 int val, ret; 274 275 ret = kstrtoint(buf, 10, &val); 276 if (ret) 277 return ret; 278 279 spin_lock(&pd->lock); 280 pd->write_congestion_on = val; 281 init_write_congestion_marks(&pd->write_congestion_off, &pd->write_congestion_on); 282 spin_unlock(&pd->lock); 283 return len; 284 } 285 static DEVICE_ATTR_RW(congestion_on); 286 287 static struct attribute *pkt_wq_attrs[] = { 288 &dev_attr_congestion_on.attr, 289 &dev_attr_congestion_off.attr, 290 &dev_attr_size.attr, 291 NULL, 292 }; 293 294 static const struct attribute_group pkt_wq_group = { 295 .name = "write_queue", 296 .attrs = pkt_wq_attrs, 297 }; 298 299 static const struct attribute_group *pkt_groups[] = { 300 &pkt_stat_group, 301 &pkt_wq_group, 302 NULL, 303 }; 304 305 static void pkt_sysfs_dev_new(struct pktcdvd_device *pd) 306 { 307 if (class_is_registered(&class_pktcdvd)) { 308 pd->dev = device_create_with_groups(&class_pktcdvd, NULL, 309 MKDEV(0, 0), pd, pkt_groups, 310 "%s", pd->disk->disk_name); 311 if (IS_ERR(pd->dev)) 312 pd->dev = NULL; 313 } 314 } 315 316 static void pkt_sysfs_dev_remove(struct pktcdvd_device *pd) 317 { 318 if (class_is_registered(&class_pktcdvd)) 319 device_unregister(pd->dev); 320 } 321 322 323 /******************************************************************** 324 /sys/class/pktcdvd/ 325 add map block device 326 remove unmap packet dev 327 device_map show mappings 328 *******************************************************************/ 329 330 static ssize_t device_map_show(const struct class *c, const struct class_attribute *attr, 331 char *data) 332 { 333 int n = 0; 334 int idx; 335 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); 336 for (idx = 0; idx < MAX_WRITERS; idx++) { 337 struct pktcdvd_device *pd = pkt_devs[idx]; 338 if (!pd) 339 continue; 340 n += sysfs_emit_at(data, n, "%s %u:%u %u:%u\n", 341 pd->disk->disk_name, 342 MAJOR(pd->pkt_dev), MINOR(pd->pkt_dev), 343 MAJOR(file_bdev(pd->bdev_file)->bd_dev), 344 MINOR(file_bdev(pd->bdev_file)->bd_dev)); 345 } 346 mutex_unlock(&ctl_mutex); 347 return n; 348 } 349 static CLASS_ATTR_RO(device_map); 350 351 static ssize_t add_store(const struct class *c, const struct class_attribute *attr, 352 const char *buf, size_t count) 353 { 354 unsigned int major, minor; 355 356 if (sscanf(buf, "%u:%u", &major, &minor) == 2) { 357 /* pkt_setup_dev() expects caller to hold reference to self */ 358 if (!try_module_get(THIS_MODULE)) 359 return -ENODEV; 360 361 pkt_setup_dev(MKDEV(major, minor), NULL); 362 363 module_put(THIS_MODULE); 364 365 return count; 366 } 367 368 return -EINVAL; 369 } 370 static CLASS_ATTR_WO(add); 371 372 static ssize_t remove_store(const struct class *c, const struct class_attribute *attr, 373 const char *buf, size_t count) 374 { 375 unsigned int major, minor; 376 if (sscanf(buf, "%u:%u", &major, &minor) == 2) { 377 pkt_remove_dev(MKDEV(major, minor)); 378 return count; 379 } 380 return -EINVAL; 381 } 382 static CLASS_ATTR_WO(remove); 383 384 static struct attribute *class_pktcdvd_attrs[] = { 385 &class_attr_add.attr, 386 &class_attr_remove.attr, 387 &class_attr_device_map.attr, 388 NULL, 389 }; 390 ATTRIBUTE_GROUPS(class_pktcdvd); 391 392 static struct class class_pktcdvd = { 393 .name = DRIVER_NAME, 394 .class_groups = class_pktcdvd_groups, 395 }; 396 397 static int pkt_sysfs_init(void) 398 { 399 /* 400 * create control files in sysfs 401 * /sys/class/pktcdvd/... 402 */ 403 return class_register(&class_pktcdvd); 404 } 405 406 static void pkt_sysfs_cleanup(void) 407 { 408 class_unregister(&class_pktcdvd); 409 } 410 411 /******************************************************************** 412 entries in debugfs 413 414 /sys/kernel/debug/pktcdvd[0-7]/ 415 info 416 417 *******************************************************************/ 418 419 static void pkt_count_states(struct pktcdvd_device *pd, int *states) 420 { 421 struct packet_data *pkt; 422 int i; 423 424 for (i = 0; i < PACKET_NUM_STATES; i++) 425 states[i] = 0; 426 427 spin_lock(&pd->cdrw.active_list_lock); 428 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) { 429 states[pkt->state]++; 430 } 431 spin_unlock(&pd->cdrw.active_list_lock); 432 } 433 434 static int pkt_seq_show(struct seq_file *m, void *p) 435 { 436 struct pktcdvd_device *pd = m->private; 437 char *msg; 438 int states[PACKET_NUM_STATES]; 439 440 seq_printf(m, "Writer %s mapped to %pg:\n", pd->disk->disk_name, 441 file_bdev(pd->bdev_file)); 442 443 seq_printf(m, "\nSettings:\n"); 444 seq_printf(m, "\tpacket size:\t\t%dkB\n", pd->settings.size / 2); 445 446 if (pd->settings.write_type == 0) 447 msg = "Packet"; 448 else 449 msg = "Unknown"; 450 seq_printf(m, "\twrite type:\t\t%s\n", msg); 451 452 seq_printf(m, "\tpacket type:\t\t%s\n", pd->settings.fp ? "Fixed" : "Variable"); 453 seq_printf(m, "\tlink loss:\t\t%d\n", pd->settings.link_loss); 454 455 seq_printf(m, "\ttrack mode:\t\t%d\n", pd->settings.track_mode); 456 457 if (pd->settings.block_mode == PACKET_BLOCK_MODE1) 458 msg = "Mode 1"; 459 else if (pd->settings.block_mode == PACKET_BLOCK_MODE2) 460 msg = "Mode 2"; 461 else 462 msg = "Unknown"; 463 seq_printf(m, "\tblock mode:\t\t%s\n", msg); 464 465 seq_printf(m, "\nStatistics:\n"); 466 seq_printf(m, "\tpackets started:\t%lu\n", pd->stats.pkt_started); 467 seq_printf(m, "\tpackets ended:\t\t%lu\n", pd->stats.pkt_ended); 468 seq_printf(m, "\twritten:\t\t%lukB\n", pd->stats.secs_w >> 1); 469 seq_printf(m, "\tread gather:\t\t%lukB\n", pd->stats.secs_rg >> 1); 470 seq_printf(m, "\tread:\t\t\t%lukB\n", pd->stats.secs_r >> 1); 471 472 seq_printf(m, "\nMisc:\n"); 473 seq_printf(m, "\treference count:\t%d\n", pd->refcnt); 474 seq_printf(m, "\tflags:\t\t\t0x%lx\n", pd->flags); 475 seq_printf(m, "\tread speed:\t\t%ukB/s\n", pd->read_speed); 476 seq_printf(m, "\twrite speed:\t\t%ukB/s\n", pd->write_speed); 477 seq_printf(m, "\tstart offset:\t\t%lu\n", pd->offset); 478 seq_printf(m, "\tmode page offset:\t%u\n", pd->mode_offset); 479 480 seq_printf(m, "\nQueue state:\n"); 481 seq_printf(m, "\tbios queued:\t\t%d\n", pd->bio_queue_size); 482 seq_printf(m, "\tbios pending:\t\t%d\n", atomic_read(&pd->cdrw.pending_bios)); 483 seq_printf(m, "\tcurrent sector:\t\t0x%llx\n", pd->current_sector); 484 485 pkt_count_states(pd, states); 486 seq_printf(m, "\tstate:\t\t\ti:%d ow:%d rw:%d ww:%d rec:%d fin:%d\n", 487 states[0], states[1], states[2], states[3], states[4], states[5]); 488 489 seq_printf(m, "\twrite congestion marks:\toff=%d on=%d\n", 490 pd->write_congestion_off, 491 pd->write_congestion_on); 492 return 0; 493 } 494 DEFINE_SHOW_ATTRIBUTE(pkt_seq); 495 496 static void pkt_debugfs_dev_new(struct pktcdvd_device *pd) 497 { 498 if (!pkt_debugfs_root) 499 return; 500 pd->dfs_d_root = debugfs_create_dir(pd->disk->disk_name, pkt_debugfs_root); 501 if (!pd->dfs_d_root) 502 return; 503 504 pd->dfs_f_info = debugfs_create_file("info", 0444, pd->dfs_d_root, 505 pd, &pkt_seq_fops); 506 } 507 508 static void pkt_debugfs_dev_remove(struct pktcdvd_device *pd) 509 { 510 if (!pkt_debugfs_root) 511 return; 512 debugfs_remove(pd->dfs_f_info); 513 debugfs_remove(pd->dfs_d_root); 514 pd->dfs_f_info = NULL; 515 pd->dfs_d_root = NULL; 516 } 517 518 static void pkt_debugfs_init(void) 519 { 520 pkt_debugfs_root = debugfs_create_dir(DRIVER_NAME, NULL); 521 } 522 523 static void pkt_debugfs_cleanup(void) 524 { 525 debugfs_remove(pkt_debugfs_root); 526 pkt_debugfs_root = NULL; 527 } 528 529 /* ----------------------------------------------------------*/ 530 531 532 static void pkt_bio_finished(struct pktcdvd_device *pd) 533 { 534 struct device *ddev = disk_to_dev(pd->disk); 535 536 BUG_ON(atomic_read(&pd->cdrw.pending_bios) <= 0); 537 if (atomic_dec_and_test(&pd->cdrw.pending_bios)) { 538 dev_dbg(ddev, "queue empty\n"); 539 atomic_set(&pd->iosched.attention, 1); 540 wake_up(&pd->wqueue); 541 } 542 } 543 544 /* 545 * Allocate a packet_data struct 546 */ 547 static struct packet_data *pkt_alloc_packet_data(int frames) 548 { 549 int i; 550 struct packet_data *pkt; 551 552 pkt = kzalloc(sizeof(struct packet_data), GFP_KERNEL); 553 if (!pkt) 554 goto no_pkt; 555 556 pkt->frames = frames; 557 pkt->w_bio = bio_kmalloc(frames, GFP_KERNEL); 558 if (!pkt->w_bio) 559 goto no_bio; 560 561 for (i = 0; i < frames / FRAMES_PER_PAGE; i++) { 562 pkt->pages[i] = alloc_page(GFP_KERNEL|__GFP_ZERO); 563 if (!pkt->pages[i]) 564 goto no_page; 565 } 566 567 spin_lock_init(&pkt->lock); 568 bio_list_init(&pkt->orig_bios); 569 570 for (i = 0; i < frames; i++) { 571 pkt->r_bios[i] = bio_kmalloc(1, GFP_KERNEL); 572 if (!pkt->r_bios[i]) 573 goto no_rd_bio; 574 } 575 576 return pkt; 577 578 no_rd_bio: 579 for (i = 0; i < frames; i++) 580 kfree(pkt->r_bios[i]); 581 no_page: 582 for (i = 0; i < frames / FRAMES_PER_PAGE; i++) 583 if (pkt->pages[i]) 584 __free_page(pkt->pages[i]); 585 kfree(pkt->w_bio); 586 no_bio: 587 kfree(pkt); 588 no_pkt: 589 return NULL; 590 } 591 592 /* 593 * Free a packet_data struct 594 */ 595 static void pkt_free_packet_data(struct packet_data *pkt) 596 { 597 int i; 598 599 for (i = 0; i < pkt->frames; i++) 600 kfree(pkt->r_bios[i]); 601 for (i = 0; i < pkt->frames / FRAMES_PER_PAGE; i++) 602 __free_page(pkt->pages[i]); 603 kfree(pkt->w_bio); 604 kfree(pkt); 605 } 606 607 static void pkt_shrink_pktlist(struct pktcdvd_device *pd) 608 { 609 struct packet_data *pkt, *next; 610 611 BUG_ON(!list_empty(&pd->cdrw.pkt_active_list)); 612 613 list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_free_list, list) { 614 pkt_free_packet_data(pkt); 615 } 616 INIT_LIST_HEAD(&pd->cdrw.pkt_free_list); 617 } 618 619 static int pkt_grow_pktlist(struct pktcdvd_device *pd, int nr_packets) 620 { 621 struct packet_data *pkt; 622 623 BUG_ON(!list_empty(&pd->cdrw.pkt_free_list)); 624 625 while (nr_packets > 0) { 626 pkt = pkt_alloc_packet_data(pd->settings.size >> 2); 627 if (!pkt) { 628 pkt_shrink_pktlist(pd); 629 return 0; 630 } 631 pkt->id = nr_packets; 632 pkt->pd = pd; 633 list_add(&pkt->list, &pd->cdrw.pkt_free_list); 634 nr_packets--; 635 } 636 return 1; 637 } 638 639 static inline struct pkt_rb_node *pkt_rbtree_next(struct pkt_rb_node *node) 640 { 641 struct rb_node *n = rb_next(&node->rb_node); 642 if (!n) 643 return NULL; 644 return rb_entry(n, struct pkt_rb_node, rb_node); 645 } 646 647 static void pkt_rbtree_erase(struct pktcdvd_device *pd, struct pkt_rb_node *node) 648 { 649 rb_erase(&node->rb_node, &pd->bio_queue); 650 mempool_free(node, &pd->rb_pool); 651 pd->bio_queue_size--; 652 BUG_ON(pd->bio_queue_size < 0); 653 } 654 655 /* 656 * Find the first node in the pd->bio_queue rb tree with a starting sector >= s. 657 */ 658 static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s) 659 { 660 struct rb_node *n = pd->bio_queue.rb_node; 661 struct rb_node *next; 662 struct pkt_rb_node *tmp; 663 664 if (!n) { 665 BUG_ON(pd->bio_queue_size > 0); 666 return NULL; 667 } 668 669 for (;;) { 670 tmp = rb_entry(n, struct pkt_rb_node, rb_node); 671 if (s <= tmp->bio->bi_iter.bi_sector) 672 next = n->rb_left; 673 else 674 next = n->rb_right; 675 if (!next) 676 break; 677 n = next; 678 } 679 680 if (s > tmp->bio->bi_iter.bi_sector) { 681 tmp = pkt_rbtree_next(tmp); 682 if (!tmp) 683 return NULL; 684 } 685 BUG_ON(s > tmp->bio->bi_iter.bi_sector); 686 return tmp; 687 } 688 689 /* 690 * Insert a node into the pd->bio_queue rb tree. 691 */ 692 static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *node) 693 { 694 struct rb_node **p = &pd->bio_queue.rb_node; 695 struct rb_node *parent = NULL; 696 sector_t s = node->bio->bi_iter.bi_sector; 697 struct pkt_rb_node *tmp; 698 699 while (*p) { 700 parent = *p; 701 tmp = rb_entry(parent, struct pkt_rb_node, rb_node); 702 if (s < tmp->bio->bi_iter.bi_sector) 703 p = &(*p)->rb_left; 704 else 705 p = &(*p)->rb_right; 706 } 707 rb_link_node(&node->rb_node, parent, p); 708 rb_insert_color(&node->rb_node, &pd->bio_queue); 709 pd->bio_queue_size++; 710 } 711 712 /* 713 * Send a packet_command to the underlying block device and 714 * wait for completion. 715 */ 716 static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *cgc) 717 { 718 struct request_queue *q = bdev_get_queue(file_bdev(pd->bdev_file)); 719 struct scsi_cmnd *scmd; 720 struct request *rq; 721 int ret = 0; 722 723 rq = scsi_alloc_request(q, (cgc->data_direction == CGC_DATA_WRITE) ? 724 REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0); 725 if (IS_ERR(rq)) 726 return PTR_ERR(rq); 727 scmd = blk_mq_rq_to_pdu(rq); 728 729 if (cgc->buflen) { 730 ret = blk_rq_map_kern(q, rq, cgc->buffer, cgc->buflen, 731 GFP_NOIO); 732 if (ret) 733 goto out; 734 } 735 736 scmd->cmd_len = COMMAND_SIZE(cgc->cmd[0]); 737 memcpy(scmd->cmnd, cgc->cmd, CDROM_PACKET_SIZE); 738 739 rq->timeout = 60*HZ; 740 if (cgc->quiet) 741 rq->rq_flags |= RQF_QUIET; 742 743 blk_execute_rq(rq, false); 744 if (scmd->result) 745 ret = -EIO; 746 out: 747 blk_mq_free_request(rq); 748 return ret; 749 } 750 751 static const char *sense_key_string(__u8 index) 752 { 753 static const char * const info[] = { 754 "No sense", "Recovered error", "Not ready", 755 "Medium error", "Hardware error", "Illegal request", 756 "Unit attention", "Data protect", "Blank check", 757 }; 758 759 return index < ARRAY_SIZE(info) ? info[index] : "INVALID"; 760 } 761 762 /* 763 * A generic sense dump / resolve mechanism should be implemented across 764 * all ATAPI + SCSI devices. 765 */ 766 static void pkt_dump_sense(struct pktcdvd_device *pd, 767 struct packet_command *cgc) 768 { 769 struct device *ddev = disk_to_dev(pd->disk); 770 struct scsi_sense_hdr *sshdr = cgc->sshdr; 771 772 if (sshdr) 773 dev_err(ddev, "%*ph - sense %02x.%02x.%02x (%s)\n", 774 CDROM_PACKET_SIZE, cgc->cmd, 775 sshdr->sense_key, sshdr->asc, sshdr->ascq, 776 sense_key_string(sshdr->sense_key)); 777 else 778 dev_err(ddev, "%*ph - no sense\n", CDROM_PACKET_SIZE, cgc->cmd); 779 } 780 781 /* 782 * flush the drive cache to media 783 */ 784 static int pkt_flush_cache(struct pktcdvd_device *pd) 785 { 786 struct packet_command cgc; 787 788 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE); 789 cgc.cmd[0] = GPCMD_FLUSH_CACHE; 790 cgc.quiet = 1; 791 792 /* 793 * the IMMED bit -- we default to not setting it, although that 794 * would allow a much faster close, this is safer 795 */ 796 #if 0 797 cgc.cmd[1] = 1 << 1; 798 #endif 799 return pkt_generic_packet(pd, &cgc); 800 } 801 802 /* 803 * speed is given as the normal factor, e.g. 4 for 4x 804 */ 805 static noinline_for_stack int pkt_set_speed(struct pktcdvd_device *pd, 806 unsigned write_speed, unsigned read_speed) 807 { 808 struct packet_command cgc; 809 struct scsi_sense_hdr sshdr; 810 int ret; 811 812 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE); 813 cgc.sshdr = &sshdr; 814 cgc.cmd[0] = GPCMD_SET_SPEED; 815 put_unaligned_be16(read_speed, &cgc.cmd[2]); 816 put_unaligned_be16(write_speed, &cgc.cmd[4]); 817 818 ret = pkt_generic_packet(pd, &cgc); 819 if (ret) 820 pkt_dump_sense(pd, &cgc); 821 822 return ret; 823 } 824 825 /* 826 * Queue a bio for processing by the low-level CD device. Must be called 827 * from process context. 828 */ 829 static void pkt_queue_bio(struct pktcdvd_device *pd, struct bio *bio) 830 { 831 /* 832 * Some CDRW drives can not handle writes larger than one packet, 833 * even if the size is a multiple of the packet size. 834 */ 835 bio->bi_opf |= REQ_NOMERGE; 836 837 spin_lock(&pd->iosched.lock); 838 if (bio_data_dir(bio) == READ) 839 bio_list_add(&pd->iosched.read_queue, bio); 840 else 841 bio_list_add(&pd->iosched.write_queue, bio); 842 spin_unlock(&pd->iosched.lock); 843 844 atomic_set(&pd->iosched.attention, 1); 845 wake_up(&pd->wqueue); 846 } 847 848 /* 849 * Process the queued read/write requests. This function handles special 850 * requirements for CDRW drives: 851 * - A cache flush command must be inserted before a read request if the 852 * previous request was a write. 853 * - Switching between reading and writing is slow, so don't do it more often 854 * than necessary. 855 * - Optimize for throughput at the expense of latency. This means that streaming 856 * writes will never be interrupted by a read, but if the drive has to seek 857 * before the next write, switch to reading instead if there are any pending 858 * read requests. 859 * - Set the read speed according to current usage pattern. When only reading 860 * from the device, it's best to use the highest possible read speed, but 861 * when switching often between reading and writing, it's better to have the 862 * same read and write speeds. 863 */ 864 static void pkt_iosched_process_queue(struct pktcdvd_device *pd) 865 { 866 struct device *ddev = disk_to_dev(pd->disk); 867 868 if (atomic_read(&pd->iosched.attention) == 0) 869 return; 870 atomic_set(&pd->iosched.attention, 0); 871 872 for (;;) { 873 struct bio *bio; 874 int reads_queued, writes_queued; 875 876 spin_lock(&pd->iosched.lock); 877 reads_queued = !bio_list_empty(&pd->iosched.read_queue); 878 writes_queued = !bio_list_empty(&pd->iosched.write_queue); 879 spin_unlock(&pd->iosched.lock); 880 881 if (!reads_queued && !writes_queued) 882 break; 883 884 if (pd->iosched.writing) { 885 int need_write_seek = 1; 886 spin_lock(&pd->iosched.lock); 887 bio = bio_list_peek(&pd->iosched.write_queue); 888 spin_unlock(&pd->iosched.lock); 889 if (bio && (bio->bi_iter.bi_sector == 890 pd->iosched.last_write)) 891 need_write_seek = 0; 892 if (need_write_seek && reads_queued) { 893 if (atomic_read(&pd->cdrw.pending_bios) > 0) { 894 dev_dbg(ddev, "write, waiting\n"); 895 break; 896 } 897 pkt_flush_cache(pd); 898 pd->iosched.writing = 0; 899 } 900 } else { 901 if (!reads_queued && writes_queued) { 902 if (atomic_read(&pd->cdrw.pending_bios) > 0) { 903 dev_dbg(ddev, "read, waiting\n"); 904 break; 905 } 906 pd->iosched.writing = 1; 907 } 908 } 909 910 spin_lock(&pd->iosched.lock); 911 if (pd->iosched.writing) 912 bio = bio_list_pop(&pd->iosched.write_queue); 913 else 914 bio = bio_list_pop(&pd->iosched.read_queue); 915 spin_unlock(&pd->iosched.lock); 916 917 if (!bio) 918 continue; 919 920 if (bio_data_dir(bio) == READ) 921 pd->iosched.successive_reads += 922 bio->bi_iter.bi_size >> 10; 923 else { 924 pd->iosched.successive_reads = 0; 925 pd->iosched.last_write = bio_end_sector(bio); 926 } 927 if (pd->iosched.successive_reads >= HI_SPEED_SWITCH) { 928 if (pd->read_speed == pd->write_speed) { 929 pd->read_speed = MAX_SPEED; 930 pkt_set_speed(pd, pd->write_speed, pd->read_speed); 931 } 932 } else { 933 if (pd->read_speed != pd->write_speed) { 934 pd->read_speed = pd->write_speed; 935 pkt_set_speed(pd, pd->write_speed, pd->read_speed); 936 } 937 } 938 939 atomic_inc(&pd->cdrw.pending_bios); 940 submit_bio_noacct(bio); 941 } 942 } 943 944 /* 945 * Special care is needed if the underlying block device has a small 946 * max_phys_segments value. 947 */ 948 static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q) 949 { 950 struct device *ddev = disk_to_dev(pd->disk); 951 952 if ((pd->settings.size << 9) / CD_FRAMESIZE <= queue_max_segments(q)) { 953 /* 954 * The cdrom device can handle one segment/frame 955 */ 956 clear_bit(PACKET_MERGE_SEGS, &pd->flags); 957 return 0; 958 } 959 960 if ((pd->settings.size << 9) / PAGE_SIZE <= queue_max_segments(q)) { 961 /* 962 * We can handle this case at the expense of some extra memory 963 * copies during write operations 964 */ 965 set_bit(PACKET_MERGE_SEGS, &pd->flags); 966 return 0; 967 } 968 969 dev_err(ddev, "cdrom max_phys_segments too small\n"); 970 return -EIO; 971 } 972 973 static void pkt_end_io_read(struct bio *bio) 974 { 975 struct packet_data *pkt = bio->bi_private; 976 struct pktcdvd_device *pd = pkt->pd; 977 BUG_ON(!pd); 978 979 dev_dbg(disk_to_dev(pd->disk), "bio=%p sec0=%llx sec=%llx err=%d\n", 980 bio, pkt->sector, bio->bi_iter.bi_sector, bio->bi_status); 981 982 if (bio->bi_status) 983 atomic_inc(&pkt->io_errors); 984 bio_uninit(bio); 985 if (atomic_dec_and_test(&pkt->io_wait)) { 986 atomic_inc(&pkt->run_sm); 987 wake_up(&pd->wqueue); 988 } 989 pkt_bio_finished(pd); 990 } 991 992 static void pkt_end_io_packet_write(struct bio *bio) 993 { 994 struct packet_data *pkt = bio->bi_private; 995 struct pktcdvd_device *pd = pkt->pd; 996 BUG_ON(!pd); 997 998 dev_dbg(disk_to_dev(pd->disk), "id=%d, err=%d\n", pkt->id, bio->bi_status); 999 1000 pd->stats.pkt_ended++; 1001 1002 bio_uninit(bio); 1003 pkt_bio_finished(pd); 1004 atomic_dec(&pkt->io_wait); 1005 atomic_inc(&pkt->run_sm); 1006 wake_up(&pd->wqueue); 1007 } 1008 1009 /* 1010 * Schedule reads for the holes in a packet 1011 */ 1012 static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt) 1013 { 1014 struct device *ddev = disk_to_dev(pd->disk); 1015 int frames_read = 0; 1016 struct bio *bio; 1017 int f; 1018 char written[PACKET_MAX_SIZE]; 1019 1020 BUG_ON(bio_list_empty(&pkt->orig_bios)); 1021 1022 atomic_set(&pkt->io_wait, 0); 1023 atomic_set(&pkt->io_errors, 0); 1024 1025 /* 1026 * Figure out which frames we need to read before we can write. 1027 */ 1028 memset(written, 0, sizeof(written)); 1029 spin_lock(&pkt->lock); 1030 bio_list_for_each(bio, &pkt->orig_bios) { 1031 int first_frame = (bio->bi_iter.bi_sector - pkt->sector) / 1032 (CD_FRAMESIZE >> 9); 1033 int num_frames = bio->bi_iter.bi_size / CD_FRAMESIZE; 1034 pd->stats.secs_w += num_frames * (CD_FRAMESIZE >> 9); 1035 BUG_ON(first_frame < 0); 1036 BUG_ON(first_frame + num_frames > pkt->frames); 1037 for (f = first_frame; f < first_frame + num_frames; f++) 1038 written[f] = 1; 1039 } 1040 spin_unlock(&pkt->lock); 1041 1042 if (pkt->cache_valid) { 1043 dev_dbg(ddev, "zone %llx cached\n", pkt->sector); 1044 goto out_account; 1045 } 1046 1047 /* 1048 * Schedule reads for missing parts of the packet. 1049 */ 1050 for (f = 0; f < pkt->frames; f++) { 1051 int p, offset; 1052 1053 if (written[f]) 1054 continue; 1055 1056 bio = pkt->r_bios[f]; 1057 bio_init(bio, file_bdev(pd->bdev_file), bio->bi_inline_vecs, 1, 1058 REQ_OP_READ); 1059 bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9); 1060 bio->bi_end_io = pkt_end_io_read; 1061 bio->bi_private = pkt; 1062 1063 p = (f * CD_FRAMESIZE) / PAGE_SIZE; 1064 offset = (f * CD_FRAMESIZE) % PAGE_SIZE; 1065 dev_dbg(ddev, "Adding frame %d, page:%p offs:%d\n", f, 1066 pkt->pages[p], offset); 1067 if (!bio_add_page(bio, pkt->pages[p], CD_FRAMESIZE, offset)) 1068 BUG(); 1069 1070 atomic_inc(&pkt->io_wait); 1071 pkt_queue_bio(pd, bio); 1072 frames_read++; 1073 } 1074 1075 out_account: 1076 dev_dbg(ddev, "need %d frames for zone %llx\n", frames_read, pkt->sector); 1077 pd->stats.pkt_started++; 1078 pd->stats.secs_rg += frames_read * (CD_FRAMESIZE >> 9); 1079 } 1080 1081 /* 1082 * Find a packet matching zone, or the least recently used packet if 1083 * there is no match. 1084 */ 1085 static struct packet_data *pkt_get_packet_data(struct pktcdvd_device *pd, int zone) 1086 { 1087 struct packet_data *pkt; 1088 1089 list_for_each_entry(pkt, &pd->cdrw.pkt_free_list, list) { 1090 if (pkt->sector == zone || pkt->list.next == &pd->cdrw.pkt_free_list) { 1091 list_del_init(&pkt->list); 1092 if (pkt->sector != zone) 1093 pkt->cache_valid = 0; 1094 return pkt; 1095 } 1096 } 1097 BUG(); 1098 return NULL; 1099 } 1100 1101 static void pkt_put_packet_data(struct pktcdvd_device *pd, struct packet_data *pkt) 1102 { 1103 if (pkt->cache_valid) { 1104 list_add(&pkt->list, &pd->cdrw.pkt_free_list); 1105 } else { 1106 list_add_tail(&pkt->list, &pd->cdrw.pkt_free_list); 1107 } 1108 } 1109 1110 static inline void pkt_set_state(struct device *ddev, struct packet_data *pkt, 1111 enum packet_data_state state) 1112 { 1113 static const char *state_name[] = { 1114 "IDLE", "WAITING", "READ_WAIT", "WRITE_WAIT", "RECOVERY", "FINISHED" 1115 }; 1116 enum packet_data_state old_state = pkt->state; 1117 1118 dev_dbg(ddev, "pkt %2d : s=%6llx %s -> %s\n", 1119 pkt->id, pkt->sector, state_name[old_state], state_name[state]); 1120 1121 pkt->state = state; 1122 } 1123 1124 /* 1125 * Scan the work queue to see if we can start a new packet. 1126 * returns non-zero if any work was done. 1127 */ 1128 static int pkt_handle_queue(struct pktcdvd_device *pd) 1129 { 1130 struct device *ddev = disk_to_dev(pd->disk); 1131 struct packet_data *pkt, *p; 1132 struct bio *bio = NULL; 1133 sector_t zone = 0; /* Suppress gcc warning */ 1134 struct pkt_rb_node *node, *first_node; 1135 struct rb_node *n; 1136 1137 atomic_set(&pd->scan_queue, 0); 1138 1139 if (list_empty(&pd->cdrw.pkt_free_list)) { 1140 dev_dbg(ddev, "no pkt\n"); 1141 return 0; 1142 } 1143 1144 /* 1145 * Try to find a zone we are not already working on. 1146 */ 1147 spin_lock(&pd->lock); 1148 first_node = pkt_rbtree_find(pd, pd->current_sector); 1149 if (!first_node) { 1150 n = rb_first(&pd->bio_queue); 1151 if (n) 1152 first_node = rb_entry(n, struct pkt_rb_node, rb_node); 1153 } 1154 node = first_node; 1155 while (node) { 1156 bio = node->bio; 1157 zone = get_zone(bio->bi_iter.bi_sector, pd); 1158 list_for_each_entry(p, &pd->cdrw.pkt_active_list, list) { 1159 if (p->sector == zone) { 1160 bio = NULL; 1161 goto try_next_bio; 1162 } 1163 } 1164 break; 1165 try_next_bio: 1166 node = pkt_rbtree_next(node); 1167 if (!node) { 1168 n = rb_first(&pd->bio_queue); 1169 if (n) 1170 node = rb_entry(n, struct pkt_rb_node, rb_node); 1171 } 1172 if (node == first_node) 1173 node = NULL; 1174 } 1175 spin_unlock(&pd->lock); 1176 if (!bio) { 1177 dev_dbg(ddev, "no bio\n"); 1178 return 0; 1179 } 1180 1181 pkt = pkt_get_packet_data(pd, zone); 1182 1183 pd->current_sector = zone + pd->settings.size; 1184 pkt->sector = zone; 1185 BUG_ON(pkt->frames != pd->settings.size >> 2); 1186 pkt->write_size = 0; 1187 1188 /* 1189 * Scan work queue for bios in the same zone and link them 1190 * to this packet. 1191 */ 1192 spin_lock(&pd->lock); 1193 dev_dbg(ddev, "looking for zone %llx\n", zone); 1194 while ((node = pkt_rbtree_find(pd, zone)) != NULL) { 1195 sector_t tmp = get_zone(node->bio->bi_iter.bi_sector, pd); 1196 1197 bio = node->bio; 1198 dev_dbg(ddev, "found zone=%llx\n", tmp); 1199 if (tmp != zone) 1200 break; 1201 pkt_rbtree_erase(pd, node); 1202 spin_lock(&pkt->lock); 1203 bio_list_add(&pkt->orig_bios, bio); 1204 pkt->write_size += bio->bi_iter.bi_size / CD_FRAMESIZE; 1205 spin_unlock(&pkt->lock); 1206 } 1207 /* check write congestion marks, and if bio_queue_size is 1208 * below, wake up any waiters 1209 */ 1210 if (pd->congested && 1211 pd->bio_queue_size <= pd->write_congestion_off) { 1212 pd->congested = false; 1213 wake_up_var(&pd->congested); 1214 } 1215 spin_unlock(&pd->lock); 1216 1217 pkt->sleep_time = max(PACKET_WAIT_TIME, 1); 1218 pkt_set_state(ddev, pkt, PACKET_WAITING_STATE); 1219 atomic_set(&pkt->run_sm, 1); 1220 1221 spin_lock(&pd->cdrw.active_list_lock); 1222 list_add(&pkt->list, &pd->cdrw.pkt_active_list); 1223 spin_unlock(&pd->cdrw.active_list_lock); 1224 1225 return 1; 1226 } 1227 1228 /** 1229 * bio_list_copy_data - copy contents of data buffers from one chain of bios to 1230 * another 1231 * @src: source bio list 1232 * @dst: destination bio list 1233 * 1234 * Stops when it reaches the end of either the @src list or @dst list - that is, 1235 * copies min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of 1236 * bios). 1237 */ 1238 static void bio_list_copy_data(struct bio *dst, struct bio *src) 1239 { 1240 struct bvec_iter src_iter = src->bi_iter; 1241 struct bvec_iter dst_iter = dst->bi_iter; 1242 1243 while (1) { 1244 if (!src_iter.bi_size) { 1245 src = src->bi_next; 1246 if (!src) 1247 break; 1248 1249 src_iter = src->bi_iter; 1250 } 1251 1252 if (!dst_iter.bi_size) { 1253 dst = dst->bi_next; 1254 if (!dst) 1255 break; 1256 1257 dst_iter = dst->bi_iter; 1258 } 1259 1260 bio_copy_data_iter(dst, &dst_iter, src, &src_iter); 1261 } 1262 } 1263 1264 /* 1265 * Assemble a bio to write one packet and queue the bio for processing 1266 * by the underlying block device. 1267 */ 1268 static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt) 1269 { 1270 struct device *ddev = disk_to_dev(pd->disk); 1271 int f; 1272 1273 bio_init(pkt->w_bio, file_bdev(pd->bdev_file), pkt->w_bio->bi_inline_vecs, 1274 pkt->frames, REQ_OP_WRITE); 1275 pkt->w_bio->bi_iter.bi_sector = pkt->sector; 1276 pkt->w_bio->bi_end_io = pkt_end_io_packet_write; 1277 pkt->w_bio->bi_private = pkt; 1278 1279 /* XXX: locking? */ 1280 for (f = 0; f < pkt->frames; f++) { 1281 struct page *page = pkt->pages[(f * CD_FRAMESIZE) / PAGE_SIZE]; 1282 unsigned offset = (f * CD_FRAMESIZE) % PAGE_SIZE; 1283 1284 if (!bio_add_page(pkt->w_bio, page, CD_FRAMESIZE, offset)) 1285 BUG(); 1286 } 1287 dev_dbg(ddev, "vcnt=%d\n", pkt->w_bio->bi_vcnt); 1288 1289 /* 1290 * Fill-in bvec with data from orig_bios. 1291 */ 1292 spin_lock(&pkt->lock); 1293 bio_list_copy_data(pkt->w_bio, pkt->orig_bios.head); 1294 1295 pkt_set_state(ddev, pkt, PACKET_WRITE_WAIT_STATE); 1296 spin_unlock(&pkt->lock); 1297 1298 dev_dbg(ddev, "Writing %d frames for zone %llx\n", pkt->write_size, pkt->sector); 1299 1300 if (test_bit(PACKET_MERGE_SEGS, &pd->flags) || (pkt->write_size < pkt->frames)) 1301 pkt->cache_valid = 1; 1302 else 1303 pkt->cache_valid = 0; 1304 1305 /* Start the write request */ 1306 atomic_set(&pkt->io_wait, 1); 1307 pkt_queue_bio(pd, pkt->w_bio); 1308 } 1309 1310 static void pkt_finish_packet(struct packet_data *pkt, blk_status_t status) 1311 { 1312 struct bio *bio; 1313 1314 if (status) 1315 pkt->cache_valid = 0; 1316 1317 /* Finish all bios corresponding to this packet */ 1318 while ((bio = bio_list_pop(&pkt->orig_bios))) { 1319 bio->bi_status = status; 1320 bio_endio(bio); 1321 } 1322 } 1323 1324 static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt) 1325 { 1326 struct device *ddev = disk_to_dev(pd->disk); 1327 1328 dev_dbg(ddev, "pkt %d\n", pkt->id); 1329 1330 for (;;) { 1331 switch (pkt->state) { 1332 case PACKET_WAITING_STATE: 1333 if ((pkt->write_size < pkt->frames) && (pkt->sleep_time > 0)) 1334 return; 1335 1336 pkt->sleep_time = 0; 1337 pkt_gather_data(pd, pkt); 1338 pkt_set_state(ddev, pkt, PACKET_READ_WAIT_STATE); 1339 break; 1340 1341 case PACKET_READ_WAIT_STATE: 1342 if (atomic_read(&pkt->io_wait) > 0) 1343 return; 1344 1345 if (atomic_read(&pkt->io_errors) > 0) { 1346 pkt_set_state(ddev, pkt, PACKET_RECOVERY_STATE); 1347 } else { 1348 pkt_start_write(pd, pkt); 1349 } 1350 break; 1351 1352 case PACKET_WRITE_WAIT_STATE: 1353 if (atomic_read(&pkt->io_wait) > 0) 1354 return; 1355 1356 if (!pkt->w_bio->bi_status) { 1357 pkt_set_state(ddev, pkt, PACKET_FINISHED_STATE); 1358 } else { 1359 pkt_set_state(ddev, pkt, PACKET_RECOVERY_STATE); 1360 } 1361 break; 1362 1363 case PACKET_RECOVERY_STATE: 1364 dev_dbg(ddev, "No recovery possible\n"); 1365 pkt_set_state(ddev, pkt, PACKET_FINISHED_STATE); 1366 break; 1367 1368 case PACKET_FINISHED_STATE: 1369 pkt_finish_packet(pkt, pkt->w_bio->bi_status); 1370 return; 1371 1372 default: 1373 BUG(); 1374 break; 1375 } 1376 } 1377 } 1378 1379 static void pkt_handle_packets(struct pktcdvd_device *pd) 1380 { 1381 struct device *ddev = disk_to_dev(pd->disk); 1382 struct packet_data *pkt, *next; 1383 1384 /* 1385 * Run state machine for active packets 1386 */ 1387 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) { 1388 if (atomic_read(&pkt->run_sm) > 0) { 1389 atomic_set(&pkt->run_sm, 0); 1390 pkt_run_state_machine(pd, pkt); 1391 } 1392 } 1393 1394 /* 1395 * Move no longer active packets to the free list 1396 */ 1397 spin_lock(&pd->cdrw.active_list_lock); 1398 list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_active_list, list) { 1399 if (pkt->state == PACKET_FINISHED_STATE) { 1400 list_del(&pkt->list); 1401 pkt_put_packet_data(pd, pkt); 1402 pkt_set_state(ddev, pkt, PACKET_IDLE_STATE); 1403 atomic_set(&pd->scan_queue, 1); 1404 } 1405 } 1406 spin_unlock(&pd->cdrw.active_list_lock); 1407 } 1408 1409 /* 1410 * kcdrwd is woken up when writes have been queued for one of our 1411 * registered devices 1412 */ 1413 static int kcdrwd(void *foobar) 1414 { 1415 struct pktcdvd_device *pd = foobar; 1416 struct device *ddev = disk_to_dev(pd->disk); 1417 struct packet_data *pkt; 1418 int states[PACKET_NUM_STATES]; 1419 long min_sleep_time, residue; 1420 1421 set_user_nice(current, MIN_NICE); 1422 set_freezable(); 1423 1424 for (;;) { 1425 DECLARE_WAITQUEUE(wait, current); 1426 1427 /* 1428 * Wait until there is something to do 1429 */ 1430 add_wait_queue(&pd->wqueue, &wait); 1431 for (;;) { 1432 set_current_state(TASK_INTERRUPTIBLE); 1433 1434 /* Check if we need to run pkt_handle_queue */ 1435 if (atomic_read(&pd->scan_queue) > 0) 1436 goto work_to_do; 1437 1438 /* Check if we need to run the state machine for some packet */ 1439 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) { 1440 if (atomic_read(&pkt->run_sm) > 0) 1441 goto work_to_do; 1442 } 1443 1444 /* Check if we need to process the iosched queues */ 1445 if (atomic_read(&pd->iosched.attention) != 0) 1446 goto work_to_do; 1447 1448 /* Otherwise, go to sleep */ 1449 pkt_count_states(pd, states); 1450 dev_dbg(ddev, "i:%d ow:%d rw:%d ww:%d rec:%d fin:%d\n", 1451 states[0], states[1], states[2], states[3], states[4], states[5]); 1452 1453 min_sleep_time = MAX_SCHEDULE_TIMEOUT; 1454 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) { 1455 if (pkt->sleep_time && pkt->sleep_time < min_sleep_time) 1456 min_sleep_time = pkt->sleep_time; 1457 } 1458 1459 dev_dbg(ddev, "sleeping\n"); 1460 residue = schedule_timeout(min_sleep_time); 1461 dev_dbg(ddev, "wake up\n"); 1462 1463 /* make swsusp happy with our thread */ 1464 try_to_freeze(); 1465 1466 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) { 1467 if (!pkt->sleep_time) 1468 continue; 1469 pkt->sleep_time -= min_sleep_time - residue; 1470 if (pkt->sleep_time <= 0) { 1471 pkt->sleep_time = 0; 1472 atomic_inc(&pkt->run_sm); 1473 } 1474 } 1475 1476 if (kthread_should_stop()) 1477 break; 1478 } 1479 work_to_do: 1480 set_current_state(TASK_RUNNING); 1481 remove_wait_queue(&pd->wqueue, &wait); 1482 1483 if (kthread_should_stop()) 1484 break; 1485 1486 /* 1487 * if pkt_handle_queue returns true, we can queue 1488 * another request. 1489 */ 1490 while (pkt_handle_queue(pd)) 1491 ; 1492 1493 /* 1494 * Handle packet state machine 1495 */ 1496 pkt_handle_packets(pd); 1497 1498 /* 1499 * Handle iosched queues 1500 */ 1501 pkt_iosched_process_queue(pd); 1502 } 1503 1504 return 0; 1505 } 1506 1507 static void pkt_print_settings(struct pktcdvd_device *pd) 1508 { 1509 dev_info(disk_to_dev(pd->disk), "%s packets, %u blocks, Mode-%c disc\n", 1510 pd->settings.fp ? "Fixed" : "Variable", 1511 pd->settings.size >> 2, 1512 pd->settings.block_mode == 8 ? '1' : '2'); 1513 } 1514 1515 static int pkt_mode_sense(struct pktcdvd_device *pd, struct packet_command *cgc, int page_code, int page_control) 1516 { 1517 memset(cgc->cmd, 0, sizeof(cgc->cmd)); 1518 1519 cgc->cmd[0] = GPCMD_MODE_SENSE_10; 1520 cgc->cmd[2] = page_code | (page_control << 6); 1521 put_unaligned_be16(cgc->buflen, &cgc->cmd[7]); 1522 cgc->data_direction = CGC_DATA_READ; 1523 return pkt_generic_packet(pd, cgc); 1524 } 1525 1526 static int pkt_mode_select(struct pktcdvd_device *pd, struct packet_command *cgc) 1527 { 1528 memset(cgc->cmd, 0, sizeof(cgc->cmd)); 1529 memset(cgc->buffer, 0, 2); 1530 cgc->cmd[0] = GPCMD_MODE_SELECT_10; 1531 cgc->cmd[1] = 0x10; /* PF */ 1532 put_unaligned_be16(cgc->buflen, &cgc->cmd[7]); 1533 cgc->data_direction = CGC_DATA_WRITE; 1534 return pkt_generic_packet(pd, cgc); 1535 } 1536 1537 static int pkt_get_disc_info(struct pktcdvd_device *pd, disc_information *di) 1538 { 1539 struct packet_command cgc; 1540 int ret; 1541 1542 /* set up command and get the disc info */ 1543 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ); 1544 cgc.cmd[0] = GPCMD_READ_DISC_INFO; 1545 cgc.cmd[8] = cgc.buflen = 2; 1546 cgc.quiet = 1; 1547 1548 ret = pkt_generic_packet(pd, &cgc); 1549 if (ret) 1550 return ret; 1551 1552 /* not all drives have the same disc_info length, so requeue 1553 * packet with the length the drive tells us it can supply 1554 */ 1555 cgc.buflen = be16_to_cpu(di->disc_information_length) + 1556 sizeof(di->disc_information_length); 1557 1558 if (cgc.buflen > sizeof(disc_information)) 1559 cgc.buflen = sizeof(disc_information); 1560 1561 cgc.cmd[8] = cgc.buflen; 1562 return pkt_generic_packet(pd, &cgc); 1563 } 1564 1565 static int pkt_get_track_info(struct pktcdvd_device *pd, __u16 track, __u8 type, track_information *ti) 1566 { 1567 struct packet_command cgc; 1568 int ret; 1569 1570 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ); 1571 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO; 1572 cgc.cmd[1] = type & 3; 1573 put_unaligned_be16(track, &cgc.cmd[4]); 1574 cgc.cmd[8] = 8; 1575 cgc.quiet = 1; 1576 1577 ret = pkt_generic_packet(pd, &cgc); 1578 if (ret) 1579 return ret; 1580 1581 cgc.buflen = be16_to_cpu(ti->track_information_length) + 1582 sizeof(ti->track_information_length); 1583 1584 if (cgc.buflen > sizeof(track_information)) 1585 cgc.buflen = sizeof(track_information); 1586 1587 cgc.cmd[8] = cgc.buflen; 1588 return pkt_generic_packet(pd, &cgc); 1589 } 1590 1591 static noinline_for_stack int pkt_get_last_written(struct pktcdvd_device *pd, 1592 long *last_written) 1593 { 1594 disc_information di; 1595 track_information ti; 1596 __u32 last_track; 1597 int ret; 1598 1599 ret = pkt_get_disc_info(pd, &di); 1600 if (ret) 1601 return ret; 1602 1603 last_track = (di.last_track_msb << 8) | di.last_track_lsb; 1604 ret = pkt_get_track_info(pd, last_track, 1, &ti); 1605 if (ret) 1606 return ret; 1607 1608 /* if this track is blank, try the previous. */ 1609 if (ti.blank) { 1610 last_track--; 1611 ret = pkt_get_track_info(pd, last_track, 1, &ti); 1612 if (ret) 1613 return ret; 1614 } 1615 1616 /* if last recorded field is valid, return it. */ 1617 if (ti.lra_v) { 1618 *last_written = be32_to_cpu(ti.last_rec_address); 1619 } else { 1620 /* make it up instead */ 1621 *last_written = be32_to_cpu(ti.track_start) + 1622 be32_to_cpu(ti.track_size); 1623 if (ti.free_blocks) 1624 *last_written -= (be32_to_cpu(ti.free_blocks) + 7); 1625 } 1626 return 0; 1627 } 1628 1629 /* 1630 * write mode select package based on pd->settings 1631 */ 1632 static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd) 1633 { 1634 struct device *ddev = disk_to_dev(pd->disk); 1635 struct packet_command cgc; 1636 struct scsi_sense_hdr sshdr; 1637 write_param_page *wp; 1638 char buffer[128]; 1639 int ret, size; 1640 1641 /* doesn't apply to DVD+RW or DVD-RAM */ 1642 if ((pd->mmc3_profile == 0x1a) || (pd->mmc3_profile == 0x12)) 1643 return 0; 1644 1645 memset(buffer, 0, sizeof(buffer)); 1646 init_cdrom_command(&cgc, buffer, sizeof(*wp), CGC_DATA_READ); 1647 cgc.sshdr = &sshdr; 1648 ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0); 1649 if (ret) { 1650 pkt_dump_sense(pd, &cgc); 1651 return ret; 1652 } 1653 1654 size = 2 + get_unaligned_be16(&buffer[0]); 1655 pd->mode_offset = get_unaligned_be16(&buffer[6]); 1656 if (size > sizeof(buffer)) 1657 size = sizeof(buffer); 1658 1659 /* 1660 * now get it all 1661 */ 1662 init_cdrom_command(&cgc, buffer, size, CGC_DATA_READ); 1663 cgc.sshdr = &sshdr; 1664 ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0); 1665 if (ret) { 1666 pkt_dump_sense(pd, &cgc); 1667 return ret; 1668 } 1669 1670 /* 1671 * write page is offset header + block descriptor length 1672 */ 1673 wp = (write_param_page *) &buffer[sizeof(struct mode_page_header) + pd->mode_offset]; 1674 1675 wp->fp = pd->settings.fp; 1676 wp->track_mode = pd->settings.track_mode; 1677 wp->write_type = pd->settings.write_type; 1678 wp->data_block_type = pd->settings.block_mode; 1679 1680 wp->multi_session = 0; 1681 1682 #ifdef PACKET_USE_LS 1683 wp->link_size = 7; 1684 wp->ls_v = 1; 1685 #endif 1686 1687 if (wp->data_block_type == PACKET_BLOCK_MODE1) { 1688 wp->session_format = 0; 1689 wp->subhdr2 = 0x20; 1690 } else if (wp->data_block_type == PACKET_BLOCK_MODE2) { 1691 wp->session_format = 0x20; 1692 wp->subhdr2 = 8; 1693 #if 0 1694 wp->mcn[0] = 0x80; 1695 memcpy(&wp->mcn[1], PACKET_MCN, sizeof(wp->mcn) - 1); 1696 #endif 1697 } else { 1698 /* 1699 * paranoia 1700 */ 1701 dev_err(ddev, "write mode wrong %d\n", wp->data_block_type); 1702 return 1; 1703 } 1704 wp->packet_size = cpu_to_be32(pd->settings.size >> 2); 1705 1706 cgc.buflen = cgc.cmd[8] = size; 1707 ret = pkt_mode_select(pd, &cgc); 1708 if (ret) { 1709 pkt_dump_sense(pd, &cgc); 1710 return ret; 1711 } 1712 1713 pkt_print_settings(pd); 1714 return 0; 1715 } 1716 1717 /* 1718 * 1 -- we can write to this track, 0 -- we can't 1719 */ 1720 static int pkt_writable_track(struct pktcdvd_device *pd, track_information *ti) 1721 { 1722 struct device *ddev = disk_to_dev(pd->disk); 1723 1724 switch (pd->mmc3_profile) { 1725 case 0x1a: /* DVD+RW */ 1726 case 0x12: /* DVD-RAM */ 1727 /* The track is always writable on DVD+RW/DVD-RAM */ 1728 return 1; 1729 default: 1730 break; 1731 } 1732 1733 if (!ti->packet || !ti->fp) 1734 return 0; 1735 1736 /* 1737 * "good" settings as per Mt Fuji. 1738 */ 1739 if (ti->rt == 0 && ti->blank == 0) 1740 return 1; 1741 1742 if (ti->rt == 0 && ti->blank == 1) 1743 return 1; 1744 1745 if (ti->rt == 1 && ti->blank == 0) 1746 return 1; 1747 1748 dev_err(ddev, "bad state %d-%d-%d\n", ti->rt, ti->blank, ti->packet); 1749 return 0; 1750 } 1751 1752 /* 1753 * 1 -- we can write to this disc, 0 -- we can't 1754 */ 1755 static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di) 1756 { 1757 struct device *ddev = disk_to_dev(pd->disk); 1758 1759 switch (pd->mmc3_profile) { 1760 case 0x0a: /* CD-RW */ 1761 case 0xffff: /* MMC3 not supported */ 1762 break; 1763 case 0x1a: /* DVD+RW */ 1764 case 0x13: /* DVD-RW */ 1765 case 0x12: /* DVD-RAM */ 1766 return 1; 1767 default: 1768 dev_dbg(ddev, "Wrong disc profile (%x)\n", pd->mmc3_profile); 1769 return 0; 1770 } 1771 1772 /* 1773 * for disc type 0xff we should probably reserve a new track. 1774 * but i'm not sure, should we leave this to user apps? probably. 1775 */ 1776 if (di->disc_type == 0xff) { 1777 dev_notice(ddev, "unknown disc - no track?\n"); 1778 return 0; 1779 } 1780 1781 if (di->disc_type != 0x20 && di->disc_type != 0) { 1782 dev_err(ddev, "wrong disc type (%x)\n", di->disc_type); 1783 return 0; 1784 } 1785 1786 if (di->erasable == 0) { 1787 dev_err(ddev, "disc not erasable\n"); 1788 return 0; 1789 } 1790 1791 if (di->border_status == PACKET_SESSION_RESERVED) { 1792 dev_err(ddev, "can't write to last track (reserved)\n"); 1793 return 0; 1794 } 1795 1796 return 1; 1797 } 1798 1799 static noinline_for_stack int pkt_probe_settings(struct pktcdvd_device *pd) 1800 { 1801 struct device *ddev = disk_to_dev(pd->disk); 1802 struct packet_command cgc; 1803 unsigned char buf[12]; 1804 disc_information di; 1805 track_information ti; 1806 int ret, track; 1807 1808 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ); 1809 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; 1810 cgc.cmd[8] = 8; 1811 ret = pkt_generic_packet(pd, &cgc); 1812 pd->mmc3_profile = ret ? 0xffff : get_unaligned_be16(&buf[6]); 1813 1814 memset(&di, 0, sizeof(disc_information)); 1815 memset(&ti, 0, sizeof(track_information)); 1816 1817 ret = pkt_get_disc_info(pd, &di); 1818 if (ret) { 1819 dev_err(ddev, "failed get_disc\n"); 1820 return ret; 1821 } 1822 1823 if (!pkt_writable_disc(pd, &di)) 1824 return -EROFS; 1825 1826 pd->type = di.erasable ? PACKET_CDRW : PACKET_CDR; 1827 1828 track = 1; /* (di.last_track_msb << 8) | di.last_track_lsb; */ 1829 ret = pkt_get_track_info(pd, track, 1, &ti); 1830 if (ret) { 1831 dev_err(ddev, "failed get_track\n"); 1832 return ret; 1833 } 1834 1835 if (!pkt_writable_track(pd, &ti)) { 1836 dev_err(ddev, "can't write to this track\n"); 1837 return -EROFS; 1838 } 1839 1840 /* 1841 * we keep packet size in 512 byte units, makes it easier to 1842 * deal with request calculations. 1843 */ 1844 pd->settings.size = be32_to_cpu(ti.fixed_packet_size) << 2; 1845 if (pd->settings.size == 0) { 1846 dev_notice(ddev, "detected zero packet size!\n"); 1847 return -ENXIO; 1848 } 1849 if (pd->settings.size > PACKET_MAX_SECTORS) { 1850 dev_err(ddev, "packet size is too big\n"); 1851 return -EROFS; 1852 } 1853 pd->settings.fp = ti.fp; 1854 pd->offset = (be32_to_cpu(ti.track_start) << 2) & (pd->settings.size - 1); 1855 1856 if (ti.nwa_v) { 1857 pd->nwa = be32_to_cpu(ti.next_writable); 1858 set_bit(PACKET_NWA_VALID, &pd->flags); 1859 } 1860 1861 /* 1862 * in theory we could use lra on -RW media as well and just zero 1863 * blocks that haven't been written yet, but in practice that 1864 * is just a no-go. we'll use that for -R, naturally. 1865 */ 1866 if (ti.lra_v) { 1867 pd->lra = be32_to_cpu(ti.last_rec_address); 1868 set_bit(PACKET_LRA_VALID, &pd->flags); 1869 } else { 1870 pd->lra = 0xffffffff; 1871 set_bit(PACKET_LRA_VALID, &pd->flags); 1872 } 1873 1874 /* 1875 * fine for now 1876 */ 1877 pd->settings.link_loss = 7; 1878 pd->settings.write_type = 0; /* packet */ 1879 pd->settings.track_mode = ti.track_mode; 1880 1881 /* 1882 * mode1 or mode2 disc 1883 */ 1884 switch (ti.data_mode) { 1885 case PACKET_MODE1: 1886 pd->settings.block_mode = PACKET_BLOCK_MODE1; 1887 break; 1888 case PACKET_MODE2: 1889 pd->settings.block_mode = PACKET_BLOCK_MODE2; 1890 break; 1891 default: 1892 dev_err(ddev, "unknown data mode\n"); 1893 return -EROFS; 1894 } 1895 return 0; 1896 } 1897 1898 /* 1899 * enable/disable write caching on drive 1900 */ 1901 static noinline_for_stack int pkt_write_caching(struct pktcdvd_device *pd) 1902 { 1903 struct device *ddev = disk_to_dev(pd->disk); 1904 struct packet_command cgc; 1905 struct scsi_sense_hdr sshdr; 1906 unsigned char buf[64]; 1907 bool set = IS_ENABLED(CONFIG_CDROM_PKTCDVD_WCACHE); 1908 int ret; 1909 1910 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ); 1911 cgc.sshdr = &sshdr; 1912 cgc.buflen = pd->mode_offset + 12; 1913 1914 /* 1915 * caching mode page might not be there, so quiet this command 1916 */ 1917 cgc.quiet = 1; 1918 1919 ret = pkt_mode_sense(pd, &cgc, GPMODE_WCACHING_PAGE, 0); 1920 if (ret) 1921 return ret; 1922 1923 /* 1924 * use drive write caching -- we need deferred error handling to be 1925 * able to successfully recover with this option (drive will return good 1926 * status as soon as the cdb is validated). 1927 */ 1928 buf[pd->mode_offset + 10] |= (set << 2); 1929 1930 cgc.buflen = cgc.cmd[8] = 2 + get_unaligned_be16(&buf[0]); 1931 ret = pkt_mode_select(pd, &cgc); 1932 if (ret) { 1933 dev_err(ddev, "write caching control failed\n"); 1934 pkt_dump_sense(pd, &cgc); 1935 } else if (!ret && set) 1936 dev_notice(ddev, "enabled write caching\n"); 1937 return ret; 1938 } 1939 1940 static int pkt_lock_door(struct pktcdvd_device *pd, int lockflag) 1941 { 1942 struct packet_command cgc; 1943 1944 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE); 1945 cgc.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL; 1946 cgc.cmd[4] = lockflag ? 1 : 0; 1947 return pkt_generic_packet(pd, &cgc); 1948 } 1949 1950 /* 1951 * Returns drive maximum write speed 1952 */ 1953 static noinline_for_stack int pkt_get_max_speed(struct pktcdvd_device *pd, 1954 unsigned *write_speed) 1955 { 1956 struct packet_command cgc; 1957 struct scsi_sense_hdr sshdr; 1958 unsigned char buf[256+18]; 1959 unsigned char *cap_buf; 1960 int ret, offset; 1961 1962 cap_buf = &buf[sizeof(struct mode_page_header) + pd->mode_offset]; 1963 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_UNKNOWN); 1964 cgc.sshdr = &sshdr; 1965 1966 ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0); 1967 if (ret) { 1968 cgc.buflen = pd->mode_offset + cap_buf[1] + 2 + 1969 sizeof(struct mode_page_header); 1970 ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0); 1971 if (ret) { 1972 pkt_dump_sense(pd, &cgc); 1973 return ret; 1974 } 1975 } 1976 1977 offset = 20; /* Obsoleted field, used by older drives */ 1978 if (cap_buf[1] >= 28) 1979 offset = 28; /* Current write speed selected */ 1980 if (cap_buf[1] >= 30) { 1981 /* If the drive reports at least one "Logical Unit Write 1982 * Speed Performance Descriptor Block", use the information 1983 * in the first block. (contains the highest speed) 1984 */ 1985 int num_spdb = get_unaligned_be16(&cap_buf[30]); 1986 if (num_spdb > 0) 1987 offset = 34; 1988 } 1989 1990 *write_speed = get_unaligned_be16(&cap_buf[offset]); 1991 return 0; 1992 } 1993 1994 /* These tables from cdrecord - I don't have orange book */ 1995 /* standard speed CD-RW (1-4x) */ 1996 static char clv_to_speed[16] = { 1997 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */ 1998 0, 2, 4, 6, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1999 }; 2000 /* high speed CD-RW (-10x) */ 2001 static char hs_clv_to_speed[16] = { 2002 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */ 2003 0, 2, 4, 6, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 2004 }; 2005 /* ultra high speed CD-RW */ 2006 static char us_clv_to_speed[16] = { 2007 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */ 2008 0, 2, 4, 8, 0, 0,16, 0,24,32,40,48, 0, 0, 0, 0 2009 }; 2010 2011 /* 2012 * reads the maximum media speed from ATIP 2013 */ 2014 static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd, 2015 unsigned *speed) 2016 { 2017 struct device *ddev = disk_to_dev(pd->disk); 2018 struct packet_command cgc; 2019 struct scsi_sense_hdr sshdr; 2020 unsigned char buf[64]; 2021 unsigned int size, st, sp; 2022 int ret; 2023 2024 init_cdrom_command(&cgc, buf, 2, CGC_DATA_READ); 2025 cgc.sshdr = &sshdr; 2026 cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP; 2027 cgc.cmd[1] = 2; 2028 cgc.cmd[2] = 4; /* READ ATIP */ 2029 cgc.cmd[8] = 2; 2030 ret = pkt_generic_packet(pd, &cgc); 2031 if (ret) { 2032 pkt_dump_sense(pd, &cgc); 2033 return ret; 2034 } 2035 size = 2 + get_unaligned_be16(&buf[0]); 2036 if (size > sizeof(buf)) 2037 size = sizeof(buf); 2038 2039 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ); 2040 cgc.sshdr = &sshdr; 2041 cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP; 2042 cgc.cmd[1] = 2; 2043 cgc.cmd[2] = 4; 2044 cgc.cmd[8] = size; 2045 ret = pkt_generic_packet(pd, &cgc); 2046 if (ret) { 2047 pkt_dump_sense(pd, &cgc); 2048 return ret; 2049 } 2050 2051 if (!(buf[6] & 0x40)) { 2052 dev_notice(ddev, "disc type is not CD-RW\n"); 2053 return 1; 2054 } 2055 if (!(buf[6] & 0x4)) { 2056 dev_notice(ddev, "A1 values on media are not valid, maybe not CDRW?\n"); 2057 return 1; 2058 } 2059 2060 st = (buf[6] >> 3) & 0x7; /* disc sub-type */ 2061 2062 sp = buf[16] & 0xf; /* max speed from ATIP A1 field */ 2063 2064 /* Info from cdrecord */ 2065 switch (st) { 2066 case 0: /* standard speed */ 2067 *speed = clv_to_speed[sp]; 2068 break; 2069 case 1: /* high speed */ 2070 *speed = hs_clv_to_speed[sp]; 2071 break; 2072 case 2: /* ultra high speed */ 2073 *speed = us_clv_to_speed[sp]; 2074 break; 2075 default: 2076 dev_notice(ddev, "unknown disc sub-type %d\n", st); 2077 return 1; 2078 } 2079 if (*speed) { 2080 dev_info(ddev, "maximum media speed: %d\n", *speed); 2081 return 0; 2082 } else { 2083 dev_notice(ddev, "unknown speed %d for sub-type %d\n", sp, st); 2084 return 1; 2085 } 2086 } 2087 2088 static noinline_for_stack int pkt_perform_opc(struct pktcdvd_device *pd) 2089 { 2090 struct device *ddev = disk_to_dev(pd->disk); 2091 struct packet_command cgc; 2092 struct scsi_sense_hdr sshdr; 2093 int ret; 2094 2095 dev_dbg(ddev, "Performing OPC\n"); 2096 2097 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE); 2098 cgc.sshdr = &sshdr; 2099 cgc.timeout = 60*HZ; 2100 cgc.cmd[0] = GPCMD_SEND_OPC; 2101 cgc.cmd[1] = 1; 2102 ret = pkt_generic_packet(pd, &cgc); 2103 if (ret) 2104 pkt_dump_sense(pd, &cgc); 2105 return ret; 2106 } 2107 2108 static int pkt_open_write(struct pktcdvd_device *pd) 2109 { 2110 struct device *ddev = disk_to_dev(pd->disk); 2111 int ret; 2112 unsigned int write_speed, media_write_speed, read_speed; 2113 2114 ret = pkt_probe_settings(pd); 2115 if (ret) { 2116 dev_dbg(ddev, "failed probe\n"); 2117 return ret; 2118 } 2119 2120 ret = pkt_set_write_settings(pd); 2121 if (ret) { 2122 dev_notice(ddev, "failed saving write settings\n"); 2123 return -EIO; 2124 } 2125 2126 pkt_write_caching(pd); 2127 2128 ret = pkt_get_max_speed(pd, &write_speed); 2129 if (ret) 2130 write_speed = 16 * 177; 2131 switch (pd->mmc3_profile) { 2132 case 0x13: /* DVD-RW */ 2133 case 0x1a: /* DVD+RW */ 2134 case 0x12: /* DVD-RAM */ 2135 dev_notice(ddev, "write speed %ukB/s\n", write_speed); 2136 break; 2137 default: 2138 ret = pkt_media_speed(pd, &media_write_speed); 2139 if (ret) 2140 media_write_speed = 16; 2141 write_speed = min(write_speed, media_write_speed * 177); 2142 dev_notice(ddev, "write speed %ux\n", write_speed / 176); 2143 break; 2144 } 2145 read_speed = write_speed; 2146 2147 ret = pkt_set_speed(pd, write_speed, read_speed); 2148 if (ret) { 2149 dev_notice(ddev, "couldn't set write speed\n"); 2150 return -EIO; 2151 } 2152 pd->write_speed = write_speed; 2153 pd->read_speed = read_speed; 2154 2155 ret = pkt_perform_opc(pd); 2156 if (ret) 2157 dev_notice(ddev, "Optimum Power Calibration failed\n"); 2158 2159 return 0; 2160 } 2161 2162 /* 2163 * called at open time. 2164 */ 2165 static int pkt_open_dev(struct pktcdvd_device *pd, bool write) 2166 { 2167 struct device *ddev = disk_to_dev(pd->disk); 2168 int ret; 2169 long lba; 2170 struct request_queue *q; 2171 struct file *bdev_file; 2172 2173 /* 2174 * We need to re-open the cdrom device without O_NONBLOCK to be able 2175 * to read/write from/to it. It is already opened in O_NONBLOCK mode 2176 * so open should not fail. 2177 */ 2178 bdev_file = bdev_file_open_by_dev(file_bdev(pd->bdev_file)->bd_dev, 2179 BLK_OPEN_READ, pd, NULL); 2180 if (IS_ERR(bdev_file)) { 2181 ret = PTR_ERR(bdev_file); 2182 goto out; 2183 } 2184 pd->f_open_bdev = bdev_file; 2185 2186 ret = pkt_get_last_written(pd, &lba); 2187 if (ret) { 2188 dev_err(ddev, "pkt_get_last_written failed\n"); 2189 goto out_putdev; 2190 } 2191 2192 set_capacity(pd->disk, lba << 2); 2193 set_capacity_and_notify(file_bdev(pd->bdev_file)->bd_disk, lba << 2); 2194 2195 q = bdev_get_queue(file_bdev(pd->bdev_file)); 2196 if (write) { 2197 ret = pkt_open_write(pd); 2198 if (ret) 2199 goto out_putdev; 2200 set_bit(PACKET_WRITABLE, &pd->flags); 2201 } else { 2202 pkt_set_speed(pd, MAX_SPEED, MAX_SPEED); 2203 clear_bit(PACKET_WRITABLE, &pd->flags); 2204 } 2205 2206 ret = pkt_set_segment_merging(pd, q); 2207 if (ret) 2208 goto out_putdev; 2209 2210 if (write) { 2211 if (!pkt_grow_pktlist(pd, CONFIG_CDROM_PKTCDVD_BUFFERS)) { 2212 dev_err(ddev, "not enough memory for buffers\n"); 2213 ret = -ENOMEM; 2214 goto out_putdev; 2215 } 2216 dev_info(ddev, "%lukB available on disc\n", lba << 1); 2217 } 2218 set_blocksize(bdev_file, CD_FRAMESIZE); 2219 2220 return 0; 2221 2222 out_putdev: 2223 fput(bdev_file); 2224 out: 2225 return ret; 2226 } 2227 2228 /* 2229 * called when the device is closed. makes sure that the device flushes 2230 * the internal cache before we close. 2231 */ 2232 static void pkt_release_dev(struct pktcdvd_device *pd, int flush) 2233 { 2234 struct device *ddev = disk_to_dev(pd->disk); 2235 2236 if (flush && pkt_flush_cache(pd)) 2237 dev_notice(ddev, "not flushing cache\n"); 2238 2239 pkt_lock_door(pd, 0); 2240 2241 pkt_set_speed(pd, MAX_SPEED, MAX_SPEED); 2242 fput(pd->f_open_bdev); 2243 pd->f_open_bdev = NULL; 2244 2245 pkt_shrink_pktlist(pd); 2246 } 2247 2248 static struct pktcdvd_device *pkt_find_dev_from_minor(unsigned int dev_minor) 2249 { 2250 if (dev_minor >= MAX_WRITERS) 2251 return NULL; 2252 2253 dev_minor = array_index_nospec(dev_minor, MAX_WRITERS); 2254 return pkt_devs[dev_minor]; 2255 } 2256 2257 static int pkt_open(struct gendisk *disk, blk_mode_t mode) 2258 { 2259 struct pktcdvd_device *pd = NULL; 2260 int ret; 2261 2262 mutex_lock(&pktcdvd_mutex); 2263 mutex_lock(&ctl_mutex); 2264 pd = pkt_find_dev_from_minor(disk->first_minor); 2265 if (!pd) { 2266 ret = -ENODEV; 2267 goto out; 2268 } 2269 BUG_ON(pd->refcnt < 0); 2270 2271 pd->refcnt++; 2272 if (pd->refcnt > 1) { 2273 if ((mode & BLK_OPEN_WRITE) && 2274 !test_bit(PACKET_WRITABLE, &pd->flags)) { 2275 ret = -EBUSY; 2276 goto out_dec; 2277 } 2278 } else { 2279 ret = pkt_open_dev(pd, mode & BLK_OPEN_WRITE); 2280 if (ret) 2281 goto out_dec; 2282 } 2283 mutex_unlock(&ctl_mutex); 2284 mutex_unlock(&pktcdvd_mutex); 2285 return 0; 2286 2287 out_dec: 2288 pd->refcnt--; 2289 out: 2290 mutex_unlock(&ctl_mutex); 2291 mutex_unlock(&pktcdvd_mutex); 2292 return ret; 2293 } 2294 2295 static void pkt_release(struct gendisk *disk) 2296 { 2297 struct pktcdvd_device *pd = disk->private_data; 2298 2299 mutex_lock(&pktcdvd_mutex); 2300 mutex_lock(&ctl_mutex); 2301 pd->refcnt--; 2302 BUG_ON(pd->refcnt < 0); 2303 if (pd->refcnt == 0) { 2304 int flush = test_bit(PACKET_WRITABLE, &pd->flags); 2305 pkt_release_dev(pd, flush); 2306 } 2307 mutex_unlock(&ctl_mutex); 2308 mutex_unlock(&pktcdvd_mutex); 2309 } 2310 2311 2312 static void pkt_end_io_read_cloned(struct bio *bio) 2313 { 2314 struct packet_stacked_data *psd = bio->bi_private; 2315 struct pktcdvd_device *pd = psd->pd; 2316 2317 psd->bio->bi_status = bio->bi_status; 2318 bio_put(bio); 2319 bio_endio(psd->bio); 2320 mempool_free(psd, &psd_pool); 2321 pkt_bio_finished(pd); 2322 } 2323 2324 static void pkt_make_request_read(struct pktcdvd_device *pd, struct bio *bio) 2325 { 2326 struct bio *cloned_bio = bio_alloc_clone(file_bdev(pd->bdev_file), bio, 2327 GFP_NOIO, &pkt_bio_set); 2328 struct packet_stacked_data *psd = mempool_alloc(&psd_pool, GFP_NOIO); 2329 2330 psd->pd = pd; 2331 psd->bio = bio; 2332 cloned_bio->bi_private = psd; 2333 cloned_bio->bi_end_io = pkt_end_io_read_cloned; 2334 pd->stats.secs_r += bio_sectors(bio); 2335 pkt_queue_bio(pd, cloned_bio); 2336 } 2337 2338 static void pkt_make_request_write(struct bio *bio) 2339 { 2340 struct pktcdvd_device *pd = bio->bi_bdev->bd_disk->private_data; 2341 sector_t zone; 2342 struct packet_data *pkt; 2343 int was_empty, blocked_bio; 2344 struct pkt_rb_node *node; 2345 2346 zone = get_zone(bio->bi_iter.bi_sector, pd); 2347 2348 /* 2349 * If we find a matching packet in state WAITING or READ_WAIT, we can 2350 * just append this bio to that packet. 2351 */ 2352 spin_lock(&pd->cdrw.active_list_lock); 2353 blocked_bio = 0; 2354 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) { 2355 if (pkt->sector == zone) { 2356 spin_lock(&pkt->lock); 2357 if ((pkt->state == PACKET_WAITING_STATE) || 2358 (pkt->state == PACKET_READ_WAIT_STATE)) { 2359 bio_list_add(&pkt->orig_bios, bio); 2360 pkt->write_size += 2361 bio->bi_iter.bi_size / CD_FRAMESIZE; 2362 if ((pkt->write_size >= pkt->frames) && 2363 (pkt->state == PACKET_WAITING_STATE)) { 2364 atomic_inc(&pkt->run_sm); 2365 wake_up(&pd->wqueue); 2366 } 2367 spin_unlock(&pkt->lock); 2368 spin_unlock(&pd->cdrw.active_list_lock); 2369 return; 2370 } else { 2371 blocked_bio = 1; 2372 } 2373 spin_unlock(&pkt->lock); 2374 } 2375 } 2376 spin_unlock(&pd->cdrw.active_list_lock); 2377 2378 /* 2379 * Test if there is enough room left in the bio work queue 2380 * (queue size >= congestion on mark). 2381 * If not, wait till the work queue size is below the congestion off mark. 2382 */ 2383 spin_lock(&pd->lock); 2384 if (pd->write_congestion_on > 0 2385 && pd->bio_queue_size >= pd->write_congestion_on) { 2386 struct wait_bit_queue_entry wqe; 2387 2388 init_wait_var_entry(&wqe, &pd->congested, 0); 2389 for (;;) { 2390 prepare_to_wait_event(__var_waitqueue(&pd->congested), 2391 &wqe.wq_entry, 2392 TASK_UNINTERRUPTIBLE); 2393 if (pd->bio_queue_size <= pd->write_congestion_off) 2394 break; 2395 pd->congested = true; 2396 spin_unlock(&pd->lock); 2397 schedule(); 2398 spin_lock(&pd->lock); 2399 } 2400 } 2401 spin_unlock(&pd->lock); 2402 2403 /* 2404 * No matching packet found. Store the bio in the work queue. 2405 */ 2406 node = mempool_alloc(&pd->rb_pool, GFP_NOIO); 2407 node->bio = bio; 2408 spin_lock(&pd->lock); 2409 BUG_ON(pd->bio_queue_size < 0); 2410 was_empty = (pd->bio_queue_size == 0); 2411 pkt_rbtree_insert(pd, node); 2412 spin_unlock(&pd->lock); 2413 2414 /* 2415 * Wake up the worker thread. 2416 */ 2417 atomic_set(&pd->scan_queue, 1); 2418 if (was_empty) { 2419 /* This wake_up is required for correct operation */ 2420 wake_up(&pd->wqueue); 2421 } else if (!list_empty(&pd->cdrw.pkt_free_list) && !blocked_bio) { 2422 /* 2423 * This wake up is not required for correct operation, 2424 * but improves performance in some cases. 2425 */ 2426 wake_up(&pd->wqueue); 2427 } 2428 } 2429 2430 static void pkt_submit_bio(struct bio *bio) 2431 { 2432 struct pktcdvd_device *pd = bio->bi_bdev->bd_disk->private_data; 2433 struct device *ddev = disk_to_dev(pd->disk); 2434 struct bio *split; 2435 2436 bio = bio_split_to_limits(bio); 2437 if (!bio) 2438 return; 2439 2440 dev_dbg(ddev, "start = %6llx stop = %6llx\n", 2441 bio->bi_iter.bi_sector, bio_end_sector(bio)); 2442 2443 /* 2444 * Clone READ bios so we can have our own bi_end_io callback. 2445 */ 2446 if (bio_data_dir(bio) == READ) { 2447 pkt_make_request_read(pd, bio); 2448 return; 2449 } 2450 2451 if (!test_bit(PACKET_WRITABLE, &pd->flags)) { 2452 dev_notice(ddev, "WRITE for ro device (%llu)\n", bio->bi_iter.bi_sector); 2453 goto end_io; 2454 } 2455 2456 if (!bio->bi_iter.bi_size || (bio->bi_iter.bi_size % CD_FRAMESIZE)) { 2457 dev_err(ddev, "wrong bio size\n"); 2458 goto end_io; 2459 } 2460 2461 do { 2462 sector_t zone = get_zone(bio->bi_iter.bi_sector, pd); 2463 sector_t last_zone = get_zone(bio_end_sector(bio) - 1, pd); 2464 2465 if (last_zone != zone) { 2466 BUG_ON(last_zone != zone + pd->settings.size); 2467 2468 split = bio_split(bio, last_zone - 2469 bio->bi_iter.bi_sector, 2470 GFP_NOIO, &pkt_bio_set); 2471 bio_chain(split, bio); 2472 } else { 2473 split = bio; 2474 } 2475 2476 pkt_make_request_write(split); 2477 } while (split != bio); 2478 2479 return; 2480 end_io: 2481 bio_io_error(bio); 2482 } 2483 2484 static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) 2485 { 2486 struct device *ddev = disk_to_dev(pd->disk); 2487 int i; 2488 struct file *bdev_file; 2489 struct scsi_device *sdev; 2490 2491 if (pd->pkt_dev == dev) { 2492 dev_err(ddev, "recursive setup not allowed\n"); 2493 return -EBUSY; 2494 } 2495 for (i = 0; i < MAX_WRITERS; i++) { 2496 struct pktcdvd_device *pd2 = pkt_devs[i]; 2497 if (!pd2) 2498 continue; 2499 if (file_bdev(pd2->bdev_file)->bd_dev == dev) { 2500 dev_err(ddev, "%pg already setup\n", 2501 file_bdev(pd2->bdev_file)); 2502 return -EBUSY; 2503 } 2504 if (pd2->pkt_dev == dev) { 2505 dev_err(ddev, "can't chain pktcdvd devices\n"); 2506 return -EBUSY; 2507 } 2508 } 2509 2510 bdev_file = bdev_file_open_by_dev(dev, BLK_OPEN_READ | BLK_OPEN_NDELAY, 2511 NULL, NULL); 2512 if (IS_ERR(bdev_file)) 2513 return PTR_ERR(bdev_file); 2514 sdev = scsi_device_from_queue(file_bdev(bdev_file)->bd_disk->queue); 2515 if (!sdev) { 2516 fput(bdev_file); 2517 return -EINVAL; 2518 } 2519 put_device(&sdev->sdev_gendev); 2520 2521 /* This is safe, since we have a reference from open(). */ 2522 __module_get(THIS_MODULE); 2523 2524 pd->bdev_file = bdev_file; 2525 2526 atomic_set(&pd->cdrw.pending_bios, 0); 2527 pd->cdrw.thread = kthread_run(kcdrwd, pd, "%s", pd->disk->disk_name); 2528 if (IS_ERR(pd->cdrw.thread)) { 2529 dev_err(ddev, "can't start kernel thread\n"); 2530 goto out_mem; 2531 } 2532 2533 proc_create_single_data(pd->disk->disk_name, 0, pkt_proc, pkt_seq_show, pd); 2534 dev_notice(ddev, "writer mapped to %pg\n", file_bdev(bdev_file)); 2535 return 0; 2536 2537 out_mem: 2538 fput(bdev_file); 2539 /* This is safe: open() is still holding a reference. */ 2540 module_put(THIS_MODULE); 2541 return -ENOMEM; 2542 } 2543 2544 static int pkt_ioctl(struct block_device *bdev, blk_mode_t mode, 2545 unsigned int cmd, unsigned long arg) 2546 { 2547 struct pktcdvd_device *pd = bdev->bd_disk->private_data; 2548 struct device *ddev = disk_to_dev(pd->disk); 2549 int ret; 2550 2551 dev_dbg(ddev, "cmd %x, dev %d:%d\n", cmd, MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev)); 2552 2553 mutex_lock(&pktcdvd_mutex); 2554 switch (cmd) { 2555 case CDROMEJECT: 2556 /* 2557 * The door gets locked when the device is opened, so we 2558 * have to unlock it or else the eject command fails. 2559 */ 2560 if (pd->refcnt == 1) 2561 pkt_lock_door(pd, 0); 2562 fallthrough; 2563 /* 2564 * forward selected CDROM ioctls to CD-ROM, for UDF 2565 */ 2566 case CDROMMULTISESSION: 2567 case CDROMREADTOCENTRY: 2568 case CDROM_LAST_WRITTEN: 2569 case CDROM_SEND_PACKET: 2570 case SCSI_IOCTL_SEND_COMMAND: 2571 if (!bdev->bd_disk->fops->ioctl) 2572 ret = -ENOTTY; 2573 else 2574 ret = bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg); 2575 break; 2576 default: 2577 dev_dbg(ddev, "Unknown ioctl (%x)\n", cmd); 2578 ret = -ENOTTY; 2579 } 2580 mutex_unlock(&pktcdvd_mutex); 2581 2582 return ret; 2583 } 2584 2585 static unsigned int pkt_check_events(struct gendisk *disk, 2586 unsigned int clearing) 2587 { 2588 struct pktcdvd_device *pd = disk->private_data; 2589 struct gendisk *attached_disk; 2590 2591 if (!pd) 2592 return 0; 2593 if (!pd->bdev_file) 2594 return 0; 2595 attached_disk = file_bdev(pd->bdev_file)->bd_disk; 2596 if (!attached_disk || !attached_disk->fops->check_events) 2597 return 0; 2598 return attached_disk->fops->check_events(attached_disk, clearing); 2599 } 2600 2601 static char *pkt_devnode(struct gendisk *disk, umode_t *mode) 2602 { 2603 return kasprintf(GFP_KERNEL, "pktcdvd/%s", disk->disk_name); 2604 } 2605 2606 static const struct block_device_operations pktcdvd_ops = { 2607 .owner = THIS_MODULE, 2608 .submit_bio = pkt_submit_bio, 2609 .open = pkt_open, 2610 .release = pkt_release, 2611 .ioctl = pkt_ioctl, 2612 .compat_ioctl = blkdev_compat_ptr_ioctl, 2613 .check_events = pkt_check_events, 2614 .devnode = pkt_devnode, 2615 }; 2616 2617 /* 2618 * Set up mapping from pktcdvd device to CD-ROM device. 2619 */ 2620 static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev) 2621 { 2622 struct queue_limits lim = { 2623 .max_hw_sectors = PACKET_MAX_SECTORS, 2624 .logical_block_size = CD_FRAMESIZE, 2625 .features = BLK_FEAT_ROTATIONAL, 2626 }; 2627 int idx; 2628 int ret = -ENOMEM; 2629 struct pktcdvd_device *pd; 2630 struct gendisk *disk; 2631 2632 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); 2633 2634 for (idx = 0; idx < MAX_WRITERS; idx++) 2635 if (!pkt_devs[idx]) 2636 break; 2637 if (idx == MAX_WRITERS) { 2638 pr_err("max %d writers supported\n", MAX_WRITERS); 2639 ret = -EBUSY; 2640 goto out_mutex; 2641 } 2642 2643 pd = kzalloc(sizeof(struct pktcdvd_device), GFP_KERNEL); 2644 if (!pd) 2645 goto out_mutex; 2646 2647 ret = mempool_init_kmalloc_pool(&pd->rb_pool, PKT_RB_POOL_SIZE, 2648 sizeof(struct pkt_rb_node)); 2649 if (ret) 2650 goto out_mem; 2651 2652 INIT_LIST_HEAD(&pd->cdrw.pkt_free_list); 2653 INIT_LIST_HEAD(&pd->cdrw.pkt_active_list); 2654 spin_lock_init(&pd->cdrw.active_list_lock); 2655 2656 spin_lock_init(&pd->lock); 2657 spin_lock_init(&pd->iosched.lock); 2658 bio_list_init(&pd->iosched.read_queue); 2659 bio_list_init(&pd->iosched.write_queue); 2660 init_waitqueue_head(&pd->wqueue); 2661 pd->bio_queue = RB_ROOT; 2662 2663 pd->write_congestion_on = write_congestion_on; 2664 pd->write_congestion_off = write_congestion_off; 2665 2666 disk = blk_alloc_disk(&lim, NUMA_NO_NODE); 2667 if (IS_ERR(disk)) { 2668 ret = PTR_ERR(disk); 2669 goto out_mem; 2670 } 2671 pd->disk = disk; 2672 disk->major = pktdev_major; 2673 disk->first_minor = idx; 2674 disk->minors = 1; 2675 disk->fops = &pktcdvd_ops; 2676 disk->flags = GENHD_FL_REMOVABLE | GENHD_FL_NO_PART; 2677 snprintf(disk->disk_name, sizeof(disk->disk_name), DRIVER_NAME"%d", idx); 2678 disk->private_data = pd; 2679 2680 pd->pkt_dev = MKDEV(pktdev_major, idx); 2681 ret = pkt_new_dev(pd, dev); 2682 if (ret) 2683 goto out_mem2; 2684 2685 /* inherit events of the host device */ 2686 disk->events = file_bdev(pd->bdev_file)->bd_disk->events; 2687 2688 ret = add_disk(disk); 2689 if (ret) 2690 goto out_mem2; 2691 2692 pkt_sysfs_dev_new(pd); 2693 pkt_debugfs_dev_new(pd); 2694 2695 pkt_devs[idx] = pd; 2696 if (pkt_dev) 2697 *pkt_dev = pd->pkt_dev; 2698 2699 mutex_unlock(&ctl_mutex); 2700 return 0; 2701 2702 out_mem2: 2703 put_disk(disk); 2704 out_mem: 2705 mempool_exit(&pd->rb_pool); 2706 kfree(pd); 2707 out_mutex: 2708 mutex_unlock(&ctl_mutex); 2709 pr_err("setup of pktcdvd device failed\n"); 2710 return ret; 2711 } 2712 2713 /* 2714 * Tear down mapping from pktcdvd device to CD-ROM device. 2715 */ 2716 static int pkt_remove_dev(dev_t pkt_dev) 2717 { 2718 struct pktcdvd_device *pd; 2719 struct device *ddev; 2720 int idx; 2721 int ret = 0; 2722 2723 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); 2724 2725 for (idx = 0; idx < MAX_WRITERS; idx++) { 2726 pd = pkt_devs[idx]; 2727 if (pd && (pd->pkt_dev == pkt_dev)) 2728 break; 2729 } 2730 if (idx == MAX_WRITERS) { 2731 pr_debug("dev not setup\n"); 2732 ret = -ENXIO; 2733 goto out; 2734 } 2735 2736 if (pd->refcnt > 0) { 2737 ret = -EBUSY; 2738 goto out; 2739 } 2740 2741 ddev = disk_to_dev(pd->disk); 2742 2743 if (!IS_ERR(pd->cdrw.thread)) 2744 kthread_stop(pd->cdrw.thread); 2745 2746 pkt_devs[idx] = NULL; 2747 2748 pkt_debugfs_dev_remove(pd); 2749 pkt_sysfs_dev_remove(pd); 2750 2751 fput(pd->bdev_file); 2752 2753 remove_proc_entry(pd->disk->disk_name, pkt_proc); 2754 dev_notice(ddev, "writer unmapped\n"); 2755 2756 del_gendisk(pd->disk); 2757 put_disk(pd->disk); 2758 2759 mempool_exit(&pd->rb_pool); 2760 kfree(pd); 2761 2762 /* This is safe: open() is still holding a reference. */ 2763 module_put(THIS_MODULE); 2764 2765 out: 2766 mutex_unlock(&ctl_mutex); 2767 return ret; 2768 } 2769 2770 static void pkt_get_status(struct pkt_ctrl_command *ctrl_cmd) 2771 { 2772 struct pktcdvd_device *pd; 2773 2774 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); 2775 2776 pd = pkt_find_dev_from_minor(ctrl_cmd->dev_index); 2777 if (pd) { 2778 ctrl_cmd->dev = new_encode_dev(file_bdev(pd->bdev_file)->bd_dev); 2779 ctrl_cmd->pkt_dev = new_encode_dev(pd->pkt_dev); 2780 } else { 2781 ctrl_cmd->dev = 0; 2782 ctrl_cmd->pkt_dev = 0; 2783 } 2784 ctrl_cmd->num_devices = MAX_WRITERS; 2785 2786 mutex_unlock(&ctl_mutex); 2787 } 2788 2789 static long pkt_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2790 { 2791 void __user *argp = (void __user *)arg; 2792 struct pkt_ctrl_command ctrl_cmd; 2793 int ret = 0; 2794 dev_t pkt_dev = 0; 2795 2796 if (cmd != PACKET_CTRL_CMD) 2797 return -ENOTTY; 2798 2799 if (copy_from_user(&ctrl_cmd, argp, sizeof(struct pkt_ctrl_command))) 2800 return -EFAULT; 2801 2802 switch (ctrl_cmd.command) { 2803 case PKT_CTRL_CMD_SETUP: 2804 if (!capable(CAP_SYS_ADMIN)) 2805 return -EPERM; 2806 ret = pkt_setup_dev(new_decode_dev(ctrl_cmd.dev), &pkt_dev); 2807 ctrl_cmd.pkt_dev = new_encode_dev(pkt_dev); 2808 break; 2809 case PKT_CTRL_CMD_TEARDOWN: 2810 if (!capable(CAP_SYS_ADMIN)) 2811 return -EPERM; 2812 ret = pkt_remove_dev(new_decode_dev(ctrl_cmd.pkt_dev)); 2813 break; 2814 case PKT_CTRL_CMD_STATUS: 2815 pkt_get_status(&ctrl_cmd); 2816 break; 2817 default: 2818 return -ENOTTY; 2819 } 2820 2821 if (copy_to_user(argp, &ctrl_cmd, sizeof(struct pkt_ctrl_command))) 2822 return -EFAULT; 2823 return ret; 2824 } 2825 2826 #ifdef CONFIG_COMPAT 2827 static long pkt_ctl_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2828 { 2829 return pkt_ctl_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 2830 } 2831 #endif 2832 2833 static const struct file_operations pkt_ctl_fops = { 2834 .open = nonseekable_open, 2835 .unlocked_ioctl = pkt_ctl_ioctl, 2836 #ifdef CONFIG_COMPAT 2837 .compat_ioctl = pkt_ctl_compat_ioctl, 2838 #endif 2839 .owner = THIS_MODULE, 2840 .llseek = no_llseek, 2841 }; 2842 2843 static struct miscdevice pkt_misc = { 2844 .minor = MISC_DYNAMIC_MINOR, 2845 .name = DRIVER_NAME, 2846 .nodename = "pktcdvd/control", 2847 .fops = &pkt_ctl_fops 2848 }; 2849 2850 static int __init pkt_init(void) 2851 { 2852 int ret; 2853 2854 mutex_init(&ctl_mutex); 2855 2856 ret = mempool_init_kmalloc_pool(&psd_pool, PSD_POOL_SIZE, 2857 sizeof(struct packet_stacked_data)); 2858 if (ret) 2859 return ret; 2860 ret = bioset_init(&pkt_bio_set, BIO_POOL_SIZE, 0, 0); 2861 if (ret) { 2862 mempool_exit(&psd_pool); 2863 return ret; 2864 } 2865 2866 ret = register_blkdev(pktdev_major, DRIVER_NAME); 2867 if (ret < 0) { 2868 pr_err("unable to register block device\n"); 2869 goto out2; 2870 } 2871 if (!pktdev_major) 2872 pktdev_major = ret; 2873 2874 ret = pkt_sysfs_init(); 2875 if (ret) 2876 goto out; 2877 2878 pkt_debugfs_init(); 2879 2880 ret = misc_register(&pkt_misc); 2881 if (ret) { 2882 pr_err("unable to register misc device\n"); 2883 goto out_misc; 2884 } 2885 2886 pkt_proc = proc_mkdir("driver/"DRIVER_NAME, NULL); 2887 2888 return 0; 2889 2890 out_misc: 2891 pkt_debugfs_cleanup(); 2892 pkt_sysfs_cleanup(); 2893 out: 2894 unregister_blkdev(pktdev_major, DRIVER_NAME); 2895 out2: 2896 mempool_exit(&psd_pool); 2897 bioset_exit(&pkt_bio_set); 2898 return ret; 2899 } 2900 2901 static void __exit pkt_exit(void) 2902 { 2903 remove_proc_entry("driver/"DRIVER_NAME, NULL); 2904 misc_deregister(&pkt_misc); 2905 2906 pkt_debugfs_cleanup(); 2907 pkt_sysfs_cleanup(); 2908 2909 unregister_blkdev(pktdev_major, DRIVER_NAME); 2910 mempool_exit(&psd_pool); 2911 bioset_exit(&pkt_bio_set); 2912 } 2913 2914 MODULE_DESCRIPTION("Packet writing layer for CD/DVD drives"); 2915 MODULE_AUTHOR("Jens Axboe <axboe@suse.de>"); 2916 MODULE_LICENSE("GPL"); 2917 2918 module_init(pkt_init); 2919 module_exit(pkt_exit); 2920