+18

Documentation/ABI/testing/debugfs-pktcdvd

reviewed

··· 1 1 + What: /sys/kernel/debug/pktcdvd/pktcdvd[0-7] 2 2 + Date: Oct. 2006 3 3 + KernelVersion: 2.6.20 4 4 + Contact: Thomas Maier <balagi@justmail.de> 5 5 + Description: 6 6 + 7 7 + The pktcdvd module (packet writing driver) creates 8 8 + these files in debugfs: 9 9 + 10 10 + /sys/kernel/debug/pktcdvd/pktcdvd[0-7]/ 11 11 + 12 12 + ==== ====== ==================================== 13 13 + info 0444 Lots of driver statistics and infos. 14 14 + ==== ====== ==================================== 15 15 + 16 16 + Example:: 17 17 + 18 18 + cat /sys/kernel/debug/pktcdvd/pktcdvd0/info

+97

Documentation/ABI/testing/sysfs-class-pktcdvd

reviewed

··· 1 1 + sysfs interface 2 2 + --------------- 3 3 + The pktcdvd module (packet writing driver) creates the following files in the 4 4 + sysfs: (<devid> is in the format major:minor) 5 5 + 6 6 + What: /sys/class/pktcdvd/add 7 7 + What: /sys/class/pktcdvd/remove 8 8 + What: /sys/class/pktcdvd/device_map 9 9 + Date: Oct. 2006 10 10 + KernelVersion: 2.6.20 11 11 + Contact: Thomas Maier <balagi@justmail.de> 12 12 + Description: 13 13 + 14 14 + ========== ============================================== 15 15 + add (WO) Write a block device id (major:minor) to 16 16 + create a new pktcdvd device and map it to the 17 17 + block device. 18 18 + 19 19 + remove (WO) Write the pktcdvd device id (major:minor) 20 20 + to remove the pktcdvd device. 21 21 + 22 22 + device_map (RO) Shows the device mapping in format: 23 23 + pktcdvd[0-7] <pktdevid> <blkdevid> 24 24 + ========== ============================================== 25 25 + 26 26 + 27 27 + What: /sys/class/pktcdvd/pktcdvd[0-7]/dev 28 28 + What: /sys/class/pktcdvd/pktcdvd[0-7]/uevent 29 29 + Date: Oct. 2006 30 30 + KernelVersion: 2.6.20 31 31 + Contact: Thomas Maier <balagi@justmail.de> 32 32 + Description: 33 33 + dev: (RO) Device id 34 34 + 35 35 + uevent: (WO) To send a uevent 36 36 + 37 37 + 38 38 + What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/packets_started 39 39 + What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/packets_finished 40 40 + What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/kb_written 41 41 + What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/kb_read 42 42 + What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/kb_read_gather 43 43 + What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/reset 44 44 + Date: Oct. 2006 45 45 + KernelVersion: 2.6.20 46 46 + Contact: Thomas Maier <balagi@justmail.de> 47 47 + Description: 48 48 + packets_started: (RO) Number of started packets. 49 49 + 50 50 + packets_finished: (RO) Number of finished packets. 51 51 + 52 52 + kb_written: (RO) kBytes written. 53 53 + 54 54 + kb_read: (RO) kBytes read. 55 55 + 56 56 + kb_read_gather: (RO) kBytes read to fill write packets. 57 57 + 58 58 + reset: (WO) Write any value to it to reset 59 59 + pktcdvd device statistic values, like 60 60 + bytes read/written. 61 61 + 62 62 + 63 63 + What: /sys/class/pktcdvd/pktcdvd[0-7]/write_queue/size 64 64 + What: /sys/class/pktcdvd/pktcdvd[0-7]/write_queue/congestion_off 65 65 + What: /sys/class/pktcdvd/pktcdvd[0-7]/write_queue/congestion_on 66 66 + Date: Oct. 2006 67 67 + KernelVersion: 2.6.20 68 68 + Contact: Thomas Maier <balagi@justmail.de> 69 69 + Description: 70 70 + ============== ================================================ 71 71 + size (RO) Contains the size of the bio write queue. 72 72 + 73 73 + congestion_off (RW) If bio write queue size is below this mark, 74 74 + accept new bio requests from the block layer. 75 75 + 76 76 + congestion_on (RW) If bio write queue size is higher as this 77 77 + mark, do no longer accept bio write requests 78 78 + from the block layer and wait till the pktcdvd 79 79 + device has processed enough bio's so that bio 80 80 + write queue size is below congestion off mark. 81 81 + A value of <= 0 disables congestion control. 82 82 + ============== ================================================ 83 83 + 84 84 + 85 85 + Example: 86 86 + -------- 87 87 + To use the pktcdvd sysfs interface directly, you can do:: 88 88 + 89 89 + # create a new pktcdvd device mapped to /dev/hdc 90 90 + echo "22:0" >/sys/class/pktcdvd/add 91 91 + cat /sys/class/pktcdvd/device_map 92 92 + # assuming device pktcdvd0 was created, look at stat's 93 93 + cat /sys/class/pktcdvd/pktcdvd0/stat/kb_written 94 94 + # print the device id of the mapped block device 95 95 + fgrep pktcdvd0 /sys/class/pktcdvd/device_map 96 96 + # remove device, using pktcdvd0 device id 253:0 97 97 + echo "253:0" >/sys/class/pktcdvd/remove

