aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/block/cciss.c88
-rw-r--r--drivers/block/cciss.h4
-rw-r--r--drivers/block/cciss_cmd.h3
-rw-r--r--drivers/block/loop.c39
-rw-r--r--drivers/block/nbd.c10
-rw-r--r--drivers/block/virtio_blk.c2
-rw-r--r--drivers/block/xen-blkfront.c8
-rw-r--r--drivers/cdrom/cdrom.c703
-rw-r--r--drivers/md/dm-crypt.c2
-rw-r--r--drivers/md/dm-io.c2
-rw-r--r--drivers/md/dm.c2
11 files changed, 491 insertions, 372 deletions
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 9f7c543cc04b..01e69383d9c0 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -164,7 +164,7 @@ static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
164 164
165static int cciss_revalidate(struct gendisk *disk); 165static int cciss_revalidate(struct gendisk *disk);
166static int rebuild_lun_table(ctlr_info_t *h, int first_time); 166static int rebuild_lun_table(ctlr_info_t *h, int first_time);
167static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, 167static int deregister_disk(ctlr_info_t *h, int drv_index,
168 int clear_all); 168 int clear_all);
169 169
170static void cciss_read_capacity(int ctlr, int logvol, int withirq, 170static void cciss_read_capacity(int ctlr, int logvol, int withirq,
@@ -215,31 +215,17 @@ static struct block_device_operations cciss_fops = {
215/* 215/*
216 * Enqueuing and dequeuing functions for cmdlists. 216 * Enqueuing and dequeuing functions for cmdlists.
217 */ 217 */
218static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c) 218static inline void addQ(struct hlist_head *list, CommandList_struct *c)
219{ 219{
220 if (*Qptr == NULL) { 220 hlist_add_head(&c->list, list);
221 *Qptr = c;
222 c->next = c->prev = c;
223 } else {
224 c->prev = (*Qptr)->prev;
225 c->next = (*Qptr);
226 (*Qptr)->prev->next = c;
227 (*Qptr)->prev = c;
228 }
229} 221}
230 222
231static inline CommandList_struct *removeQ(CommandList_struct **Qptr, 223static inline void removeQ(CommandList_struct *c)
232 CommandList_struct *c)
233{ 224{
234 if (c && c->next != c) { 225 if (WARN_ON(hlist_unhashed(&c->list)))
235 if (*Qptr == c) 226 return;
236 *Qptr = c->next; 227
237 c->prev->next = c->next; 228 hlist_del_init(&c->list);
238 c->next->prev = c->prev;
239 } else {
240 *Qptr = NULL;
241 }
242 return c;
243} 229}
244 230
245#include "cciss_scsi.c" /* For SCSI tape support */ 231#include "cciss_scsi.c" /* For SCSI tape support */
@@ -506,6 +492,7 @@ static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
506 c->cmdindex = i; 492 c->cmdindex = i;
507 } 493 }
508 494
495 INIT_HLIST_NODE(&c->list);
509 c->busaddr = (__u32) cmd_dma_handle; 496 c->busaddr = (__u32) cmd_dma_handle;
510 temp64.val = (__u64) err_dma_handle; 497 temp64.val = (__u64) err_dma_handle;
511 c->ErrDesc.Addr.lower = temp64.val32.lower; 498 c->ErrDesc.Addr.lower = temp64.val32.lower;
@@ -1492,8 +1479,7 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
1492 * which keeps the interrupt handler from starting 1479 * which keeps the interrupt handler from starting
1493 * the queue. 1480 * the queue.
1494 */ 1481 */
1495 ret = deregister_disk(h->gendisk[drv_index], 1482 ret = deregister_disk(h, drv_index, 0);
1496 &h->drv[drv_index], 0);
1497 h->drv[drv_index].busy_configuring = 0; 1483 h->drv[drv_index].busy_configuring = 0;
1498 } 1484 }
1499 1485
@@ -1711,8 +1697,7 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time)
1711 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 1697 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1712 h->drv[i].busy_configuring = 1; 1698 h->drv[i].busy_configuring = 1;
1713 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 1699 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1714 return_code = deregister_disk(h->gendisk[i], 1700 return_code = deregister_disk(h, i, 1);
1715 &h->drv[i], 1);
1716 h->drv[i].busy_configuring = 0; 1701 h->drv[i].busy_configuring = 0;
1717 } 1702 }
1718 } 1703 }
@@ -1782,15 +1767,19 @@ mem_msg:
1782 * the highest_lun should be left unchanged and the LunID 1767 * the highest_lun should be left unchanged and the LunID
1783 * should not be cleared. 1768 * should not be cleared.
1784*/ 1769*/
1785static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, 1770static int deregister_disk(ctlr_info_t *h, int drv_index,
1786 int clear_all) 1771 int clear_all)
1787{ 1772{
1788 int i; 1773 int i;
1789 ctlr_info_t *h = get_host(disk); 1774 struct gendisk *disk;
1775 drive_info_struct *drv;
1790 1776
1791 if (!capable(CAP_SYS_RAWIO)) 1777 if (!capable(CAP_SYS_RAWIO))
1792 return -EPERM; 1778 return -EPERM;
1793 1779
1780 drv = &h->drv[drv_index];
1781 disk = h->gendisk[drv_index];
1782
1794 /* make sure logical volume is NOT is use */ 1783 /* make sure logical volume is NOT is use */
1795 if (clear_all || (h->gendisk[0] == disk)) { 1784 if (clear_all || (h->gendisk[0] == disk)) {
1796 if (drv->usage_count > 1) 1785 if (drv->usage_count > 1)
@@ -2548,7 +2537,8 @@ static void start_io(ctlr_info_t *h)
2548{ 2537{
2549 CommandList_struct *c; 2538 CommandList_struct *c;
2550 2539
2551 while ((c = h->reqQ) != NULL) { 2540 while (!hlist_empty(&h->reqQ)) {
2541 c = hlist_entry(h->reqQ.first, CommandList_struct, list);
2552 /* can't do anything if fifo is full */ 2542 /* can't do anything if fifo is full */
2553 if ((h->access.fifo_full(h))) { 2543 if ((h->access.fifo_full(h))) {
2554 printk(KERN_WARNING "cciss: fifo full\n"); 2544 printk(KERN_WARNING "cciss: fifo full\n");
@@ -2556,14 +2546,14 @@ static void start_io(ctlr_info_t *h)
2556 } 2546 }
2557 2547
2558 /* Get the first entry from the Request Q */ 2548 /* Get the first entry from the Request Q */
2559 removeQ(&(h->reqQ), c); 2549 removeQ(c);
2560 h->Qdepth--; 2550 h->Qdepth--;
2561 2551
2562 /* Tell the controller execute command */ 2552 /* Tell the controller execute command */
2563 h->access.submit_command(h, c); 2553 h->access.submit_command(h, c);
2564 2554
2565 /* Put job onto the completed Q */ 2555 /* Put job onto the completed Q */
2566 addQ(&(h->cmpQ), c); 2556 addQ(&h->cmpQ, c);
2567 } 2557 }
2568} 2558}
2569 2559
@@ -2576,7 +2566,7 @@ static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2576 memset(c->err_info, 0, sizeof(ErrorInfo_struct)); 2566 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2577 2567
2578 /* add it to software queue and then send it to the controller */ 2568 /* add it to software queue and then send it to the controller */
2579 addQ(&(h->reqQ), c); 2569 addQ(&h->reqQ, c);
2580 h->Qdepth++; 2570 h->Qdepth++;
2581 if (h->Qdepth > h->maxQsinceinit) 2571 if (h->Qdepth > h->maxQsinceinit)
2582 h->maxQsinceinit = h->Qdepth; 2572 h->maxQsinceinit = h->Qdepth;
@@ -2897,7 +2887,7 @@ static void do_cciss_request(struct request_queue *q)
2897 2887
2898 spin_lock_irq(q->queue_lock); 2888 spin_lock_irq(q->queue_lock);
2899 2889
2900 addQ(&(h->reqQ), c); 2890 addQ(&h->reqQ, c);
2901 h->Qdepth++; 2891 h->Qdepth++;
2902 if (h->Qdepth > h->maxQsinceinit) 2892 if (h->Qdepth > h->maxQsinceinit)
2903 h->maxQsinceinit = h->Qdepth; 2893 h->maxQsinceinit = h->Qdepth;
@@ -2985,16 +2975,12 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2985 a = c->busaddr; 2975 a = c->busaddr;
2986 2976
2987 } else { 2977 } else {
2978 struct hlist_node *tmp;
2979
2988 a &= ~3; 2980 a &= ~3;
2989 if ((c = h->cmpQ) == NULL) { 2981 c = NULL;
2990 printk(KERN_WARNING 2982 hlist_for_each_entry(c, tmp, &h->cmpQ, list) {
2991 "cciss: Completion of %08x ignored\n", 2983 if (c->busaddr == a)
2992 a1);
2993 continue;
2994 }
2995 while (c->busaddr != a) {
2996 c = c->next;
2997 if (c == h->cmpQ)
2998 break; 2984 break;
2999 } 2985 }
3000 } 2986 }
@@ -3002,8 +2988,8 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id)
3002 * If we've found the command, take it off the 2988 * If we've found the command, take it off the
3003 * completion Q and free it 2989 * completion Q and free it
3004 */ 2990 */
3005 if (c->busaddr == a) { 2991 if (c && c->busaddr == a) {
3006 removeQ(&h->cmpQ, c); 2992 removeQ(c);
3007 if (c->cmd_type == CMD_RWREQ) { 2993 if (c->cmd_type == CMD_RWREQ) {
3008 complete_command(h, c, 0); 2994 complete_command(h, c, 0);
3009 } else if (c->cmd_type == CMD_IOCTL_PEND) { 2995 } else if (c->cmd_type == CMD_IOCTL_PEND) {
@@ -3423,6 +3409,8 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
3423 return -1; 3409 return -1;
3424 3410
3425 hba[i]->busy_initializing = 1; 3411 hba[i]->busy_initializing = 1;
3412 INIT_HLIST_HEAD(&hba[i]->cmpQ);
3413 INIT_HLIST_HEAD(&hba[i]->reqQ);
3426 3414
3427 if (cciss_pci_init(hba[i], pdev) != 0) 3415 if (cciss_pci_init(hba[i], pdev) != 0)
3428 goto clean1; 3416 goto clean1;
@@ -3730,15 +3718,17 @@ static void fail_all_cmds(unsigned long ctlr)
3730 pci_disable_device(h->pdev); /* Make sure it is really dead. */ 3718 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3731 3719
3732 /* move everything off the request queue onto the completed queue */ 3720 /* move everything off the request queue onto the completed queue */
3733 while ((c = h->reqQ) != NULL) { 3721 while (!hlist_empty(&h->reqQ)) {
3734 removeQ(&(h->reqQ), c); 3722 c = hlist_entry(h->reqQ.first, CommandList_struct, list);
3723 removeQ(c);
3735 h->Qdepth--; 3724 h->Qdepth--;
3736 addQ(&(h->cmpQ), c); 3725 addQ(&h->cmpQ, c);
3737 } 3726 }
3738 3727
3739 /* Now, fail everything on the completed queue with a HW error */ 3728 /* Now, fail everything on the completed queue with a HW error */
3740 while ((c = h->cmpQ) != NULL) { 3729 while (!hlist_empty(&h->cmpQ)) {
3741 removeQ(&h->cmpQ, c); 3730 c = hlist_entry(h->cmpQ.first, CommandList_struct, list);
3731 removeQ(c);
3742 c->err_info->CommandStatus = CMD_HARDWARE_ERR; 3732 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3743 if (c->cmd_type == CMD_RWREQ) { 3733 if (c->cmd_type == CMD_RWREQ) {
3744 complete_command(h, c, 0); 3734 complete_command(h, c, 0);
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index 24a7efa993ab..15e2b84734e3 100644
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -89,8 +89,8 @@ struct ctlr_info
89 struct access_method access; 89 struct access_method access;
90 90
91 /* queue and queue Info */ 91 /* queue and queue Info */
92 CommandList_struct *reqQ; 92 struct hlist_head reqQ;
93 CommandList_struct *cmpQ; 93 struct hlist_head cmpQ;
94 unsigned int Qdepth; 94 unsigned int Qdepth;
95 unsigned int maxQsinceinit; 95 unsigned int maxQsinceinit;
96 unsigned int maxSG; 96 unsigned int maxSG;
diff --git a/drivers/block/cciss_cmd.h b/drivers/block/cciss_cmd.h
index 43bf5593b59b..24e22dea1a99 100644
--- a/drivers/block/cciss_cmd.h
+++ b/drivers/block/cciss_cmd.h
@@ -265,8 +265,7 @@ typedef struct _CommandList_struct {
265 int ctlr; 265 int ctlr;
266 int cmd_type; 266 int cmd_type;
267 long cmdindex; 267 long cmdindex;
268 struct _CommandList_struct *prev; 268 struct hlist_node list;
269 struct _CommandList_struct *next;
270 struct request * rq; 269 struct request * rq;
271 struct completion *waiting; 270 struct completion *waiting;
272 int retry_count; 271 int retry_count;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index fb06ed659212..edbaac6c0573 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -624,20 +624,38 @@ static int loop_switch(struct loop_device *lo, struct file *file)
624} 624}
625 625
626/* 626/*
627 * Helper to flush the IOs in loop, but keeping loop thread running
628 */
629static int loop_flush(struct loop_device *lo)
630{
631 /* loop not yet configured, no running thread, nothing to flush */
632 if (!lo->lo_thread)
633 return 0;
634
635 return loop_switch(lo, NULL);
636}
637
638/*
627 * Do the actual switch; called from the BIO completion routine 639 * Do the actual switch; called from the BIO completion routine
628 */ 640 */
629static void do_loop_switch(struct loop_device *lo, struct switch_request *p) 641static void do_loop_switch(struct loop_device *lo, struct switch_request *p)
630{ 642{
631 struct file *file = p->file; 643 struct file *file = p->file;
632 struct file *old_file = lo->lo_backing_file; 644 struct file *old_file = lo->lo_backing_file;
633 struct address_space *mapping = file->f_mapping; 645 struct address_space *mapping;
646
647 /* if no new file, only flush of queued bios requested */
648 if (!file)
649 goto out;
634 650
651 mapping = file->f_mapping;
635 mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask); 652 mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask);
636 lo->lo_backing_file = file; 653 lo->lo_backing_file = file;
637 lo->lo_blocksize = S_ISBLK(mapping->host->i_mode) ? 654 lo->lo_blocksize = S_ISBLK(mapping->host->i_mode) ?
638 mapping->host->i_bdev->bd_block_size : PAGE_SIZE; 655 mapping->host->i_bdev->bd_block_size : PAGE_SIZE;
639 lo->old_gfp_mask = mapping_gfp_mask(mapping); 656 lo->old_gfp_mask = mapping_gfp_mask(mapping);
640 mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 657 mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
658out:
641 complete(&p->wait); 659 complete(&p->wait);
642} 660}
643 661
@@ -901,6 +919,7 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
901 919
902 kthread_stop(lo->lo_thread); 920 kthread_stop(lo->lo_thread);
903 921
922 lo->lo_queue->unplug_fn = NULL;
904 lo->lo_backing_file = NULL; 923 lo->lo_backing_file = NULL;
905 924
906 loop_release_xfer(lo); 925 loop_release_xfer(lo);
@@ -1345,11 +1364,25 @@ static int lo_release(struct gendisk *disk, fmode_t mode)
1345 struct loop_device *lo = disk->private_data; 1364 struct loop_device *lo = disk->private_data;
1346 1365
1347 mutex_lock(&lo->lo_ctl_mutex); 1366 mutex_lock(&lo->lo_ctl_mutex);
1348 --lo->lo_refcnt;
1349 1367
1350 if ((lo->lo_flags & LO_FLAGS_AUTOCLEAR) && !lo->lo_refcnt) 1368 if (--lo->lo_refcnt)
1369 goto out;
1370
1371 if (lo->lo_flags & LO_FLAGS_AUTOCLEAR) {
1372 /*
1373 * In autoclear mode, stop the loop thread
1374 * and remove configuration after last close.
1375 */
1351 loop_clr_fd(lo, NULL); 1376 loop_clr_fd(lo, NULL);
1377 } else {
1378 /*
1379 * Otherwise keep thread (if running) and config,
1380 * but flush possible ongoing bios in thread.
1381 */
1382 loop_flush(lo);
1383 }
1352 1384
1385out:
1353 mutex_unlock(&lo->lo_ctl_mutex); 1386 mutex_unlock(&lo->lo_ctl_mutex);
1354 1387
1355 return 0; 1388 return 0;
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index d3a91cacee8c..7bcc1d8bc967 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -722,7 +722,6 @@ static int __init nbd_init(void)
722 722
723 for (i = 0; i < nbds_max; i++) { 723 for (i = 0; i < nbds_max; i++) {
724 struct gendisk *disk = alloc_disk(1 << part_shift); 724 struct gendisk *disk = alloc_disk(1 << part_shift);
725 elevator_t *old_e;
726 if (!disk) 725 if (!disk)
727 goto out; 726 goto out;
728 nbd_dev[i].disk = disk; 727 nbd_dev[i].disk = disk;
@@ -736,11 +735,10 @@ static int __init nbd_init(void)
736 put_disk(disk); 735 put_disk(disk);
737 goto out; 736 goto out;
738 } 737 }
739 old_e = disk->queue->elevator; 738 /*
740 if (elevator_init(disk->queue, "deadline") == 0 || 739 * Tell the block layer that we are not a rotational device
741 elevator_init(disk->queue, "noop") == 0) { 740 */
742 elevator_exit(old_e); 741 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, disk->queue);
743 }
744 } 742 }
745 743
746 if (register_blkdev(NBD_MAJOR, "nbd")) { 744 if (register_blkdev(NBD_MAJOR, "nbd")) {
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 85d79a02d487..f151592ecf73 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -237,6 +237,8 @@ static int virtblk_probe(struct virtio_device *vdev)
237 goto out_put_disk; 237 goto out_put_disk;
238 } 238 }
239 239
240 queue_flag_set_unlocked(QUEUE_FLAG_VIRT, vblk->disk->queue);
241
240 if (index < 26) { 242 if (index < 26) {
241 sprintf(vblk->disk->disk_name, "vd%c", 'a' + index % 26); 243 sprintf(vblk->disk->disk_name, "vd%c", 'a' + index % 26);
242 } else if (index < (26 + 1) * 26) { 244 } else if (index < (26 + 1) * 26) {
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 2d19f0cc47f2..918ef725de41 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -338,18 +338,12 @@ wait:
338static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size) 338static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
339{ 339{
340 struct request_queue *rq; 340 struct request_queue *rq;
341 elevator_t *old_e;
342 341
343 rq = blk_init_queue(do_blkif_request, &blkif_io_lock); 342 rq = blk_init_queue(do_blkif_request, &blkif_io_lock);
344 if (rq == NULL) 343 if (rq == NULL)
345 return -1; 344 return -1;
346 345
347 old_e = rq->elevator; 346 queue_flag_set_unlocked(QUEUE_FLAG_VIRT, rq);
348 if (IS_ERR_VALUE(elevator_init(rq, "noop")))
349 printk(KERN_WARNING
350 "blkfront: Switch elevator failed, use default\n");
351 else
352 elevator_exit(old_e);
353 347
354 /* Hard sector size and max sectors impersonate the equiv. hardware. */ 348 /* Hard sector size and max sectors impersonate the equiv. hardware. */
355 blk_queue_hardsect_size(rq, sector_size); 349 blk_queue_hardsect_size(rq, sector_size);
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 7d2e91cccb13..cceace61ef28 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -1712,29 +1712,30 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1712 return 0; 1712 return 0;
1713} 1713}
1714 1714
1715static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s) 1715static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1716 struct packet_command *cgc)
1716{ 1717{
1717 unsigned char buf[21], *base; 1718 unsigned char buf[21], *base;
1718 struct dvd_layer *layer; 1719 struct dvd_layer *layer;
1719 struct packet_command cgc;
1720 struct cdrom_device_ops *cdo = cdi->ops; 1720 struct cdrom_device_ops *cdo = cdi->ops;
1721 int ret, layer_num = s->physical.layer_num; 1721 int ret, layer_num = s->physical.layer_num;
1722 1722
1723 if (layer_num >= DVD_LAYERS) 1723 if (layer_num >= DVD_LAYERS)
1724 return -EINVAL; 1724 return -EINVAL;
1725 1725
1726 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ); 1726 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1727 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE; 1727 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1728 cgc.cmd[6] = layer_num; 1728 cgc->cmd[6] = layer_num;
1729 cgc.cmd[7] = s->type; 1729 cgc->cmd[7] = s->type;
1730 cgc.cmd[9] = cgc.buflen & 0xff; 1730 cgc->cmd[9] = cgc->buflen & 0xff;
1731 1731
1732 /* 1732 /*
1733 * refrain from reporting errors on non-existing layers (mainly) 1733 * refrain from reporting errors on non-existing layers (mainly)
1734 */ 1734 */
1735 cgc.quiet = 1; 1735 cgc->quiet = 1;
1736 1736
1737 if ((ret = cdo->generic_packet(cdi, &cgc))) 1737 ret = cdo->generic_packet(cdi, cgc);
1738 if (ret)
1738 return ret; 1739 return ret;
1739 1740
1740 base = &buf[4]; 1741 base = &buf[4];
@@ -1762,21 +1763,22 @@ static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1762 return 0; 1763 return 0;
1763} 1764}
1764 1765
1765static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s) 1766static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1767 struct packet_command *cgc)
1766{ 1768{
1767 int ret; 1769 int ret;
1768 u_char buf[8]; 1770 u_char buf[8];
1769 struct packet_command cgc;
1770 struct cdrom_device_ops *cdo = cdi->ops; 1771 struct cdrom_device_ops *cdo = cdi->ops;
1771 1772
1772 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ); 1773 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1773 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE; 1774 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1774 cgc.cmd[6] = s->copyright.layer_num; 1775 cgc->cmd[6] = s->copyright.layer_num;
1775 cgc.cmd[7] = s->type; 1776 cgc->cmd[7] = s->type;
1776 cgc.cmd[8] = cgc.buflen >> 8; 1777 cgc->cmd[8] = cgc->buflen >> 8;
1777 cgc.cmd[9] = cgc.buflen & 0xff; 1778 cgc->cmd[9] = cgc->buflen & 0xff;
1778 1779
1779 if ((ret = cdo->generic_packet(cdi, &cgc))) 1780 ret = cdo->generic_packet(cdi, cgc);
1781 if (ret)
1780 return ret; 1782 return ret;
1781 1783
1782 s->copyright.cpst = buf[4]; 1784 s->copyright.cpst = buf[4];
@@ -1785,79 +1787,89 @@ static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1785 return 0; 1787 return 0;
1786} 1788}
1787 1789
1788static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s) 1790static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1791 struct packet_command *cgc)
1789{ 1792{
1790 int ret, size; 1793 int ret, size;
1791 u_char *buf; 1794 u_char *buf;
1792 struct packet_command cgc;
1793 struct cdrom_device_ops *cdo = cdi->ops; 1795 struct cdrom_device_ops *cdo = cdi->ops;
1794 1796
1795 size = sizeof(s->disckey.value) + 4; 1797 size = sizeof(s->disckey.value) + 4;
1796 1798
1797 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL) 1799 buf = kmalloc(size, GFP_KERNEL);
1800 if (!buf)
1798 return -ENOMEM; 1801 return -ENOMEM;
1799 1802
1800 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ); 1803 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1801 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE; 1804 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1802 cgc.cmd[7] = s->type; 1805 cgc->cmd[7] = s->type;
1803 cgc.cmd[8] = size >> 8; 1806 cgc->cmd[8] = size >> 8;
1804 cgc.cmd[9] = size & 0xff; 1807 cgc->cmd[9] = size & 0xff;
1805 cgc.cmd[10] = s->disckey.agid << 6; 1808 cgc->cmd[10] = s->disckey.agid << 6;
1806 1809
1807 if (!(ret = cdo->generic_packet(cdi, &cgc))) 1810 ret = cdo->generic_packet(cdi, cgc);
1811 if (!ret)
1808 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value)); 1812 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1809 1813
1810 kfree(buf); 1814 kfree(buf);
1811 return ret; 1815 return ret;
1812} 1816}
1813 1817
1814static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s) 1818static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1819 struct packet_command *cgc)
1815{ 1820{
1816 int ret; 1821 int ret, size = 4 + 188;
1817 u_char buf[4 + 188]; 1822 u_char *buf;
1818 struct packet_command cgc;
1819 struct cdrom_device_ops *cdo = cdi->ops; 1823 struct cdrom_device_ops *cdo = cdi->ops;
1820 1824
1821 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ); 1825 buf = kmalloc(size, GFP_KERNEL);
1822 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE; 1826 if (!buf)
1823 cgc.cmd[7] = s->type; 1827 return -ENOMEM;
1824 cgc.cmd[9] = cgc.buflen & 0xff;
1825 1828
1826 if ((ret = cdo->generic_packet(cdi, &cgc))) 1829 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1827 return ret; 1830 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1831 cgc->cmd[7] = s->type;
1832 cgc->cmd[9] = cgc->buflen & 0xff;
1833
1834 ret = cdo->generic_packet(cdi, cgc);
1835 if (ret)
1836 goto out;
1828 1837
1829 s->bca.len = buf[0] << 8 | buf[1]; 1838 s->bca.len = buf[0] << 8 | buf[1];
1830 if (s->bca.len < 12 || s->bca.len > 188) { 1839 if (s->bca.len < 12 || s->bca.len > 188) {
1831 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len); 1840 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1832 return -EIO; 1841 ret = -EIO;
1842 goto out;
1833 } 1843 }
1834 memcpy(s->bca.value, &buf[4], s->bca.len); 1844 memcpy(s->bca.value, &buf[4], s->bca.len);
1835 1845 ret = 0;
1836 return 0; 1846out:
1847 kfree(buf);
1848 return ret;
1837} 1849}
1838 1850
1839static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s) 1851static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1852 struct packet_command *cgc)
1840{ 1853{
1841 int ret = 0, size; 1854 int ret = 0, size;
1842 u_char *buf; 1855 u_char *buf;
1843 struct packet_command cgc;
1844 struct cdrom_device_ops *cdo = cdi->ops; 1856 struct cdrom_device_ops *cdo = cdi->ops;
1845 1857
1846 size = sizeof(s->manufact.value) + 4; 1858 size = sizeof(s->manufact.value) + 4;
1847 1859
1848 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL) 1860 buf = kmalloc(size, GFP_KERNEL);
1861 if (!buf)
1849 return -ENOMEM; 1862 return -ENOMEM;
1850 1863
1851 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ); 1864 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1852 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE; 1865 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1853 cgc.cmd[7] = s->type; 1866 cgc->cmd[7] = s->type;
1854 cgc.cmd[8] = size >> 8; 1867 cgc->cmd[8] = size >> 8;
1855 cgc.cmd[9] = size & 0xff; 1868 cgc->cmd[9] = size & 0xff;
1856 1869
1857 if ((ret = cdo->generic_packet(cdi, &cgc))) { 1870 ret = cdo->generic_packet(cdi, cgc);
1858 kfree(buf); 1871 if (ret)
1859 return ret; 1872 goto out;
1860 }
1861 1873
1862 s->manufact.len = buf[0] << 8 | buf[1]; 1874 s->manufact.len = buf[0] << 8 | buf[1];
1863 if (s->manufact.len < 0 || s->manufact.len > 2048) { 1875 if (s->manufact.len < 0 || s->manufact.len > 2048) {
@@ -1868,27 +1880,29 @@ static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1868 memcpy(s->manufact.value, &buf[4], s->manufact.len); 1880 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1869 } 1881 }
1870 1882
1883out:
1871 kfree(buf); 1884 kfree(buf);
1872 return ret; 1885 return ret;
1873} 1886}
1874 1887
1875static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s) 1888static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1889 struct packet_command *cgc)
1876{ 1890{
1877 switch (s->type) { 1891 switch (s->type) {
1878 case DVD_STRUCT_PHYSICAL: 1892 case DVD_STRUCT_PHYSICAL:
1879 return dvd_read_physical(cdi, s); 1893 return dvd_read_physical(cdi, s, cgc);
1880 1894
1881 case DVD_STRUCT_COPYRIGHT: 1895 case DVD_STRUCT_COPYRIGHT:
1882 return dvd_read_copyright(cdi, s); 1896 return dvd_read_copyright(cdi, s, cgc);
1883 1897
1884 case DVD_STRUCT_DISCKEY: 1898 case DVD_STRUCT_DISCKEY:
1885 return dvd_read_disckey(cdi, s); 1899 return dvd_read_disckey(cdi, s, cgc);
1886 1900
1887 case DVD_STRUCT_BCA: 1901 case DVD_STRUCT_BCA:
1888 return dvd_read_bca(cdi, s); 1902 return dvd_read_bca(cdi, s, cgc);
1889 1903
1890 case DVD_STRUCT_MANUFACT: 1904 case DVD_STRUCT_MANUFACT:
1891 return dvd_read_manufact(cdi, s); 1905 return dvd_read_manufact(cdi, s, cgc);
1892 1906
1893 default: 1907 default:
1894 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n", 1908 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
@@ -2787,271 +2801,360 @@ static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2787 return cdo->generic_packet(cdi, &cgc); 2801 return cdo->generic_packet(cdi, &cgc);
2788} 2802}
2789 2803
2790static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, 2804static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2791 unsigned long arg) 2805 void __user *arg,
2792{ 2806 struct packet_command *cgc,
2793 struct cdrom_device_ops *cdo = cdi->ops; 2807 int cmd)
2794 struct packet_command cgc; 2808{
2795 struct request_sense sense; 2809 struct request_sense sense;
2796 unsigned char buffer[32]; 2810 struct cdrom_msf msf;
2797 int ret = 0; 2811 int blocksize = 0, format = 0, lba;
2798 2812 int ret;
2799 memset(&cgc, 0, sizeof(cgc));
2800 2813
2801 /* build a unified command and queue it through
2802 cdo->generic_packet() */
2803 switch (cmd) { 2814 switch (cmd) {
2804 case CDROMREADRAW: 2815 case CDROMREADRAW:
2816 blocksize = CD_FRAMESIZE_RAW;
2817 break;
2805 case CDROMREADMODE1: 2818 case CDROMREADMODE1:
2806 case CDROMREADMODE2: { 2819 blocksize = CD_FRAMESIZE;
2807 struct cdrom_msf msf; 2820 format = 2;
2808 int blocksize = 0, format = 0, lba; 2821 break;
2809 2822 case CDROMREADMODE2:
2810 switch (cmd) { 2823 blocksize = CD_FRAMESIZE_RAW0;
2811 case CDROMREADRAW: 2824 break;
2812 blocksize = CD_FRAMESIZE_RAW; 2825 }
2813 break; 2826 IOCTL_IN(arg, struct cdrom_msf, msf);
2814 case CDROMREADMODE1: 2827 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2815 blocksize = CD_FRAMESIZE; 2828 /* FIXME: we need upper bound checking, too!! */
2816 format = 2; 2829 if (lba < 0)
2817 break; 2830 return -EINVAL;
2818 case CDROMREADMODE2: 2831
2819 blocksize = CD_FRAMESIZE_RAW0; 2832 cgc->buffer = kmalloc(blocksize, GFP_KERNEL);
2820 break; 2833 if (cgc->buffer == NULL)
2821 } 2834 return -ENOMEM;
2822 IOCTL_IN(arg, struct cdrom_msf, msf); 2835
2823 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0); 2836 memset(&sense, 0, sizeof(sense));
2824 /* FIXME: we need upper bound checking, too!! */ 2837 cgc->sense = &sense;
2825 if (lba < 0) 2838 cgc->data_direction = CGC_DATA_READ;
2826 return -EINVAL; 2839 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2827 cgc.buffer = kmalloc(blocksize, GFP_KERNEL); 2840 if (ret && sense.sense_key == 0x05 &&
2828 if (cgc.buffer == NULL) 2841 sense.asc == 0x20 &&
2829 return -ENOMEM; 2842 sense.ascq == 0x00) {
2830 memset(&sense, 0, sizeof(sense)); 2843 /*
2831 cgc.sense = &sense; 2844 * SCSI-II devices are not required to support
2832 cgc.data_direction = CGC_DATA_READ; 2845 * READ_CD, so let's try switching block size
2833 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize); 2846 */
2834 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) { 2847 /* FIXME: switch back again... */
2835 /* 2848 ret = cdrom_switch_blocksize(cdi, blocksize);
2836 * SCSI-II devices are not required to support 2849 if (ret)
2837 * READ_CD, so let's try switching block size 2850 goto out;
2838 */ 2851 cgc->sense = NULL;
2839 /* FIXME: switch back again... */ 2852 ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2840 if ((ret = cdrom_switch_blocksize(cdi, blocksize))) { 2853 ret |= cdrom_switch_blocksize(cdi, blocksize);
2841 kfree(cgc.buffer); 2854 }
2842 return ret; 2855 if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
2843 } 2856 ret = -EFAULT;
2844 cgc.sense = NULL; 2857out:
2845 ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1); 2858 kfree(cgc->buffer);
2846 ret |= cdrom_switch_blocksize(cdi, blocksize); 2859 return ret;
2847 } 2860}
2848 if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize)) 2861
2849 ret = -EFAULT; 2862static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2850 kfree(cgc.buffer); 2863 void __user *arg)
2864{
2865 struct cdrom_read_audio ra;
2866 int lba;
2867
2868 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2869
2870 if (ra.addr_format == CDROM_MSF)
2871 lba = msf_to_lba(ra.addr.msf.minute,
2872 ra.addr.msf.second,
2873 ra.addr.msf.frame);
2874 else if (ra.addr_format == CDROM_LBA)
2875 lba = ra.addr.lba;
2876 else
2877 return -EINVAL;
2878
2879 /* FIXME: we need upper bound checking, too!! */
2880 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2881 return -EINVAL;
2882
2883 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2884}
2885
2886static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
2887 void __user *arg)
2888{
2889 int ret;
2890 struct cdrom_subchnl q;
2891 u_char requested, back;
2892 IOCTL_IN(arg, struct cdrom_subchnl, q);
2893 requested = q.cdsc_format;
2894 if (!((requested == CDROM_MSF) ||
2895 (requested == CDROM_LBA)))
2896 return -EINVAL;
2897 q.cdsc_format = CDROM_MSF;
2898 ret = cdrom_read_subchannel(cdi, &q, 0);
2899 if (ret)
2851 return ret; 2900 return ret;
2852 } 2901 back = q.cdsc_format; /* local copy */
2853 case CDROMREADAUDIO: { 2902 sanitize_format(&q.cdsc_absaddr, &back, requested);
2854 struct cdrom_read_audio ra; 2903 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2855 int lba; 2904 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2856 2905 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2857 IOCTL_IN(arg, struct cdrom_read_audio, ra); 2906 return 0;
2858 2907}
2859 if (ra.addr_format == CDROM_MSF)
2860 lba = msf_to_lba(ra.addr.msf.minute,
2861 ra.addr.msf.second,
2862 ra.addr.msf.frame);
2863 else if (ra.addr_format == CDROM_LBA)
2864 lba = ra.addr.lba;
2865 else
2866 return -EINVAL;
2867 2908
2868 /* FIXME: we need upper bound checking, too!! */ 2909static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
2869 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES) 2910 void __user *arg,
2870 return -EINVAL; 2911 struct packet_command *cgc)
2912{
2913 struct cdrom_device_ops *cdo = cdi->ops;
2914 struct cdrom_msf msf;
2915 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2916 IOCTL_IN(arg, struct cdrom_msf, msf);
2917 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2918 cgc->cmd[3] = msf.cdmsf_min0;
2919 cgc->cmd[4] = msf.cdmsf_sec0;
2920 cgc->cmd[5] = msf.cdmsf_frame0;
2921 cgc->cmd[6] = msf.cdmsf_min1;
2922 cgc->cmd[7] = msf.cdmsf_sec1;
2923 cgc->cmd[8] = msf.cdmsf_frame1;
2924 cgc->data_direction = CGC_DATA_NONE;
2925 return cdo->generic_packet(cdi, cgc);
2926}
2871 2927
2872 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes); 2928static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
2873 } 2929 void __user *arg,
2874 case CDROMSUBCHNL: { 2930 struct packet_command *cgc)
2875 struct cdrom_subchnl q; 2931{
2876 u_char requested, back; 2932 struct cdrom_device_ops *cdo = cdi->ops;
2877 IOCTL_IN(arg, struct cdrom_subchnl, q); 2933 struct cdrom_blk blk;
2878 requested = q.cdsc_format; 2934 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2879 if (!((requested == CDROM_MSF) || 2935 IOCTL_IN(arg, struct cdrom_blk, blk);
2880 (requested == CDROM_LBA))) 2936 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
2881 return -EINVAL; 2937 cgc->cmd[2] = (blk.from >> 24) & 0xff;
2882 q.cdsc_format = CDROM_MSF; 2938 cgc->cmd[3] = (blk.from >> 16) & 0xff;
2883 if ((ret = cdrom_read_subchannel(cdi, &q, 0))) 2939 cgc->cmd[4] = (blk.from >> 8) & 0xff;
2884 return ret; 2940 cgc->cmd[5] = blk.from & 0xff;
2885 back = q.cdsc_format; /* local copy */ 2941 cgc->cmd[7] = (blk.len >> 8) & 0xff;
2886 sanitize_format(&q.cdsc_absaddr, &back, requested); 2942 cgc->cmd[8] = blk.len & 0xff;
2887 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested); 2943 cgc->data_direction = CGC_DATA_NONE;
2888 IOCTL_OUT(arg, struct cdrom_subchnl, q); 2944 return cdo->generic_packet(cdi, cgc);
2889 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 2945}
2890 return 0; 2946
2891 } 2947static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
2892 case CDROMPLAYMSF: { 2948 void __user *arg,
2893 struct cdrom_msf msf; 2949 struct packet_command *cgc,
2894 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n"); 2950 unsigned int cmd)
2895 IOCTL_IN(arg, struct cdrom_msf, msf); 2951{
2896 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF; 2952 struct cdrom_volctrl volctrl;
2897 cgc.cmd[3] = msf.cdmsf_min0; 2953 unsigned char buffer[32];
2898 cgc.cmd[4] = msf.cdmsf_sec0; 2954 char mask[sizeof(buffer)];
2899 cgc.cmd[5] = msf.cdmsf_frame0; 2955 unsigned short offset;
2900 cgc.cmd[6] = msf.cdmsf_min1; 2956 int ret;
2901 cgc.cmd[7] = msf.cdmsf_sec1;
2902 cgc.cmd[8] = msf.cdmsf_frame1;
2903 cgc.data_direction = CGC_DATA_NONE;
2904 return cdo->generic_packet(cdi, &cgc);
2905 }
2906 case CDROMPLAYBLK: {
2907 struct cdrom_blk blk;
2908 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2909 IOCTL_IN(arg, struct cdrom_blk, blk);
2910 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2911 cgc.cmd[2] = (blk.from >> 24) & 0xff;
2912 cgc.cmd[3] = (blk.from >> 16) & 0xff;
2913 cgc.cmd[4] = (blk.from >> 8) & 0xff;
2914 cgc.cmd[5] = blk.from & 0xff;
2915 cgc.cmd[7] = (blk.len >> 8) & 0xff;
2916 cgc.cmd[8] = blk.len & 0xff;
2917 cgc.data_direction = CGC_DATA_NONE;
2918 return cdo->generic_packet(cdi, &cgc);
2919 }
2920 case CDROMVOLCTRL:
2921 case CDROMVOLREAD: {
2922 struct cdrom_volctrl volctrl;
2923 char mask[sizeof(buffer)];
2924 unsigned short offset;
2925 2957
2926 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n"); 2958 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2927 2959
2928 IOCTL_IN(arg, struct cdrom_volctrl, volctrl); 2960 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2929 2961
2930 cgc.buffer = buffer; 2962 cgc->buffer = buffer;
2931 cgc.buflen = 24; 2963 cgc->buflen = 24;
2932 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0))) 2964 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
2933 return ret; 2965 if (ret)
2966 return ret;
2934 2967
2935 /* originally the code depended on buffer[1] to determine 2968 /* originally the code depended on buffer[1] to determine
2936 how much data is available for transfer. buffer[1] is 2969 how much data is available for transfer. buffer[1] is
2937 unfortunately ambigious and the only reliable way seem 2970 unfortunately ambigious and the only reliable way seem
2938 to be to simply skip over the block descriptor... */ 2971 to be to simply skip over the block descriptor... */
2939 offset = 8 + be16_to_cpu(*(__be16 *)(buffer+6)); 2972 offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
2940 2973
2941 if (offset + 16 > sizeof(buffer)) 2974 if (offset + 16 > sizeof(buffer))
2942 return -E2BIG; 2975 return -E2BIG;
2943 2976
2944 if (offset + 16 > cgc.buflen) { 2977 if (offset + 16 > cgc->buflen) {
2945 cgc.buflen = offset+16; 2978 cgc->buflen = offset + 16;
2946 ret = cdrom_mode_sense(cdi, &cgc, 2979 ret = cdrom_mode_sense(cdi, cgc,
2947 GPMODE_AUDIO_CTL_PAGE, 0); 2980 GPMODE_AUDIO_CTL_PAGE, 0);
2948 if (ret) 2981 if (ret)
2949 return ret; 2982 return ret;
2950 } 2983 }
2951 2984
2952 /* sanity check */ 2985 /* sanity check */
2953 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE || 2986 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
2954 buffer[offset+1] < 14) 2987 buffer[offset + 1] < 14)
2955 return -EINVAL; 2988 return -EINVAL;
2956 2989
2957 /* now we have the current volume settings. if it was only 2990 /* now we have the current volume settings. if it was only
2958 a CDROMVOLREAD, return these values */ 2991 a CDROMVOLREAD, return these values */
2959 if (cmd == CDROMVOLREAD) { 2992 if (cmd == CDROMVOLREAD) {
2960 volctrl.channel0 = buffer[offset+9]; 2993 volctrl.channel0 = buffer[offset+9];
2961 volctrl.channel1 = buffer[offset+11]; 2994 volctrl.channel1 = buffer[offset+11];
2962 volctrl.channel2 = buffer[offset+13]; 2995 volctrl.channel2 = buffer[offset+13];
2963 volctrl.channel3 = buffer[offset+15]; 2996 volctrl.channel3 = buffer[offset+15];
2964 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl); 2997 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
2965 return 0; 2998 return 0;
2966 } 2999 }
2967 3000
2968 /* get the volume mask */ 3001 /* get the volume mask */
2969 cgc.buffer = mask; 3002 cgc->buffer = mask;
2970 if ((ret = cdrom_mode_sense(cdi, &cgc, 3003 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
2971 GPMODE_AUDIO_CTL_PAGE, 1))) 3004 if (ret)
2972 return ret; 3005 return ret;
2973 3006
2974 buffer[offset+9] = volctrl.channel0 & mask[offset+9]; 3007 buffer[offset + 9] = volctrl.channel0 & mask[offset + 9];
2975 buffer[offset+11] = volctrl.channel1 & mask[offset+11]; 3008 buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
2976 buffer[offset+13] = volctrl.channel2 & mask[offset+13]; 3009 buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
2977 buffer[offset+15] = volctrl.channel3 & mask[offset+15]; 3010 buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
2978 3011
2979 /* set volume */ 3012 /* set volume */
2980 cgc.buffer = buffer + offset - 8; 3013 cgc->buffer = buffer + offset - 8;
2981 memset(cgc.buffer, 0, 8); 3014 memset(cgc->buffer, 0, 8);
2982 return cdrom_mode_select(cdi, &cgc); 3015 return cdrom_mode_select(cdi, cgc);
2983 } 3016}
2984 3017
2985 case CDROMSTART: 3018static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
2986 case CDROMSTOP: { 3019 struct packet_command *cgc,
2987 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n"); 3020 int cmd)
2988 cgc.cmd[0] = GPCMD_START_STOP_UNIT; 3021{
2989 cgc.cmd[1] = 1; 3022 struct cdrom_device_ops *cdo = cdi->ops;
2990 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0; 3023 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
2991 cgc.data_direction = CGC_DATA_NONE; 3024 cgc->cmd[0] = GPCMD_START_STOP_UNIT;
2992 return cdo->generic_packet(cdi, &cgc); 3025 cgc->cmd[1] = 1;
2993 } 3026 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3027 cgc->data_direction = CGC_DATA_NONE;
3028 return cdo->generic_packet(cdi, cgc);
3029}
2994 3030
2995 case CDROMPAUSE: 3031static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
2996 case CDROMRESUME: { 3032 struct packet_command *cgc,
2997 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n"); 3033 int cmd)
2998 cgc.cmd[0] = GPCMD_PAUSE_RESUME; 3034{
2999 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0; 3035 struct cdrom_device_ops *cdo = cdi->ops;
3000 cgc.data_direction = CGC_DATA_NONE; 3036 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3001 return cdo->generic_packet(cdi, &cgc); 3037 cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3002 } 3038 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3039 cgc->data_direction = CGC_DATA_NONE;
3040 return cdo->generic_packet(cdi, cgc);
3041}
3003 3042
3004 case DVD_READ_STRUCT: { 3043static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3005 dvd_struct *s; 3044 void __user *arg,
3006 int size = sizeof(dvd_struct); 3045 struct packet_command *cgc)
3007 if (!CDROM_CAN(CDC_DVD)) 3046{
3008 return -ENOSYS; 3047 int ret;
3009 if ((s = kmalloc(size, GFP_KERNEL)) == NULL) 3048 dvd_struct *s;
3010 return -ENOMEM; 3049 int size = sizeof(dvd_struct);
3011 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n"); 3050
3012 if (copy_from_user(s, (dvd_struct __user *)arg, size)) { 3051 if (!CDROM_CAN(CDC_DVD))
3013 kfree(s); 3052 return -ENOSYS;
3014 return -EFAULT; 3053
3015 } 3054 s = kmalloc(size, GFP_KERNEL);
3016 if ((ret = dvd_read_struct(cdi, s))) { 3055 if (!s)
3017 kfree(s); 3056 return -ENOMEM;
3018 return ret; 3057
3019 } 3058 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3020 if (copy_to_user((dvd_struct __user *)arg, s, size)) 3059 if (copy_from_user(s, arg, size)) {
3021 ret = -EFAULT;
3022 kfree(s); 3060 kfree(s);
3061 return -EFAULT;
3062 }
3063
3064 ret = dvd_read_struct(cdi, s, cgc);
3065 if (ret)
3066 goto out;
3067
3068 if (copy_to_user(arg, s, size))
3069 ret = -EFAULT;
3070out:
3071 kfree(s);
3072 return ret;
3073}
3074
3075static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3076 void __user *arg)
3077{
3078 int ret;
3079 dvd_authinfo ai;
3080 if (!CDROM_CAN(CDC_DVD))
3081 return -ENOSYS;
3082 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3083 IOCTL_IN(arg, dvd_authinfo, ai);
3084 ret = dvd_do_auth(cdi, &ai);
3085 if (ret)
3023 return ret; 3086 return ret;
3024 } 3087 IOCTL_OUT(arg, dvd_authinfo, ai);
3088 return 0;
3089}
3025 3090
3026 case DVD_AUTH: { 3091static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3027 dvd_authinfo ai; 3092 void __user *arg)
3028 if (!CDROM_CAN(CDC_DVD)) 3093{
3029 return -ENOSYS; 3094 int ret;
3030 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n"); 3095 long next = 0;
3031 IOCTL_IN(arg, dvd_authinfo, ai); 3096 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3032 if ((ret = dvd_do_auth (cdi, &ai))) 3097 ret = cdrom_get_next_writable(cdi, &next);
3033 return ret; 3098 if (ret)
3034 IOCTL_OUT(arg, dvd_authinfo, ai); 3099 return ret;
3035 return 0; 3100 IOCTL_OUT(arg, long, next);
3036 } 3101 return 0;
3102}
3037 3103
3038 case CDROM_NEXT_WRITABLE: { 3104static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3039 long next = 0; 3105 void __user *arg)
3040 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n"); 3106{
3041 if ((ret = cdrom_get_next_writable(cdi, &next))) 3107 int ret;
3042 return ret; 3108 long last = 0;
3043 IOCTL_OUT(arg, long, next); 3109 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3044 return 0; 3110 ret = cdrom_get_last_written(cdi, &last);
3045 } 3111 if (ret)
3046 case CDROM_LAST_WRITTEN: { 3112 return ret;
3047 long last = 0; 3113 IOCTL_OUT(arg, long, last);
3048 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n"); 3114 return 0;
3049 if ((ret = cdrom_get_last_written(cdi, &last))) 3115}
3050 return ret; 3116
3051 IOCTL_OUT(arg, long, last); 3117static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3052 return 0; 3118 unsigned long arg)
3053 } 3119{
3054 } /* switch */ 3120 struct packet_command cgc;
3121 void __user *userptr = (void __user *)arg;
3122
3123 memset(&cgc, 0, sizeof(cgc));
3124
3125 /* build a unified command and queue it through
3126 cdo->generic_packet() */
3127 switch (cmd) {
3128 case CDROMREADRAW:
3129 case CDROMREADMODE1:
3130 case CDROMREADMODE2:
3131 return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3132 case CDROMREADAUDIO:
3133 return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3134 case CDROMSUBCHNL:
3135 return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3136 case CDROMPLAYMSF:
3137 return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3138 case CDROMPLAYBLK:
3139 return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3140 case CDROMVOLCTRL:
3141 case CDROMVOLREAD:
3142 return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3143 case CDROMSTART:
3144 case CDROMSTOP:
3145 return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3146 case CDROMPAUSE:
3147 case CDROMRESUME:
3148 return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3149 case DVD_READ_STRUCT:
3150 return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3151 case DVD_AUTH:
3152 return mmc_ioctl_dvd_auth(cdi, userptr);
3153 case CDROM_NEXT_WRITABLE:
3154 return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3155 case CDROM_LAST_WRITTEN:
3156 return mmc_ioctl_cdrom_last_written(cdi, userptr);
3157 }
3055 3158
3056 return -ENOTTY; 3159 return -ENOTTY;
3057} 3160}
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index ce26c84af064..3326750ec02c 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -1060,7 +1060,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
1060 goto bad_page_pool; 1060 goto bad_page_pool;
1061 } 1061 }
1062 1062
1063 cc->bs = bioset_create(MIN_IOS, MIN_IOS); 1063 cc->bs = bioset_create(MIN_IOS, 0);
1064 if (!cc->bs) { 1064 if (!cc->bs) {
1065 ti->error = "Cannot allocate crypt bioset"; 1065 ti->error = "Cannot allocate crypt bioset";
1066 goto bad_bs; 1066 goto bad_bs;
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 2fd6d4450637..a34338567a2a 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -56,7 +56,7 @@ struct dm_io_client *dm_io_client_create(unsigned num_pages)
56 if (!client->pool) 56 if (!client->pool)
57 goto bad; 57 goto bad;
58 58
59 client->bios = bioset_create(16, 16); 59 client->bios = bioset_create(16, 0);
60 if (!client->bios) 60 if (!client->bios)
61 goto bad; 61 goto bad;
62 62
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 343094c3feeb..421c9f02d8ca 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1093,7 +1093,7 @@ static struct mapped_device *alloc_dev(int minor)
1093 if (!md->tio_pool) 1093 if (!md->tio_pool)
1094 goto bad_tio_pool; 1094 goto bad_tio_pool;
1095 1095
1096 md->bs = bioset_create(16, 16); 1096 md->bs = bioset_create(16, 0);
1097 if (!md->bs) 1097 if (!md->bs)
1098 goto bad_no_bioset; 1098 goto bad_no_bioset;
1099 1099
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-22 00:10:52 -0500