mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-29 13:53:33 +00:00
Code Issues Releases Wiki Activity

block: Switch struct packet_command to use struct scsi_sense_hdr

Browse source 
There is a lot of needless struct request_sense usage in the CDROM
code. These can all be struct scsi_sense_hdr instead, to avoid any
confusion over their respective structure sizes. This patch is a lot
of noise changing "sense" to "sshdr", but the final code is more
readable to distinguish between "sense" meaning "struct request_sense"
and "sshdr" meaning "struct scsi_sense_hdr".

Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Kees Cook 2018-08-02 15:22:13 -06:00 committed by Jens Axboe
parent 8a39a04783
commit e7d0748dd7
7 changed files with 63 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
drivers/block/pktcdvd.c
View file

@ -748,13 +748,13 @@ static const char *sense_key_string(__u8 index)
static void pkt_dump_sense(struct pktcdvd_device *pd, static void pkt_dump_sense(struct pktcdvd_device *pd,
struct packet_command *cgc) struct packet_command *cgc)
{ {
struct request_sense *sense = cgc->sense; struct scsi_sense_hdr *sshdr = cgc->sshdr;
if (sense) if (sshdr)
pkt_err(pd, "%*ph - sense %02x.%02x.%02x (%s)\n", pkt_err(pd, "%*ph - sense %02x.%02x.%02x (%s)\n",
CDROM_PACKET_SIZE, cgc->cmd, CDROM_PACKET_SIZE, cgc->cmd,
sense->sense_key, sense->asc, sense->ascq, sshdr->sense_key, sshdr->asc, sshdr->ascq,
sense_key_string(sense->sense_key)); sense_key_string(sshdr->sense_key));
else else
pkt_err(pd, "%*ph - no sense\n", CDROM_PACKET_SIZE, cgc->cmd); pkt_err(pd, "%*ph - no sense\n", CDROM_PACKET_SIZE, cgc->cmd);
} }
@ -787,11 +787,11 @@ static noinline_for_stack int pkt_set_speed(struct pktcdvd_device *pd,
unsigned write_speed, unsigned read_speed) unsigned write_speed, unsigned read_speed)
{ {
struct packet_command cgc; struct packet_command cgc;
struct request_sense sense; struct scsi_sense_hdr sshdr;
int ret; int ret;
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE); init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
cgc.sense = &sense; cgc.sshdr = &sshdr;
cgc.cmd[0] = GPCMD_SET_SPEED; cgc.cmd[0] = GPCMD_SET_SPEED;
cgc.cmd[2] = (read_speed >> 8) & 0xff; cgc.cmd[2] = (read_speed >> 8) & 0xff;
cgc.cmd[3] = read_speed & 0xff; cgc.cmd[3] = read_speed & 0xff;
@ -1651,7 +1651,7 @@ static noinline_for_stack int pkt_get_last_written(struct pktcdvd_device *pd,
static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd) static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
{ {
struct packet_command cgc; struct packet_command cgc;
struct request_sense sense; struct scsi_sense_hdr sshdr;
write_param_page *wp; write_param_page *wp;
char buffer[128]; char buffer[128];
int ret, size; int ret, size;
@ -1662,7 +1662,7 @@ static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
init_cdrom_command(&cgc, buffer, sizeof(*wp), CGC_DATA_READ); init_cdrom_command(&cgc, buffer, sizeof(*wp), CGC_DATA_READ);
cgc.sense = &sense; cgc.sshdr = &sshdr;
ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0); ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0);
if (ret) { if (ret) {
pkt_dump_sense(pd, &cgc); pkt_dump_sense(pd, &cgc);
@ -1678,7 +1678,7 @@ static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
* now get it all * now get it all
*/ */
init_cdrom_command(&cgc, buffer, size, CGC_DATA_READ); init_cdrom_command(&cgc, buffer, size, CGC_DATA_READ);
cgc.sense = &sense; cgc.sshdr = &sshdr;
ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0); ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0);
if (ret) { if (ret) {
pkt_dump_sense(pd, &cgc); pkt_dump_sense(pd, &cgc);
@ -1916,12 +1916,12 @@ static noinline_for_stack int pkt_write_caching(struct pktcdvd_device *pd,
int set) int set)
{ {
struct packet_command cgc; struct packet_command cgc;
struct request_sense sense; struct scsi_sense_hdr sshdr;
unsigned char buf[64]; unsigned char buf[64];
int ret; int ret;
init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ); init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
cgc.sense = &sense; cgc.sshdr = &sshdr;
cgc.buflen = pd->mode_offset + 12; cgc.buflen = pd->mode_offset + 12;
/* /*
@ -1962,14 +1962,14 @@ static noinline_for_stack int pkt_get_max_speed(struct pktcdvd_device *pd,
unsigned *write_speed) unsigned *write_speed)
{ {
struct packet_command cgc; struct packet_command cgc;
struct request_sense sense; struct scsi_sense_hdr sshdr;
unsigned char buf[256+18]; unsigned char buf[256+18];
unsigned char *cap_buf; unsigned char *cap_buf;
int ret, offset; int ret, offset;
cap_buf = &buf[sizeof(struct mode_page_header) + pd->mode_offset]; cap_buf = &buf[sizeof(struct mode_page_header) + pd->mode_offset];
init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_UNKNOWN); init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_UNKNOWN);
cgc.sense = &sense; cgc.sshdr = &sshdr;
ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0); ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
if (ret) { if (ret) {
@ -2023,13 +2023,13 @@ static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
unsigned *speed) unsigned *speed)
{ {
struct packet_command cgc; struct packet_command cgc;
struct request_sense sense; struct scsi_sense_hdr sshdr;
unsigned char buf[64]; unsigned char buf[64];
unsigned int size, st, sp; unsigned int size, st, sp;
int ret; int ret;
init_cdrom_command(&cgc, buf, 2, CGC_DATA_READ); init_cdrom_command(&cgc, buf, 2, CGC_DATA_READ);
cgc.sense = &sense; cgc.sshdr = &sshdr;
cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP; cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
cgc.cmd[1] = 2; cgc.cmd[1] = 2;
cgc.cmd[2] = 4; /* READ ATIP */ cgc.cmd[2] = 4; /* READ ATIP */
@ -2044,7 +2044,7 @@ static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
size = sizeof(buf); size = sizeof(buf);
init_cdrom_command(&cgc, buf, size, CGC_DATA_READ); init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
cgc.sense = &sense; cgc.sshdr = &sshdr;
cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP; cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
cgc.cmd[1] = 2; cgc.cmd[1] = 2;
cgc.cmd[2] = 4; cgc.cmd[2] = 4;
@ -2095,13 +2095,13 @@ static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
static noinline_for_stack int pkt_perform_opc(struct pktcdvd_device *pd) static noinline_for_stack int pkt_perform_opc(struct pktcdvd_device *pd)
{ {
struct packet_command cgc; struct packet_command cgc;
struct request_sense sense; struct scsi_sense_hdr sshdr;
int ret; int ret;
pkt_dbg(2, pd, "Performing OPC\n"); pkt_dbg(2, pd, "Performing OPC\n");
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE); init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
cgc.sense = &sense; cgc.sshdr = &sshdr;
cgc.timeout = 60*HZ; cgc.timeout = 60*HZ;
cgc.cmd[0] = GPCMD_SEND_OPC; cgc.cmd[0] = GPCMD_SEND_OPC;
cgc.cmd[1] = 1; cgc.cmd[1] = 1;

22
drivers/cdrom/cdrom.c
View file

@ -345,10 +345,10 @@ static LIST_HEAD(cdrom_list);
int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi, int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
struct packet_command *cgc) struct packet_command *cgc)
{ {
if (cgc->sense) { if (cgc->sshdr) {
cgc->sense->sense_key = 0x05; cgc->sshdr->sense_key = 0x05;
cgc->sense->asc = 0x20; cgc->sshdr->asc = 0x20;
cgc->sense->ascq = 0x00; cgc->sshdr->ascq = 0x00;
} }
cgc->stat = -EIO; cgc->stat = -EIO;
@ -2943,7 +2943,7 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
struct packet_command *cgc, struct packet_command *cgc,
int cmd) int cmd)
{ {
struct request_sense sense; struct scsi_sense_hdr sshdr;
struct cdrom_msf msf; struct cdrom_msf msf;
int blocksize = 0, format = 0, lba; int blocksize = 0, format = 0, lba;
int ret; int ret;
@ -2971,13 +2971,13 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
if (cgc->buffer == NULL) if (cgc->buffer == NULL)
return -ENOMEM; return -ENOMEM;
memset(&sense, 0, sizeof(sense)); memset(&sshdr, 0, sizeof(sshdr));
cgc->sense = &sense; cgc->sshdr = &sshdr;
cgc->data_direction = CGC_DATA_READ; cgc->data_direction = CGC_DATA_READ;
ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize); ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
if (ret && sense.sense_key == 0x05 && if (ret && sshdr.sense_key == 0x05 &&
sense.asc == 0x20 && sshdr.asc == 0x20 &&
sense.ascq == 0x00) { sshdr.ascq == 0x00) {
/* /*
* SCSI-II devices are not required to support * SCSI-II devices are not required to support
* READ_CD, so let's try switching block size * READ_CD, so let's try switching block size
@ -2986,7 +2986,7 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
ret = cdrom_switch_blocksize(cdi, blocksize); ret = cdrom_switch_blocksize(cdi, blocksize);
if (ret) if (ret)
goto out; goto out;
cgc->sense = NULL; cgc->sshdr = NULL;
ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1); ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
ret |= cdrom_switch_blocksize(cdi, blocksize); ret |= cdrom_switch_blocksize(cdi, blocksize);
} }

11
drivers/ide/ide-cd.c
View file

@ -419,7 +419,7 @@ static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct ide_cmd *cmd)
int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd, int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
int write, void *buffer, unsigned *bufflen, int write, void *buffer, unsigned *bufflen,
struct request_sense *sense, int timeout, struct scsi_sense_hdr *sshdr, int timeout,
req_flags_t rq_flags) req_flags_t rq_flags)
{ {
struct cdrom_info *info = drive->driver_data; struct cdrom_info *info = drive->driver_data;
@ -456,8 +456,9 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
if (buffer) if (buffer)
*bufflen = scsi_req(rq)->resid_len; *bufflen = scsi_req(rq)->resid_len;
if (sense) if (sshdr)
memcpy(sense, scsi_req(rq)->sense, sizeof(*sense)); scsi_normalize_sense(scsi_req(rq)->sense,
scsi_req(rq)->sense_len, sshdr);
/* /*
* FIXME: we should probably abort/retry or something in case of * FIXME: we should probably abort/retry or something in case of
@ -864,7 +865,7 @@ static void msf_from_bcd(struct atapi_msf *msf)
msf->frame = bcd2bin(msf->frame); msf->frame = bcd2bin(msf->frame);
} }
int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense) int cdrom_check_status(ide_drive_t *drive, struct scsi_sense_hdr *sshdr)
{ {
struct cdrom_info *info = drive->driver_data; struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *cdi; struct cdrom_device_info *cdi;
@ -886,7 +887,7 @@ int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
*/ */
cmd[7] = cdi->sanyo_slot % 3; cmd[7] = cdi->sanyo_slot % 3;
return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, RQF_QUIET); return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sshdr, 0, RQF_QUIET);
} }
static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity, static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,

4
drivers/ide/ide-cd.h
View file

@ -98,11 +98,11 @@ void ide_cd_log_error(const char *, struct request *, struct request_sense *);
/* ide-cd.c functions used by ide-cd_ioctl.c */ /* ide-cd.c functions used by ide-cd_ioctl.c */
int ide_cd_queue_pc(ide_drive_t *, const unsigned char *, int, void *, int ide_cd_queue_pc(ide_drive_t *, const unsigned char *, int, void *,
unsigned *, struct request_sense *, int, req_flags_t); unsigned *, struct scsi_sense_hdr *, int, req_flags_t);
int ide_cd_read_toc(ide_drive_t *); int ide_cd_read_toc(ide_drive_t *);
int ide_cdrom_get_capabilities(ide_drive_t *, u8 *); int ide_cdrom_get_capabilities(ide_drive_t *, u8 *);
void ide_cdrom_update_speed(ide_drive_t *, u8 *); void ide_cdrom_update_speed(ide_drive_t *, u8 *);
int cdrom_check_status(ide_drive_t *, struct request_sense *); int cdrom_check_status(ide_drive_t *, struct scsi_sense_hdr *);
/* ide-cd_ioctl.c */ /* ide-cd_ioctl.c */
int ide_cdrom_open_real(struct cdrom_device_info *, int); int ide_cdrom_open_real(struct cdrom_device_info *, int);

30
drivers/ide/ide-cd_ioctl.c
View file

@ -43,14 +43,14 @@ int ide_cdrom_drive_status(struct cdrom_device_info *cdi, int slot_nr)
{ {
ide_drive_t *drive = cdi->handle; ide_drive_t *drive = cdi->handle;
struct media_event_desc med; struct media_event_desc med;
struct request_sense sense; struct scsi_sense_hdr sshdr;
int stat; int stat;
if (slot_nr != CDSL_CURRENT) if (slot_nr != CDSL_CURRENT)
return -EINVAL; return -EINVAL;
stat = cdrom_check_status(drive, &sense); stat = cdrom_check_status(drive, &sshdr);
if (!stat || sense.sense_key == UNIT_ATTENTION) if (!stat || sshdr.sense_key == UNIT_ATTENTION)
return CDS_DISC_OK; return CDS_DISC_OK;
if (!cdrom_get_media_event(cdi, &med)) { if (!cdrom_get_media_event(cdi, &med)) {
@ -62,8 +62,8 @@ int ide_cdrom_drive_status(struct cdrom_device_info *cdi, int slot_nr)
return CDS_NO_DISC; return CDS_NO_DISC;
} }
if (sense.sense_key == NOT_READY && sense.asc == 0x04 if (sshdr.sense_key == NOT_READY && sshdr.asc == 0x04
&& sense.ascq == 0x04) && sshdr.ascq == 0x04)
return CDS_DISC_OK; return CDS_DISC_OK;
/* /*
@ -71,8 +71,8 @@ int ide_cdrom_drive_status(struct cdrom_device_info *cdi, int slot_nr)
* just return TRAY_OPEN since ATAPI doesn't provide * just return TRAY_OPEN since ATAPI doesn't provide
* any other way to detect this... * any other way to detect this...
*/ */
if (sense.sense_key == NOT_READY) { if (sshdr.sense_key == NOT_READY) {
if (sense.asc == 0x3a && sense.ascq == 1) if (sshdr.asc == 0x3a && sshdr.ascq == 1)
return CDS_NO_DISC; return CDS_NO_DISC;
else else
return CDS_TRAY_OPEN; return CDS_TRAY_OPEN;
@ -135,7 +135,7 @@ int cdrom_eject(ide_drive_t *drive, int ejectflag)
static static
int ide_cd_lockdoor(ide_drive_t *drive, int lockflag) int ide_cd_lockdoor(ide_drive_t *drive, int lockflag)
{ {
struct request_sense my_sense, *sense = &my_sense; struct scsi_sense_hdr sshdr;
int stat; int stat;
/* If the drive cannot lock the door, just pretend. */ /* If the drive cannot lock the door, just pretend. */
@ -150,14 +150,14 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag)
cmd[4] = lockflag ? 1 : 0; cmd[4] = lockflag ? 1 : 0;
stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL,
sense, 0, 0); &sshdr, 0, 0);
} }
/* If we got an illegal field error, the drive /* If we got an illegal field error, the drive
probably cannot lock the door. */ probably cannot lock the door. */
if (stat != 0 && if (stat != 0 &&
sense->sense_key == ILLEGAL_REQUEST && sshdr.sense_key == ILLEGAL_REQUEST &&
(sense->asc == 0x24 || sense->asc == 0x20)) { (sshdr.asc == 0x24 || sshdr.asc == 0x20)) {
printk(KERN_ERR "%s: door locking not supported\n", printk(KERN_ERR "%s: door locking not supported\n",
drive->name); drive->name);
drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING; drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
@ -165,7 +165,7 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag)
} }
/* no medium, that's alright. */ /* no medium, that's alright. */
if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a) if (stat != 0 && sshdr.sense_key == NOT_READY && sshdr.asc == 0x3a)
stat = 0; stat = 0;
if (stat == 0) { if (stat == 0) {
@ -451,8 +451,8 @@ int ide_cdrom_packet(struct cdrom_device_info *cdi,
layer. the packet must be complete, as we do not layer. the packet must be complete, as we do not
touch it at all. */ touch it at all. */
if (cgc->sense) if (cgc->sshdr)
memset(cgc->sense, 0, sizeof(struct request_sense)); memset(cgc->sshdr, 0, sizeof(*cgc->sshdr));
if (cgc->quiet) if (cgc->quiet)
flags |= RQF_QUIET; flags |= RQF_QUIET;
@ -460,7 +460,7 @@ int ide_cdrom_packet(struct cdrom_device_info *cdi,
cgc->stat = ide_cd_queue_pc(drive, cgc->cmd, cgc->stat = ide_cd_queue_pc(drive, cgc->cmd,
cgc->data_direction == CGC_DATA_WRITE, cgc->data_direction == CGC_DATA_WRITE,
cgc->buffer, &len, cgc->buffer, &len,
cgc->sense, cgc->timeout, flags); cgc->sshdr, cgc->timeout, flags);
if (!cgc->stat) if (!cgc->stat)
cgc->buflen -= len; cgc->buflen -= len;
return cgc->stat; return cgc->stat;

22
drivers/scsi/sr_ioctl.c
View file

@ -186,14 +186,13 @@ static int sr_play_trkind(struct cdrom_device_info *cdi,
int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc) int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
{ {
struct scsi_device *SDev; struct scsi_device *SDev;
struct scsi_sense_hdr sshdr; struct scsi_sense_hdr local_sshdr, *sshdr = &local_sshdr;
int result, err = 0, retries = 0; int result, err = 0, retries = 0;
unsigned char sense_buffer[SCSI_SENSE_BUFFERSIZE], *senseptr = NULL;
SDev = cd->device; SDev = cd->device;
if (cgc->sense) if (cgc->sshdr)
senseptr = sense_buffer; sshdr = cgc->sshdr;
retry: retry:
if (!scsi_block_when_processing_errors(SDev)) { if (!scsi_block_when_processing_errors(SDev)) {
@ -202,15 +201,12 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
} }
result = scsi_execute(SDev, cgc->cmd, cgc->data_direction, result = scsi_execute(SDev, cgc->cmd, cgc->data_direction,
cgc->buffer, cgc->buflen, senseptr, &sshdr, cgc->buffer, cgc->buflen, NULL, sshdr,
cgc->timeout, IOCTL_RETRIES, 0, 0, NULL); cgc->timeout, IOCTL_RETRIES, 0, 0, NULL);
if (cgc->sense)
memcpy(cgc->sense, sense_buffer, sizeof(*cgc->sense));
/* Minimal error checking. Ignore cases we know about, and report the rest. */ /* Minimal error checking. Ignore cases we know about, and report the rest. */
if (driver_byte(result) != 0) { if (driver_byte(result) != 0) {
switch (sshdr.sense_key) { switch (sshdr->sense_key) {
case UNIT_ATTENTION: case UNIT_ATTENTION:
SDev->changed = 1; SDev->changed = 1;
if (!cgc->quiet) if (!cgc->quiet)
@ -221,8 +217,8 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
err = -ENOMEDIUM; err = -ENOMEDIUM;
break; break;
case NOT_READY: /* This happens if there is no disc in drive */ case NOT_READY: /* This happens if there is no disc in drive */
if (sshdr.asc == 0x04 && if (sshdr->asc == 0x04 &&
sshdr.ascq == 0x01) { sshdr->ascq == 0x01) {
/* sense: Logical unit is in process of becoming ready */ /* sense: Logical unit is in process of becoming ready */
if (!cgc->quiet) if (!cgc->quiet)
sr_printk(KERN_INFO, cd, sr_printk(KERN_INFO, cd,
@ -245,8 +241,8 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
break; break;
case ILLEGAL_REQUEST: case ILLEGAL_REQUEST:
err = -EIO; err = -EIO;
if (sshdr.asc == 0x20 && if (sshdr->asc == 0x20 &&
sshdr.ascq == 0x00) sshdr->ascq == 0x00)
/* sense: Invalid command operation code */ /* sense: Invalid command operation code */
err = -EDRIVE_CANT_DO_THIS; err = -EDRIVE_CANT_DO_THIS;
break; break;

3
include/linux/cdrom.h
View file

@ -13,6 +13,7 @@
#include <linux/fs.h> /* not really needed, later.. */ #include <linux/fs.h> /* not really needed, later.. */
#include <linux/list.h> #include <linux/list.h>
#include <scsi/scsi_common.h>
#include <uapi/linux/cdrom.h> #include <uapi/linux/cdrom.h>
struct packet_command struct packet_command
@ -21,7 +22,7 @@ struct packet_command
unsigned char *buffer; unsigned char *buffer;
unsigned int buflen; unsigned int buflen;
int stat; int stat;
struct request_sense *sense; struct scsi_sense_hdr *sshdr;
unsigned char data_direction; unsigned char data_direction;
int quiet; int quiet;
int timeout; int timeout;