+7

MAINTAINERS

reviewed

··· 16610 16610 F: Documentation/devicetree/bindings/input/pine64,pinephone-keyboard.yaml 16611 16611 F: drivers/input/keyboard/pinephone-keyboard.c 16612 16612 16613 16613 + PKTCDVD DRIVER 16614 16614 + M: linux-block@vger.kernel.org 16615 16615 + S: Orphan 16616 16616 + F: drivers/block/pktcdvd.c 16617 16617 + F: include/linux/pktcdvd.h 16618 16618 + F: include/uapi/linux/pktcdvd.h 16619 16619 + 16613 16620 PLANTOWER PMS7003 AIR POLLUTION SENSOR DRIVER 16614 16621 M: Tomasz Duszynski <tduszyns@gmail.com> 16615 16622 S: Maintained

-1

block/Kconfig

reviewed

··· 6 6 bool "Enable the block layer" if EXPERT 7 7 default y 8 8 select SBITMAP 9 9 - select SRCU 10 9 help 11 10 Provide block layer support for the kernel. 12 11

+22 -15

block/bio.c

reviewed

··· 1401 1401 } 1402 1402 EXPORT_SYMBOL(__bio_advance); 1403 1403 1404 1404 + void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter, 1405 1405 + struct bio *src, struct bvec_iter *src_iter) 1406 1406 + { 1407 1407 + while (src_iter->bi_size && dst_iter->bi_size) { 1408 1408 + struct bio_vec src_bv = bio_iter_iovec(src, *src_iter); 1409 1409 + struct bio_vec dst_bv = bio_iter_iovec(dst, *dst_iter); 1410 1410 + unsigned int bytes = min(src_bv.bv_len, dst_bv.bv_len); 1411 1411 + void *src_buf = bvec_kmap_local(&src_bv); 1412 1412 + void *dst_buf = bvec_kmap_local(&dst_bv); 1413 1413 + 1414 1414 + memcpy(dst_buf, src_buf, bytes); 1415 1415 + 1416 1416 + kunmap_local(dst_buf); 1417 1417 + kunmap_local(src_buf); 1418 1418 + 1419 1419 + bio_advance_iter_single(src, src_iter, bytes); 1420 1420 + bio_advance_iter_single(dst, dst_iter, bytes); 1421 1421 + } 1422 1422 + } 1423 1423 + EXPORT_SYMBOL(bio_copy_data_iter); 1424 1424 + 1404 1425 /** 1405 1426 * bio_copy_data - copy contents of data buffers from one bio to another 1406 1427 * @src: source bio ··· 1435 1414 struct bvec_iter src_iter = src->bi_iter; 1436 1415 struct bvec_iter dst_iter = dst->bi_iter; 1437 1416 1438 1438 - while (src_iter.bi_size && dst_iter.bi_size) { 1439 1439 - struct bio_vec src_bv = bio_iter_iovec(src, src_iter); 1440 1440 - struct bio_vec dst_bv = bio_iter_iovec(dst, dst_iter); 1441 1441 - unsigned int bytes = min(src_bv.bv_len, dst_bv.bv_len); 1442 1442 - void *src_buf = bvec_kmap_local(&src_bv); 1443 1443 - void *dst_buf = bvec_kmap_local(&dst_bv); 1444 1444 - 1445 1445 - memcpy(dst_buf, src_buf, bytes); 1446 1446 - 1447 1447 - kunmap_local(dst_buf); 1448 1448 - kunmap_local(src_buf); 1449 1449 - 1450 1450 - bio_advance_iter_single(src, &src_iter, bytes); 1451 1451 - bio_advance_iter_single(dst, &dst_iter, bytes); 1452 1452 - } 1417 1417 + bio_copy_data_iter(dst, &dst_iter, src, &src_iter); 1453 1418 } 1454 1419 EXPORT_SYMBOL(bio_copy_data); 1455 1420

+13 -1

block/blk-merge.c

reviewed

··· 309 309 *segs = nsegs; 310 310 return NULL; 311 311 split: 312 312 + /* 313 313 + * We can't sanely support splitting for a REQ_NOWAIT bio. End it 314 314 + * with EAGAIN if splitting is required and return an error pointer. 315 315 + */ 316 316 + if (bio->bi_opf & REQ_NOWAIT) { 317 317 + bio->bi_status = BLK_STS_AGAIN; 318 318 + bio_endio(bio); 319 319 + return ERR_PTR(-EAGAIN); 320 320 + } 321 321 + 312 322 *segs = nsegs; 313 323 314 324 /* ··· 368 358 default: 369 359 split = bio_split_rw(bio, lim, nr_segs, bs, 370 360 get_max_io_size(bio, lim) << SECTOR_SHIFT); 361 361 + if (IS_ERR(split)) 362 362 + return NULL; 371 363 break; 372 364 } 373 365 374 366 if (split) { 375 375 - /* there isn't chance to merge the splitted bio */ 367 367 + /* there isn't chance to merge the split bio */ 376 368 split->bi_opf |= REQ_NOMERGE; 377 369 378 370 blkcg_bio_issue_init(split);

