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