drivers/block/pktcdvd.c

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