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