+4 -1

block/blk-mq.c

reviewed

··· 2951 2951 blk_status_t ret; 2952 2952 2953 2953 bio = blk_queue_bounce(bio, q); 2954 2954 - if (bio_may_exceed_limits(bio, &q->limits)) 2954 2954 + if (bio_may_exceed_limits(bio, &q->limits)) { 2955 2955 bio = __bio_split_to_limits(bio, &q->limits, &nr_segs); 2956 2956 + if (!bio) 2957 2957 + return; 2958 2958 + } 2956 2959 2957 2960 if (!bio_integrity_prep(bio)) 2958 2961 return;

+11

block/genhd.c

reviewed

··· 1201 1201 .dev_uevent = block_uevent, 1202 1202 }; 1203 1203 1204 1204 + static char *block_devnode(struct device *dev, umode_t *mode, 1205 1205 + kuid_t *uid, kgid_t *gid) 1206 1206 + { 1207 1207 + struct gendisk *disk = dev_to_disk(dev); 1208 1208 + 1209 1209 + if (disk->fops->devnode) 1210 1210 + return disk->fops->devnode(disk, mode); 1211 1211 + return NULL; 1212 1212 + } 1213 1213 + 1204 1214 const struct device_type disk_type = { 1205 1215 .name = "disk", 1206 1216 .groups = disk_attr_groups, 1207 1217 .release = disk_release, 1218 1218 + .devnode = block_devnode, 1208 1219 }; 1209 1220 1210 1221 #ifdef CONFIG_PROC_FS

+43

drivers/block/Kconfig

reviewed

