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