From 8e67fbf68ffeb9eb5f026dd482d73b021660bf9b Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 12:54:18 +0200 Subject: Adding debian version 2.06-3~deb11u6. Signed-off-by: Daniel Baumann --- .../disabled/gpxe/src/drivers/block/scsi.c | 366 +++++++++++++++++++++ 1 file changed, 366 insertions(+) create mode 100644 debian/grub-extras/disabled/gpxe/src/drivers/block/scsi.c (limited to 'debian/grub-extras/disabled/gpxe/src/drivers/block') diff --git a/debian/grub-extras/disabled/gpxe/src/drivers/block/scsi.c b/debian/grub-extras/disabled/gpxe/src/drivers/block/scsi.c new file mode 100644 index 0000000..a51b3af --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/drivers/block/scsi.c @@ -0,0 +1,366 @@ +/* + * Copyright (C) 2006 Michael Brown . + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include +#include +#include +#include +#include +#include +#include +#include + +/** @file + * + * SCSI block device + * + */ + +/** Maximum number of dummy "read capacity (10)" operations + * + * These are issued at connection setup to draw out various useless + * power-on messages. + */ +#define SCSI_MAX_DUMMY_READ_CAP 10 + +static inline __attribute__ (( always_inline )) struct scsi_device * +block_to_scsi ( struct block_device *blockdev ) { + return container_of ( blockdev, struct scsi_device, blockdev ); +} + +/** + * Handle SCSI command with no backing device + * + * @v scsi SCSI device + * @v command SCSI command + * @ret rc Return status code + */ +int scsi_detached_command ( struct scsi_device *scsi __unused, + struct scsi_command *command __unused ) { + return -ENODEV; +} + +/** + * Issue SCSI command + * + * @v scsi SCSI device + * @v command SCSI command + * @ret rc Return status code + */ +static int scsi_command ( struct scsi_device *scsi, + struct scsi_command *command ) { + int rc; + + DBGC2 ( scsi, "SCSI %p " SCSI_CDB_FORMAT "\n", + scsi, SCSI_CDB_DATA ( command->cdb ) ); + + /* Clear sense response code before issuing command */ + command->sense_response = 0; + + /* Flag command as in-progress */ + command->rc = -EINPROGRESS; + + /* Issue SCSI command */ + if ( ( rc = scsi->command ( scsi, command ) ) != 0 ) { + /* Something went wrong with the issuing mechanism */ + DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " err %s\n", + scsi, SCSI_CDB_DATA ( command->cdb ), strerror ( rc ) ); + return rc; + } + + /* Wait for command to complete */ + while ( command->rc == -EINPROGRESS ) + step(); + if ( ( rc = command->rc ) != 0 ) { + /* Something went wrong with the command execution */ + DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " err %s\n", + scsi, SCSI_CDB_DATA ( command->cdb ), strerror ( rc ) ); + return rc; + } + + /* Check for SCSI errors */ + if ( command->status != 0 ) { + DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " status %02x sense " + "%02x\n", scsi, SCSI_CDB_DATA ( command->cdb ), + command->status, command->sense_response ); + return -EIO; + } + + return 0; +} + +/** + * Read block from SCSI device using READ (10) + * + * @v blockdev Block device + * @v block LBA block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ +static int scsi_read_10 ( struct block_device *blockdev, uint64_t block, + unsigned long count, userptr_t buffer ) { + struct scsi_device *scsi = block_to_scsi ( blockdev ); + struct scsi_command command; + struct scsi_cdb_read_10 *cdb = &command.cdb.read10; + + /* Issue READ (10) */ + memset ( &command, 0, sizeof ( command ) ); + cdb->opcode = SCSI_OPCODE_READ_10; + cdb->lba = cpu_to_be32 ( block ); + cdb->len = cpu_to_be16 ( count ); + command.data_in = buffer; + command.data_in_len = ( count * blockdev->blksize ); + return scsi_command ( scsi, &command ); +} + +/** + * Read block from SCSI device using READ (16) + * + * @v blockdev Block device + * @v block LBA block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ +static int scsi_read_16 ( struct block_device *blockdev, uint64_t block, + unsigned long count, userptr_t buffer ) { + struct scsi_device *scsi = block_to_scsi ( blockdev ); + struct scsi_command command; + struct scsi_cdb_read_16 *cdb = &command.cdb.read16; + + /* Issue READ (16) */ + memset ( &command, 0, sizeof ( command ) ); + cdb->opcode = SCSI_OPCODE_READ_16; + cdb->lba = cpu_to_be64 ( block ); + cdb->len = cpu_to_be32 ( count ); + command.data_in = buffer; + command.data_in_len = ( count * blockdev->blksize ); + return scsi_command ( scsi, &command ); +} + +/** + * Write block to SCSI device using WRITE (10) + * + * @v blockdev Block device + * @v block LBA block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ +static int scsi_write_10 ( struct block_device *blockdev, uint64_t block, + unsigned long count, userptr_t buffer ) { + struct scsi_device *scsi = block_to_scsi ( blockdev ); + struct scsi_command command; + struct scsi_cdb_write_10 *cdb = &command.cdb.write10; + + /* Issue WRITE (10) */ + memset ( &command, 0, sizeof ( command ) ); + cdb->opcode = SCSI_OPCODE_WRITE_10; + cdb->lba = cpu_to_be32 ( block ); + cdb->len = cpu_to_be16 ( count ); + command.data_out = buffer; + command.data_out_len = ( count * blockdev->blksize ); + return scsi_command ( scsi, &command ); +} + +/** + * Write block to SCSI device using WRITE (16) + * + * @v blockdev Block device + * @v block LBA block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ +static int scsi_write_16 ( struct block_device *blockdev, uint64_t block, + unsigned long count, userptr_t buffer ) { + struct scsi_device *scsi = block_to_scsi ( blockdev ); + struct scsi_command command; + struct scsi_cdb_write_16 *cdb = &command.cdb.write16; + + /* Issue WRITE (16) */ + memset ( &command, 0, sizeof ( command ) ); + cdb->opcode = SCSI_OPCODE_WRITE_16; + cdb->lba = cpu_to_be64 ( block ); + cdb->len = cpu_to_be32 ( count ); + command.data_out = buffer; + command.data_out_len = ( count * blockdev->blksize ); + return scsi_command ( scsi, &command ); +} + +/** + * Read capacity of SCSI device via READ CAPACITY (10) + * + * @v blockdev Block device + * @ret rc Return status code + */ +static int scsi_read_capacity_10 ( struct block_device *blockdev ) { + struct scsi_device *scsi = block_to_scsi ( blockdev ); + struct scsi_command command; + struct scsi_cdb_read_capacity_10 *cdb = &command.cdb.readcap10; + struct scsi_capacity_10 capacity; + int rc; + + /* Issue READ CAPACITY (10) */ + memset ( &command, 0, sizeof ( command ) ); + cdb->opcode = SCSI_OPCODE_READ_CAPACITY_10; + command.data_in = virt_to_user ( &capacity ); + command.data_in_len = sizeof ( capacity ); + + if ( ( rc = scsi_command ( scsi, &command ) ) != 0 ) + return rc; + + /* Fill in block device fields */ + blockdev->blksize = be32_to_cpu ( capacity.blksize ); + blockdev->blocks = ( be32_to_cpu ( capacity.lba ) + 1 ); + + return 0; +} + +/** + * Read capacity of SCSI device via READ CAPACITY (16) + * + * @v blockdev Block device + * @ret rc Return status code + */ +static int scsi_read_capacity_16 ( struct block_device *blockdev ) { + struct scsi_device *scsi = block_to_scsi ( blockdev ); + struct scsi_command command; + struct scsi_cdb_read_capacity_16 *cdb = &command.cdb.readcap16; + struct scsi_capacity_16 capacity; + int rc; + + /* Issue READ CAPACITY (16) */ + memset ( &command, 0, sizeof ( command ) ); + cdb->opcode = SCSI_OPCODE_SERVICE_ACTION_IN; + cdb->service_action = SCSI_SERVICE_ACTION_READ_CAPACITY_16; + cdb->len = cpu_to_be32 ( sizeof ( capacity ) ); + command.data_in = virt_to_user ( &capacity ); + command.data_in_len = sizeof ( capacity ); + + if ( ( rc = scsi_command ( scsi, &command ) ) != 0 ) + return rc; + + /* Fill in block device fields */ + blockdev->blksize = be32_to_cpu ( capacity.blksize ); + blockdev->blocks = ( be64_to_cpu ( capacity.lba ) + 1 ); + return 0; +} + +static struct block_device_operations scsi_operations_16 = { + .read = scsi_read_16, + .write = scsi_write_16, +}; + +static struct block_device_operations scsi_operations_10 = { + .read = scsi_read_10, + .write = scsi_write_10, +}; + +/** + * Initialise SCSI device + * + * @v scsi SCSI device + * @ret rc Return status code + * + * Initialises a SCSI device. The scsi_device::command and + * scsi_device::lun fields must already be filled in. This function + * will configure scsi_device::blockdev, including issuing a READ + * CAPACITY call to determine the block size and total device size. + */ +int init_scsidev ( struct scsi_device *scsi ) { + unsigned int i; + int rc; + + /* Issue some theoretically extraneous READ CAPACITY (10) + * commands, solely in order to draw out the "CHECK CONDITION + * (power-on occurred)", "CHECK CONDITION (reported LUNs data + * has changed)" etc. that some dumb targets insist on sending + * as an error at start of day. The precise command that we + * use is unimportant; we just need to provide the target with + * an opportunity to send its responses. + */ + for ( i = 0 ; i < SCSI_MAX_DUMMY_READ_CAP ; i++ ) { + if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) == 0 ) + break; + DBGC ( scsi, "SCSI %p ignoring start-of-day error (#%d)\n", + scsi, ( i + 1 ) ); + } + + /* Try READ CAPACITY (10), which is a mandatory command, first. */ + scsi->blockdev.op = &scsi_operations_10; + if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) != 0 ) { + DBGC ( scsi, "SCSI %p could not READ CAPACITY (10): %s\n", + scsi, strerror ( rc ) ); + return rc; + } + + /* If capacity range was exceeded (i.e. capacity.lba was + * 0xffffffff, meaning that blockdev->blocks is now zero), use + * READ CAPACITY (16) instead. READ CAPACITY (16) is not + * mandatory, so we can't just use it straight off. + */ + if ( scsi->blockdev.blocks == 0 ) { + scsi->blockdev.op = &scsi_operations_16; + if ( ( rc = scsi_read_capacity_16 ( &scsi->blockdev ) ) != 0 ){ + DBGC ( scsi, "SCSI %p could not READ CAPACITY (16): " + "%s\n", scsi, strerror ( rc ) ); + return rc; + } + } + + DBGC ( scsi, "SCSI %p using READ/WRITE (%d) commands\n", scsi, + ( ( scsi->blockdev.op == &scsi_operations_10 ) ? 10 : 16 ) ); + DBGC ( scsi, "SCSI %p capacity is %ld MB (%#llx blocks)\n", scsi, + ( ( unsigned long ) ( scsi->blockdev.blocks >> 11 ) ), + scsi->blockdev.blocks ); + + return 0; +} + +/** + * Parse SCSI LUN + * + * @v lun_string LUN string representation + * @v lun LUN to fill in + * @ret rc Return status code + */ +int scsi_parse_lun ( const char *lun_string, struct scsi_lun *lun ) { + char *p; + int i; + + memset ( lun, 0, sizeof ( *lun ) ); + if ( lun_string ) { + p = ( char * ) lun_string; + for ( i = 0 ; i < 4 ; i++ ) { + lun->u16[i] = htons ( strtoul ( p, &p, 16 ) ); + if ( *p == '\0' ) + break; + if ( *p != '-' ) + return -EINVAL; + p++; + } + if ( *p ) + return -EINVAL; + } + + return 0; +} -- cgit v1.2.3