··· 285 285 The default value is 4096 kilobytes. Only change this if you know 286 286 what you are doing. 287 287 288 288 + config CDROM_PKTCDVD 289 289 + tristate "Packet writing on CD/DVD media (DEPRECATED)" 290 290 + depends on !UML 291 291 + depends on SCSI 292 292 + select CDROM 293 293 + help 294 294 + Note: This driver is deprecated and will be removed from the 295 295 + kernel in the near future! 296 296 + 297 297 + If you have a CDROM/DVD drive that supports packet writing, say 298 298 + Y to include support. It should work with any MMC/Mt Fuji 299 299 + compliant ATAPI or SCSI drive, which is just about any newer 300 300 + DVD/CD writer. 301 301 + 302 302 + Currently only writing to CD-RW, DVD-RW, DVD+RW and DVDRAM discs 303 303 + is possible. 304 304 + DVD-RW disks must be in restricted overwrite mode. 305 305 + 306 306 + See the file <file:Documentation/cdrom/packet-writing.rst> 307 307 + for further information on the use of this driver. 308 308 + 309 309 + To compile this driver as a module, choose M here: the 310 310 + module will be called pktcdvd. 311 311 + 312 312 + config CDROM_PKTCDVD_BUFFERS 313 313 + int "Free buffers for data gathering" 314 314 + depends on CDROM_PKTCDVD 315 315 + default "8" 316 316 + help 317 317 + This controls the maximum number of active concurrent packets. More 318 318 + concurrent packets can increase write performance, but also require 319 319 + more memory. Each concurrent packet will require approximately 64Kb 320 320 + of non-swappable kernel memory, memory which will be allocated when 321 321 + a disc is opened for writing. 322 322 + 323 323 + config CDROM_PKTCDVD_WCACHE 324 324 + bool "Enable write caching" 325 325 + depends on CDROM_PKTCDVD 326 326 + help 327 327 + If enabled, write caching will be set for the CD-R/W device. For now 328 328 + this option is dangerous unless the CD-RW media is known good, as we 329 329 + don't do deferred write error handling yet. 330 330 + 288 331 config ATA_OVER_ETH 289 332 tristate "ATA over Ethernet support" 290 333 depends on NET

+1

drivers/block/Makefile

reviewed

··· 20 20 obj-$(CONFIG_N64CART) += n64cart.o 21 21 obj-$(CONFIG_BLK_DEV_RAM) += brd.o 22 22 obj-$(CONFIG_BLK_DEV_LOOP) += loop.o 23 23 + obj-$(CONFIG_CDROM_PKTCDVD) += pktcdvd.o 23 24 obj-$(CONFIG_SUNVDC) += sunvdc.o 24 25 25 26 obj-$(CONFIG_BLK_DEV_NBD) += nbd.o

+2

drivers/block/drbd/drbd_req.c

reviewed

··· 1607 1607 struct drbd_device *device = bio->bi_bdev->bd_disk->private_data; 1608 1608 1609 1609 bio = bio_split_to_limits(bio); 1610 1610 + if (!bio) 1611 1611 + return; 1610 1612 1611 1613 /* 1612 1614 * what we "blindly" assume:

+2944

drivers/block/pktcdvd.c

reviewed

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

+2

drivers/block/ps3vram.c

reviewed

··· 587 587 dev_dbg(&dev->core, "%s\n", __func__); 588 588 589 589 bio = bio_split_to_limits(bio); 590 590 + if (!bio) 591 591 + return; 590 592 591 593 spin_lock_irq(&priv->lock); 592 594 busy = !bio_list_empty(&priv->list);

+3

drivers/block/ublk_drv.c

reviewed

··· 1992 1992 struct ublksrv_ctrl_cmd *header = (struct ublksrv_ctrl_cmd *)cmd->cmd; 1993 1993 int ret = -EINVAL; 1994 1994 1995 1995 + if (issue_flags & IO_URING_F_NONBLOCK) 1996 1996 + return -EAGAIN; 1997 1997 + 1995 1998 ublk_ctrl_cmd_dump(cmd); 1996 1999 1997 2000 if (!(issue_flags & IO_URING_F_SQE128))

+2

drivers/md/dm.c

reviewed

··· 1742 1742 * otherwise associated queue_limits won't be imposed. 1743 1743 */ 1744 1744 bio = bio_split_to_limits(bio); 1745 1745 + if (!bio) 1746 1746 + return; 1745 1747 } 1746 1748 1747 1749 init_clone_info(&ci, md, map, bio, is_abnormal);

