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