+2

drivers/md/md.c

reviewed

··· 455 455 } 456 456 457 457 bio = bio_split_to_limits(bio); 458 458 + if (!bio) 459 459 + return; 458 460 459 461 if (mddev->ro == MD_RDONLY && unlikely(rw == WRITE)) { 460 462 if (bio_sectors(bio) != 0)

+2

drivers/nvme/host/multipath.c

reviewed

··· 376 376 * pool from the original queue to allocate the bvecs from. 377 377 */ 378 378 bio = bio_split_to_limits(bio); 379 379 + if (!bio) 380 380 + return; 379 381 380 382 srcu_idx = srcu_read_lock(&head->srcu); 381 383 ns = nvme_find_path(head);

+2

drivers/s390/block/dcssblk.c

reviewed

··· 865 865 unsigned long bytes_done; 866 866 867 867 bio = bio_split_to_limits(bio); 868 868 + if (!bio) 869 869 + return; 868 870 869 871 bytes_done = 0; 870 872 dev_info = bio->bi_bdev->bd_disk->private_data;

+2

include/linux/bio.h

reviewed

··· 475 475 extern void bio_set_pages_dirty(struct bio *bio); 476 476 extern void bio_check_pages_dirty(struct bio *bio); 477 477 478 478 + extern void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter, 479 479 + struct bio *src, struct bvec_iter *src_iter); 478 480 extern void bio_copy_data(struct bio *dst, struct bio *src); 479 481 extern void bio_free_pages(struct bio *bio); 480 482 void guard_bio_eod(struct bio *bio);

+1

include/linux/blkdev.h

reviewed

··· 1395 1395 void (*swap_slot_free_notify) (struct block_device *, unsigned long); 1396 1396 int (*report_zones)(struct gendisk *, sector_t sector, 1397 1397 unsigned int nr_zones, report_zones_cb cb, void *data); 1398 1398 + char *(*devnode)(struct gendisk *disk, umode_t *mode); 1398 1399 /* returns the length of the identifier or a negative errno: */ 1399 1400 int (*get_unique_id)(struct gendisk *disk, u8 id[16], 1400 1401 enum blk_unique_id id_type);

+197

include/linux/pktcdvd.h

reviewed

··· 1 1 + /* 2 2 + * Copyright (C) 2000 Jens Axboe <axboe@suse.de> 3 3 + * Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com> 4 4 + * 5 5 + * May be copied or modified under the terms of the GNU General Public 6 6 + * License. See linux/COPYING for more information. 7 7 + * 8 8 + * Packet writing layer for ATAPI and SCSI CD-R, CD-RW, DVD-R, and 9 9 + * DVD-RW devices. 10 10 + * 11 11 + */ 12 12 + #ifndef __PKTCDVD_H 13 13 + #define __PKTCDVD_H 14 14 + 15 15 + #include <linux/blkdev.h> 16 16 + #include <linux/completion.h> 17 17 + #include <linux/cdrom.h> 18 18 + #include <linux/kobject.h> 19 19 + #include <linux/sysfs.h> 20 20 + #include <linux/mempool.h> 21 21 + #include <uapi/linux/pktcdvd.h> 22 22 + 23 23 + /* default bio write queue congestion marks */ 24 24 + #define PKT_WRITE_CONGESTION_ON 10000 25 25 + #define PKT_WRITE_CONGESTION_OFF 9000 26 26 + 27 27 + 28 28 + struct packet_settings 29 29 + { 30 30 + __u32 size; /* packet size in (512 byte) sectors */ 31 31 + __u8 fp; /* fixed packets */ 32 32 + __u8 link_loss; /* the rest is specified 33 33 + * as per Mt Fuji */ 34 34 + __u8 write_type; 35 35 + __u8 track_mode; 36 36 + __u8 block_mode; 37 37 + }; 38 38 + 39 39 + /* 40 40 + * Very crude stats for now 41 41 + */ 42 42 + struct packet_stats 43 43 + { 44 44 + unsigned long pkt_started; 45 45 + unsigned long pkt_ended; 46 46 + unsigned long secs_w; 47 47 + unsigned long secs_rg; 48 48 + unsigned long secs_r; 49 49 + }; 50 50 + 51 51 + struct packet_cdrw 52 52 + { 53 53 + struct list_head pkt_free_list; 54 54 + struct list_head pkt_active_list; 55 55 + spinlock_t active_list_lock; /* Serialize access to pkt_active_list */ 56 56 + struct task_struct *thread; 57 57 + atomic_t pending_bios; 58 58 + }; 59 59 + 60 60 + /* 61 61 + * Switch to high speed reading after reading this many kilobytes 62 62 + * with no interspersed writes. 63 63 + */ 64 64 + #define HI_SPEED_SWITCH 512 65 65 + 66 66 + struct packet_iosched 67 67 + { 68 68 + atomic_t attention; /* Set to non-zero when queue processing is needed */ 69 69 + int writing; /* Non-zero when writing, zero when reading */ 70 70 + spinlock_t lock; /* Protecting read/write queue manipulations */ 71 71 + struct bio_list read_queue; 72 72 + struct bio_list write_queue; 73 73 + sector_t last_write; /* The sector where the last write ended */ 74 74 + int successive_reads; 75 75 + }; 76 76 + 77 77 + /* 78 78 + * 32 buffers of 2048 bytes 79 79 + */ 80 80 + #if (PAGE_SIZE % CD_FRAMESIZE) != 0 81 81 + #error "PAGE_SIZE must be a multiple of CD_FRAMESIZE" 82 82 + #endif 83 83 + #define PACKET_MAX_SIZE 128 84 84 + #define FRAMES_PER_PAGE (PAGE_SIZE / CD_FRAMESIZE) 85 85 + #define PACKET_MAX_SECTORS (PACKET_MAX_SIZE * CD_FRAMESIZE >> 9) 86 86 + 87 87 + enum packet_data_state { 88 88 + PACKET_IDLE_STATE, /* Not used at the moment */ 89 89 + PACKET_WAITING_STATE, /* Waiting for more bios to arrive, so */ 90 90 + /* we don't have to do as much */ 91 91 + /* data gathering */ 92 92 + PACKET_READ_WAIT_STATE, /* Waiting for reads to fill in holes */ 93 93 + PACKET_WRITE_WAIT_STATE, /* Waiting for the write to complete */ 94 94 + PACKET_RECOVERY_STATE, /* Recover after read/write errors */ 95 95 + PACKET_FINISHED_STATE, /* After write has finished */ 96 96 + 97 97 + PACKET_NUM_STATES /* Number of possible states */ 98 98 + }; 99 99 + 100 100 + /* 101 101 + * Information needed for writing a single packet 102 102 + */ 103 103 + struct pktcdvd_device; 104 104 + 105 105 + struct packet_data 106 106 + { 107 107 + struct list_head list; 108 108 + 109 109 + spinlock_t lock; /* Lock protecting state transitions and */ 110 110 + /* orig_bios list */ 111 111 + 112 112 + struct bio_list orig_bios; /* Original bios passed to pkt_make_request */ 113 113 + /* that will be handled by this packet */ 114 114 + int write_size; /* Total size of all bios in the orig_bios */ 115 115 + /* list, measured in number of frames */ 116 116 + 117 117 + struct bio *w_bio; /* The bio we will send to the real CD */ 118 118 + /* device once we have all data for the */ 119 119 + /* packet we are going to write */ 120 120 + sector_t sector; /* First sector in this packet */ 121 121 + int frames; /* Number of frames in this packet */ 122 122 + 123 123 + enum packet_data_state state; /* Current state */ 124 124 + atomic_t run_sm; /* Incremented whenever the state */ 125 125 + /* machine needs to be run */ 126 126 + long sleep_time; /* Set this to non-zero to make the state */ 127 127 + /* machine run after this many jiffies. */ 128 128 + 129 129 + atomic_t io_wait; /* Number of pending IO operations */ 130 130 + atomic_t io_errors; /* Number of read/write errors during IO */ 131 131 + 132 132 + struct bio *r_bios[PACKET_MAX_SIZE]; /* bios to use during data gathering */ 133 133 + struct page *pages[PACKET_MAX_SIZE / FRAMES_PER_PAGE]; 134 134 + 135 135 + int cache_valid; /* If non-zero, the data for the zone defined */ 136 136 + /* by the sector variable is completely cached */ 137 137 + /* in the pages[] vector. */ 138 138 + 139 139 + int id; /* ID number for debugging */ 140 140 + struct pktcdvd_device *pd; 141 141 + }; 142 142 + 143 143 + struct pkt_rb_node { 144 144 + struct rb_node rb_node; 145 145 + struct bio *bio; 146 146 + }; 147 147 + 148 148 + struct packet_stacked_data 149 149 + { 150 150 + struct bio *bio; /* Original read request bio */ 151 151 + struct pktcdvd_device *pd; 152 152 + }; 153 153 + #define PSD_POOL_SIZE 64 154 154 + 155 155 + struct pktcdvd_device 156 156 + { 157 157 + struct block_device *bdev; /* dev attached */ 158 158 + dev_t pkt_dev; /* our dev */ 159 159 + char name[20]; 160 160 + struct packet_settings settings; 161 161 + struct packet_stats stats; 162 162 + int refcnt; /* Open count */ 163 163 + int write_speed; /* current write speed, kB/s */ 164 164 + int read_speed; /* current read speed, kB/s */ 165 165 + unsigned long offset; /* start offset */ 166 166 + __u8 mode_offset; /* 0 / 8 */ 167 167 + __u8 type; 168 168 + unsigned long flags; 169 169 + __u16 mmc3_profile; 170 170 + __u32 nwa; /* next writable address */ 171 171 + __u32 lra; /* last recorded address */ 172 172 + struct packet_cdrw cdrw; 173 173 + wait_queue_head_t wqueue; 174 174 + 175 175 + spinlock_t lock; /* Serialize access to bio_queue */ 176 176 + struct rb_root bio_queue; /* Work queue of bios we need to handle */ 177 177 + int bio_queue_size; /* Number of nodes in bio_queue */ 178 178 + bool congested; /* Someone is waiting for bio_queue_size 179 179 + * to drop. */ 180 180 + sector_t current_sector; /* Keep track of where the elevator is */ 181 181 + atomic_t scan_queue; /* Set to non-zero when pkt_handle_queue */ 182 182 + /* needs to be run. */ 183 183 + mempool_t rb_pool; /* mempool for pkt_rb_node allocations */ 184 184 + 185 185 + struct packet_iosched iosched; 186 186 + struct gendisk *disk; 187 187 + 188 188 + int write_congestion_off; 189 189 + int write_congestion_on; 190 190 + 191 191 + struct device *dev; /* sysfs pktcdvd[0-7] dev */ 192 192 + 193 193 + struct dentry *dfs_d_root; /* debugfs: devname directory */ 194 194 + struct dentry *dfs_f_info; /* debugfs: info file */ 195 195 + }; 196 196 + 197 197 + #endif /* __PKTCDVD_H */

+112

include/uapi/linux/pktcdvd.h

reviewed

··· 1 1 + /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ 2 2 + /* 3 3 + * Copyright (C) 2000 Jens Axboe <axboe@suse.de> 4 4 + * Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com> 5 5 + * 6 6 + * May be copied or modified under the terms of the GNU General Public 7 7 + * License. See linux/COPYING for more information. 8 8 + * 9 9 + * Packet writing layer for ATAPI and SCSI CD-R, CD-RW, DVD-R, and 10 10 + * DVD-RW devices. 11 11 + * 12 12 + */ 13 13 + #ifndef _UAPI__PKTCDVD_H 14 14 + #define _UAPI__PKTCDVD_H 15 15 + 16 16 + #include <linux/types.h> 17 17 + 18 18 + /* 19 19 + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. 20 20 + */ 21 21 + #define PACKET_DEBUG 1 22 22 + 23 23 + #define MAX_WRITERS 8 24 24 + 25 25 + #define PKT_RB_POOL_SIZE 512 26 26 + 27 27 + /* 28 28 + * How long we should hold a non-full packet before starting data gathering. 29 29 + */ 30 30 + #define PACKET_WAIT_TIME (HZ * 5 / 1000) 31 31 + 32 32 + /* 33 33 + * use drive write caching -- we need deferred error handling to be 34 34 + * able to successfully recover with this option (drive will return good 35 35 + * status as soon as the cdb is validated). 36 36 + */ 37 37 + #if defined(CONFIG_CDROM_PKTCDVD_WCACHE) 38 38 + #define USE_WCACHING 1 39 39 + #else 40 40 + #define USE_WCACHING 0 41 41 + #endif 42 42 + 43 43 + /* 44 44 + * No user-servicable parts beyond this point -> 45 45 + */ 46 46 + 47 47 + /* 48 48 + * device types 49 49 + */ 50 50 + #define PACKET_CDR 1 51 51 + #define PACKET_CDRW 2 52 52 + #define PACKET_DVDR 3 53 53 + #define PACKET_DVDRW 4 54 54 + 55 55 + /* 56 56 + * flags 57 57 + */ 58 58 + #define PACKET_WRITABLE 1 /* pd is writable */ 59 59 + #define PACKET_NWA_VALID 2 /* next writable address valid */ 60 60 + #define PACKET_LRA_VALID 3 /* last recorded address valid */ 61 61 + #define PACKET_MERGE_SEGS 4 /* perform segment merging to keep */ 62 62 + /* underlying cdrom device happy */ 63 63 + 64 64 + /* 65 65 + * Disc status -- from READ_DISC_INFO 66 66 + */ 67 67 + #define PACKET_DISC_EMPTY 0 68 68 + #define PACKET_DISC_INCOMPLETE 1 69 69 + #define PACKET_DISC_COMPLETE 2 70 70 + #define PACKET_DISC_OTHER 3 71 71 + 72 72 + /* 73 73 + * write type, and corresponding data block type 74 74 + */ 75 75 + #define PACKET_MODE1 1 76 76 + #define PACKET_MODE2 2 77 77 + #define PACKET_BLOCK_MODE1 8 78 78 + #define PACKET_BLOCK_MODE2 10 79 79 + 80 80 + /* 81 81 + * Last session/border status 82 82 + */ 83 83 + #define PACKET_SESSION_EMPTY 0 84 84 + #define PACKET_SESSION_INCOMPLETE 1 85 85 + #define PACKET_SESSION_RESERVED 2 86 86 + #define PACKET_SESSION_COMPLETE 3 87 87 + 88 88 + #define PACKET_MCN "4a656e734178626f65323030300000" 89 89 + 90 90 + #undef PACKET_USE_LS 91 91 + 92 92 + #define PKT_CTRL_CMD_SETUP 0 93 93 + #define PKT_CTRL_CMD_TEARDOWN 1 94 94 + #define PKT_CTRL_CMD_STATUS 2 95 95 + 96 96 + struct pkt_ctrl_command { 97 97 + __u32 command; /* in: Setup, teardown, status */ 98 98 + __u32 dev_index; /* in/out: Device index */ 99 99 + __u32 dev; /* in/out: Device nr for cdrw device */ 100 100 + __u32 pkt_dev; /* in/out: Device nr for packet device */ 101 101 + __u32 num_devices; /* out: Largest device index + 1 */ 102 102 + __u32 padding; /* Not used */ 103 103 + }; 104 104 + 105 105 + /* 106 106 + * packet ioctls 107 107 + */ 108 108 + #define PACKET_IOCTL_MAGIC ('X') 109 109 + #define PACKET_CTRL_CMD _IOWR(PACKET_IOCTL_MAGIC, 1, struct pkt_ctrl_command) 110 110 + 111 111 + 112 112 + #endif /* _UAPI__PKTCDVD_H */