[block] Use drive number as debug message stream ID

We currently use the SAN device pointer as the debug message stream
identifier.  This pointer is not always available: for example, when
booting from a local disk there is no underlying SAN device.

Switch to using the drive number as the debug message colour stream
identifier, so that all block device debug messages may be colourised
consistently.

Signed-off-by: Michael Brown <mcb30@ipxe.org>

diff --git a/src/arch/x86/interface/pcbios/int13.c b/src/arch/x86/interface/pcbios/int13.c
index d6c4d7ebf2509ea3e6b20a0eecdc88a50a185d00..2c5e862413b8df832f7a90653876c2ee0cfcdde0 100644 (file)
--- a/src/arch/x86/interface/pcbios/int13.c
+++ b/src/arch/x86/interface/pcbios/int13.c
@@ -183,8 +183,8 @@ static int int13_parse_eltorito ( struct san_device *sandev, void *scratch ) {
        /* Read boot record volume descriptor */
        if ( ( rc = sandev_read ( sandev, ELTORITO_LBA, 1,
                                  virt_to_user ( boot ) ) ) != 0 ) {
-               DBGC ( sandev, "INT13 drive %02x could not read El Torito boot "
-                      "record volume descriptor: %s\n",
+               DBGC ( sandev->drive, "INT13 drive %02x could not read El "
+                      "Torito boot record volume descriptor: %s\n",
                       sandev->drive, strerror ( rc ) );
                return rc;
        }
@@ -192,10 +192,11 @@ static int int13_parse_eltorito ( struct san_device *sandev, void *scratch ) {
        /* Check for an El Torito boot catalog */
        if ( memcmp ( boot, &boot_check, sizeof ( boot_check ) ) == 0 ) {
                int13->boot_catalog = boot->sector;
-               DBGC ( sandev, "INT13 drive %02x has an El Torito boot catalog "
-                      "at LBA %08x\n", sandev->drive, int13->boot_catalog );
+               DBGC ( sandev->drive, "INT13 drive %02x has an El Torito boot "
+                      "catalog at LBA %08x\n", sandev->drive,
+                      int13->boot_catalog );
        } else {
-               DBGC ( sandev, "INT13 drive %02x has no El Torito boot "
+               DBGC ( sandev->drive, "INT13 drive %02x has no El Torito boot "
                       "catalog\n", sandev->drive );
        }
 
@@ -228,14 +229,14 @@ static int int13_guess_geometry_hdd ( struct san_device *sandev, void *scratch,
 
        /* Read partition table */
        if ( ( rc = sandev_read ( sandev, 0, 1, virt_to_user ( mbr ) ) ) != 0 ) {
-               DBGC ( sandev, "INT13 drive %02x could not read "
+               DBGC ( sandev->drive, "INT13 drive %02x could not read "
                       "partition table to guess geometry: %s\n",
                       sandev->drive, strerror ( rc ) );
                return rc;
        }
-       DBGC2 ( sandev, "INT13 drive %02x has MBR:\n", sandev->drive );
-       DBGC2_HDA ( sandev, 0, mbr, sizeof ( *mbr ) );
-       DBGC ( sandev, "INT13 drive %02x has signature %08x\n",
+       DBGC2 ( sandev->drive, "INT13 drive %02x has MBR:\n", sandev->drive );
+       DBGC2_HDA ( sandev->drive, 0, mbr, sizeof ( *mbr ) );
+       DBGC ( sandev->drive, "INT13 drive %02x has signature %08x\n",
               sandev->drive, mbr->signature );
 
        /* Scan through partition table and modify guesses for
@@ -260,8 +261,8 @@ static int int13_guess_geometry_hdd ( struct san_device *sandev, void *scratch,
                if ( ( start_cylinder == 0 ) && ( start_head != 0 ) ) {
                        *sectors = ( ( partition->start + 1 - start_sector ) /
                                     start_head );
-                       DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
-                              "xx/xx/%d based on partition %d\n",
+                       DBGC ( sandev->drive, "INT13 drive %02x guessing "
+                              "C/H/S xx/xx/%d based on partition %d\n",
                               sandev->drive, *sectors, ( i + 1 ) );
                }
 
@@ -272,14 +273,14 @@ static int int13_guess_geometry_hdd ( struct san_device *sandev, void *scratch,
                end_sector = PART_SECTOR ( partition->chs_end );
                if ( ( end_head + 1 ) > *heads ) {
                        *heads = ( end_head + 1 );
-                       DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
-                              "xx/%d/xx based on partition %d\n",
+                       DBGC ( sandev->drive, "INT13 drive %02x guessing "
+                              "C/H/S xx/%d/xx based on partition %d\n",
                               sandev->drive, *heads, ( i + 1 ) );
                }
                if ( end_sector > *sectors ) {
                        *sectors = end_sector;
-                       DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
-                              "xx/xx/%d based on partition %d\n",
+                       DBGC ( sandev->drive, "INT13 drive %02x guessing "
+                              "C/H/S xx/xx/%d based on partition %d\n",
                               sandev->drive, *sectors, ( i + 1 ) );
                }
        }
@@ -343,9 +344,10 @@ static int int13_guess_geometry_fdd ( struct san_device *sandev,
                *heads = INT13_FDD_HEADS ( geometry );
                *sectors = INT13_FDD_SECTORS ( geometry );
                if ( ( cylinders * (*heads) * (*sectors) ) == blocks ) {
-                       DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
-                              "%d/%d/%d based on size %dK\n", sandev->drive,
-                              cylinders, *heads, *sectors, ( blocks / 2 ) );
+                       DBGC ( sandev->drive, "INT13 drive %02x guessing "
+                              "C/H/S %d/%d/%d based on size %dK\n",
+                              sandev->drive, cylinders, *heads, *sectors,
+                              ( blocks / 2 ) );
                        return 0;
                }
        }
@@ -355,8 +357,9 @@ static int int13_guess_geometry_fdd ( struct san_device *sandev,
         */
        *heads = 2;
        *sectors = 18;
-       DBGC ( sandev, "INT13 drive %02x guessing C/H/S xx/%d/%d based on size "
-              "%dK\n", sandev->drive, *heads, *sectors, ( blocks / 2 ) );
+       DBGC ( sandev->drive, "INT13 drive %02x guessing C/H/S xx/%d/%d "
+              "based on size %dK\n", sandev->drive, *heads, *sectors,
+              ( blocks / 2 ) );
        return 0;
 }
 
@@ -431,8 +434,8 @@ static void int13_sync_num_drives ( void ) {
                required = ( ( max_drive & 0x7f ) + 1 );
                if ( *counter < required ) {
                        *counter = required;
-                       DBGC ( sandev, "INT13 drive %02x added to drive count: "
-                              "%d HDDs, %d FDDs\n",
+                       DBGC ( sandev->drive, "INT13 drive %02x added to "
+                              "drive count: %d HDDs, %d FDDs\n",
                               sandev->drive, num_drives, num_fdds );
                }
        }
@@ -472,7 +475,7 @@ static int int13_reset ( struct san_device *sandev,
                         struct i386_all_regs *ix86 __unused ) {
        int rc;
 
-       DBGC2 ( sandev, "Reset drive\n" );
+       DBGC2 ( sandev->drive, "Reset drive\n" );
 
        /* Reset SAN device */
        if ( ( rc = sandev_reset ( sandev ) ) != 0 )
@@ -491,7 +494,7 @@ static int int13_get_last_status ( struct san_device *sandev,
                                   struct i386_all_regs *ix86 __unused ) {
        struct int13_data *int13 = sandev->priv;
 
-       DBGC2 ( sandev, "Get status of last operation\n" );
+       DBGC2 ( sandev->drive, "Get status of last operation\n" );
        return int13->last_status;
 }
 
@@ -524,8 +527,8 @@ static int int13_rw_sectors ( struct san_device *sandev,
 
        /* Validate blocksize */
        if ( sandev_blksize ( sandev ) != INT13_BLKSIZE ) {
-               DBGC ( sandev, "\nINT 13 drive %02x invalid blocksize (%zd) "
-                      "for non-extended read/write\n",
+               DBGC ( sandev->drive, "\nINT 13 drive %02x invalid blocksize "
+                      "(%zd) for non-extended read/write\n",
                       sandev->drive, sandev_blksize ( sandev ) );
                return -INT13_STATUS_INVALID;
        }
@@ -537,9 +540,10 @@ static int int13_rw_sectors ( struct san_device *sandev,
        if ( ( cylinder >= int13->cylinders ) ||
             ( head >= int13->heads ) ||
             ( sector < 1 ) || ( sector > int13->sectors_per_track ) ) {
-               DBGC ( sandev, "C/H/S %d/%d/%d out of range for geometry "
-                      "%d/%d/%d\n", cylinder, head, sector, int13->cylinders,
-                      int13->heads, int13->sectors_per_track );
+               DBGC ( sandev->drive, "C/H/S %d/%d/%d out of range for "
+                      "geometry %d/%d/%d\n", cylinder, head, sector,
+                      int13->cylinders, int13->heads,
+                      int13->sectors_per_track );
                return -INT13_STATUS_INVALID;
        }
        lba = ( ( ( ( cylinder * int13->heads ) + head )
@@ -547,13 +551,13 @@ static int int13_rw_sectors ( struct san_device *sandev,
        count = ix86->regs.al;
        buffer = real_to_user ( ix86->segs.es, ix86->regs.bx );
 
-       DBGC2 ( sandev, "C/H/S %d/%d/%d = LBA %08lx <-> %04x:%04x (count %d)\n",
-               cylinder, head, sector, lba, ix86->segs.es, ix86->regs.bx,
-               count );
+       DBGC2 ( sandev->drive, "C/H/S %d/%d/%d = LBA %08lx <-> %04x:%04x "
+               "(count %d)\n", cylinder, head, sector, lba, ix86->segs.es,
+               ix86->regs.bx, count );
 
        /* Read from / write to block device */
        if ( ( rc = sandev_rw ( sandev, lba, count, buffer ) ) != 0 ){
-               DBGC ( sandev, "INT13 drive %02x I/O failed: %s\n",
+               DBGC ( sandev->drive, "INT13 drive %02x I/O failed: %s\n",
                       sandev->drive, strerror ( rc ) );
                return -INT13_STATUS_READ_ERROR;
        }
@@ -577,7 +581,7 @@ static int int13_rw_sectors ( struct san_device *sandev,
 static int int13_read_sectors ( struct san_device *sandev,
                                struct i386_all_regs *ix86 ) {
 
-       DBGC2 ( sandev, "Read: " );
+       DBGC2 ( sandev->drive, "Read: " );
        return int13_rw_sectors ( sandev, ix86, sandev_read );
 }
 
@@ -597,7 +601,7 @@ static int int13_read_sectors ( struct san_device *sandev,
 static int int13_write_sectors ( struct san_device *sandev,
                                 struct i386_all_regs *ix86 ) {
 
-       DBGC2 ( sandev, "Write: " );
+       DBGC2 ( sandev->drive, "Write: " );
        return int13_rw_sectors ( sandev, ix86, sandev_write );
 }
 
@@ -619,12 +623,12 @@ static int int13_get_parameters ( struct san_device *sandev,
        unsigned int max_head = int13->heads - 1;
        unsigned int max_sector = int13->sectors_per_track; /* sic */
 
-       DBGC2 ( sandev, "Get drive parameters\n" );
+       DBGC2 ( sandev->drive, "Get drive parameters\n" );
 
        /* Validate blocksize */
        if ( sandev_blksize ( sandev ) != INT13_BLKSIZE ) {
-               DBGC ( sandev, "\nINT 13 drive %02x invalid blocksize (%zd) "
-                      "for non-extended parameters\n",
+               DBGC ( sandev->drive, "\nINT 13 drive %02x invalid blocksize "
+                      "(%zd) for non-extended parameters\n",
                       sandev->drive, sandev_blksize ( sandev ) );
                return -INT13_STATUS_INVALID;
        }
@@ -657,7 +661,7 @@ static int int13_get_disk_type ( struct san_device *sandev,
                                 struct i386_all_regs *ix86 ) {
        uint32_t blocks;
 
-       DBGC2 ( sandev, "Get disk type\n" );
+       DBGC2 ( sandev->drive, "Get disk type\n" );
 
        if ( int13_is_fdd ( sandev ) ) {
                return INT13_DISK_TYPE_FDD;
@@ -682,7 +686,7 @@ static int int13_extension_check ( struct san_device *sandev,
                                   struct i386_all_regs *ix86 ) {
 
        if ( ( ix86->regs.bx == 0x55aa ) && ! int13_is_fdd ( sandev ) ) {
-               DBGC2 ( sandev, "INT13 extensions installation check\n" );
+               DBGC2 ( sandev->drive, "INT13 extensions check\n" );
                ix86->regs.bx = 0xaa55;
                ix86->regs.cx = ( INT13_EXTENSION_LINEAR |
                                  INT13_EXTENSION_EDD |
@@ -725,7 +729,8 @@ static int int13_extended_rw ( struct san_device *sandev,
        get_real ( bufsize, ix86->segs.ds,
                   ( ix86->regs.si + offsetof ( typeof ( addr ), bufsize ) ) );
        if ( bufsize < offsetof ( typeof ( addr ), buffer_phys ) ) {
-               DBGC2 ( sandev, "<invalid buffer size %#02x\n>\n", bufsize );
+               DBGC2 ( sandev->drive, "<invalid buffer size %#02x\n>\n",
+                       bufsize );
                return -INT13_STATUS_INVALID;
        }
 
@@ -733,17 +738,18 @@ static int int13_extended_rw ( struct san_device *sandev,
        memset ( &addr, 0, sizeof ( addr ) );
        copy_from_real ( &addr, ix86->segs.ds, ix86->regs.si, bufsize );
        lba = addr.lba;
-       DBGC2 ( sandev, "LBA %08llx <-> ", ( ( unsigned long long ) lba ) );
+       DBGC2 ( sandev->drive, "LBA %08llx <-> ",
+               ( ( unsigned long long ) lba ) );
        if ( ( addr.count == 0xff ) ||
             ( ( addr.buffer.segment == 0xffff ) &&
               ( addr.buffer.offset == 0xffff ) ) ) {
                buffer = phys_to_user ( addr.buffer_phys );
-               DBGC2 ( sandev, "%08llx",
+               DBGC2 ( sandev->drive, "%08llx",
                        ( ( unsigned long long ) addr.buffer_phys ) );
        } else {
                buffer = real_to_user ( addr.buffer.segment,
                                        addr.buffer.offset );
-               DBGC2 ( sandev, "%04x:%04x", addr.buffer.segment,
+               DBGC2 ( sandev->drive, "%04x:%04x", addr.buffer.segment,
                        addr.buffer.offset );
        }
        if ( addr.count <= 0x7f ) {
@@ -751,15 +757,15 @@ static int int13_extended_rw ( struct san_device *sandev,
        } else if ( addr.count == 0xff ) {
                count = addr.long_count;
        } else {
-               DBGC2 ( sandev, " <invalid count %#02x>\n", addr.count );
+               DBGC2 ( sandev->drive, " <invalid count %#02x>\n", addr.count );
                return -INT13_STATUS_INVALID;
        }
-       DBGC2 ( sandev, " (count %ld)\n", count );
+       DBGC2 ( sandev->drive, " (count %ld)\n", count );
 
        /* Read from / write to block device */
        if ( ( rc = sandev_rw ( sandev, lba, count, buffer ) ) != 0 ) {
-               DBGC ( sandev, "INT13 drive %02x extended I/O failed: %s\n",
-                      sandev->drive, strerror ( rc ) );
+               DBGC ( sandev->drive, "INT13 drive %02x extended I/O failed: "
+                      "%s\n", sandev->drive, strerror ( rc ) );
                /* Record that no blocks were transferred successfully */
                addr.count = 0;
                put_real ( addr.count, ix86->segs.ds,
@@ -781,7 +787,7 @@ static int int13_extended_rw ( struct san_device *sandev,
 static int int13_extended_read ( struct san_device *sandev,
                                 struct i386_all_regs *ix86 ) {
 
-       DBGC2 ( sandev, "Extended read: " );
+       DBGC2 ( sandev->drive, "Extended read: " );
        return int13_extended_rw ( sandev, ix86, sandev_read );
 }
 
@@ -795,7 +801,7 @@ static int int13_extended_read ( struct san_device *sandev,
 static int int13_extended_write ( struct san_device *sandev,
                                  struct i386_all_regs *ix86 ) {
 
-       DBGC2 ( sandev, "Extended write: " );
+       DBGC2 ( sandev->drive, "Extended write: " );
        return int13_extended_rw ( sandev, ix86, sandev_write );
 }
 
@@ -818,7 +824,7 @@ static int int13_extended_verify ( struct san_device *sandev,
                                 sizeof ( addr ));
                lba = addr.lba;
                count = addr.count;
-               DBGC2 ( sandev, "Verify: LBA %08llx (count %ld)\n",
+               DBGC2 ( sandev->drive, "Verify: LBA %08llx (count %ld)\n",
                        ( ( unsigned long long ) lba ), count );
        }
 
@@ -845,7 +851,7 @@ static int int13_extended_seek ( struct san_device *sandev,
                                 sizeof ( addr ));
                lba = addr.lba;
                count = addr.count;
-               DBGC2 ( sandev, "Seek: LBA %08llx (count %ld)\n",
+               DBGC2 ( sandev->drive, "Seek: LBA %08llx (count %ld)\n",
                        ( ( unsigned long long ) lba ), count );
        }
 
@@ -879,8 +885,8 @@ static int int13_device_path_info ( struct san_device *sandev,
        /* Get underlying hardware device */
        device = identify_device ( &sanpath->block );
        if ( ! device ) {
-               DBGC ( sandev, "INT13 drive %02x cannot identify hardware "
-                      "device\n", sandev->drive );
+               DBGC ( sandev->drive, "INT13 drive %02x cannot identify "
+                      "hardware device\n", sandev->drive );
                return -ENODEV;
        }
 
@@ -895,16 +901,16 @@ static int int13_device_path_info ( struct san_device *sandev,
                dpi->interface_path.pci.channel = 0xff; /* unused */
                break;
        default:
-               DBGC ( sandev, "INT13 drive %02x unrecognised bus type %d\n",
-                      sandev->drive, desc->bus_type );
+               DBGC ( sandev->drive, "INT13 drive %02x unrecognised bus "
+                      "type %d\n", sandev->drive, desc->bus_type );
                return -ENOTSUP;
        }
 
        /* Get EDD block device description */
        if ( ( rc = edd_describe ( &sanpath->block, &dpi->interface_type,
                                   &dpi->device_path ) ) != 0 ) {
-               DBGC ( sandev, "INT13 drive %02x cannot identify block device: "
-                      "%s\n", sandev->drive, strerror ( rc ) );
+               DBGC ( sandev->drive, "INT13 drive %02x cannot identify "
+                      "block device: %s\n", sandev->drive, strerror ( rc ) );
                return rc;
        }
 
@@ -938,8 +944,8 @@ static int int13_get_extended_parameters ( struct san_device *sandev,
        get_real ( bufsize, ix86->segs.ds,
                   ( ix86->regs.si + offsetof ( typeof ( params ), bufsize )));
 
-       DBGC2 ( sandev, "Get extended drive parameters to %04x:%04x+%02x\n",
-               ix86->segs.ds, ix86->regs.si, bufsize );
+       DBGC2 ( sandev->drive, "Get extended drive parameters to "
+               "%04x:%04x+%02x\n", ix86->segs.ds, ix86->regs.si, bufsize );
 
        /* Build drive parameters */
        memset ( &params, 0, sizeof ( params ) );
@@ -955,8 +961,8 @@ static int int13_get_extended_parameters ( struct san_device *sandev,
        params.sector_size = sandev_blksize ( sandev );
        memset ( &params.dpte, 0xff, sizeof ( params.dpte ) );
        if ( ( rc = int13_device_path_info ( sandev, &params.dpi ) ) != 0 ) {
-               DBGC ( sandev, "INT13 drive %02x could not provide device "
-                      "path information: %s\n",
+               DBGC ( sandev->drive, "INT13 drive %02x could not provide "
+                      "device path information: %s\n",
                       sandev->drive, strerror ( rc ) );
                len = offsetof ( typeof ( params ), dpi );
        }
@@ -973,11 +979,11 @@ static int int13_get_extended_parameters ( struct san_device *sandev,
                params.bufsize = offsetof ( typeof ( params ), dpi );
        }
 
-       DBGC ( sandev, "INT 13 drive %02x described using extended "
+       DBGC ( sandev->drive, "INT 13 drive %02x described using extended "
               "parameters:\n", sandev->drive );
        address.segment = ix86->segs.ds;
        address.offset = ix86->regs.si;
-       DBGC_HDA ( sandev, address, &params, len );
+       DBGC_HDA ( sandev->drive, address, &params, len );
 
        /* Return drive parameters */
        if ( len > bufsize )
@@ -998,13 +1004,13 @@ static int int13_cdrom_status_terminate ( struct san_device *sandev,
                                          struct i386_all_regs *ix86 ) {
        struct int13_cdrom_specification specification;
 
-       DBGC2 ( sandev, "Get CD-ROM emulation status to %04x:%04x%s\n",
+       DBGC2 ( sandev->drive, "Get CD-ROM emulation status to %04x:%04x%s\n",
                ix86->segs.ds, ix86->regs.si,
                ( ix86->regs.al ? "" : " and terminate" ) );
 
        /* Fail if we are not a CD-ROM */
        if ( ! sandev->is_cdrom ) {
-               DBGC ( sandev, "INT13 drive %02x is not a CD-ROM\n",
+               DBGC ( sandev->drive, "INT13 drive %02x is not a CD-ROM\n",
                       sandev->drive );
                return -INT13_STATUS_INVALID;
        }
@@ -1039,11 +1045,12 @@ static int int13_cdrom_read_boot_catalog ( struct san_device *sandev,
        /* Read parameters from command packet */
        copy_from_real ( &command, ix86->segs.ds, ix86->regs.si,
                         sizeof ( command ) );
-       DBGC2 ( sandev, "Read CD-ROM boot catalog to %08x\n", command.buffer );
+       DBGC2 ( sandev->drive, "Read CD-ROM boot catalog to %08x\n",
+               command.buffer );
 
        /* Fail if we have no boot catalog */
        if ( ! int13->boot_catalog ) {
-               DBGC ( sandev, "INT13 drive %02x has no boot catalog\n",
+               DBGC ( sandev->drive, "INT13 drive %02x has no boot catalog\n",
                       sandev->drive );
                return -INT13_STATUS_INVALID;
        }
@@ -1052,8 +1059,8 @@ static int int13_cdrom_read_boot_catalog ( struct san_device *sandev,
        /* Read from boot catalog */
        if ( ( rc = sandev_read ( sandev, start, command.count,
                                  phys_to_user ( command.buffer ) ) ) != 0 ) {
-               DBGC ( sandev, "INT13 drive %02x could not read boot catalog: "
-                      "%s\n", sandev->drive, strerror ( rc ) );
+               DBGC ( sandev->drive, "INT13 drive %02x could not read boot "
+                      "catalog: %s\n", sandev->drive, strerror ( rc ) );
                return -INT13_STATUS_READ_ERROR;
        }
 
@@ -1080,8 +1087,8 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
                if ( bios_drive != sandev->drive ) {
                        /* Remap any accesses to this drive's natural number */
                        if ( bios_drive == int13->natural_drive ) {
-                               DBGC2 ( sandev, "INT13,%02x (%02x) remapped to "
-                                       "(%02x)\n", ix86->regs.ah,
+                               DBGC2 ( sandev->drive, "INT13,%02x (%02x) "
+                                       "remapped to (%02x)\n", ix86->regs.ah,
                                        bios_drive, sandev->drive );
                                ix86->regs.dl = sandev->drive;
                                return;
@@ -1094,7 +1101,7 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
                        }
                }
                
-               DBGC2 ( sandev, "INT13,%02x (%02x): ",
+               DBGC2 ( sandev->drive, "INT13,%02x (%02x): ",
                        ix86->regs.ah, bios_drive );
 
                switch ( command ) {
@@ -1141,7 +1148,7 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
                        status = int13_cdrom_read_boot_catalog ( sandev, ix86 );
                        break;
                default:
-                       DBGC2 ( sandev, "*** Unrecognised INT13 ***\n" );
+                       DBGC2 ( sandev->drive, "*** Unrecognised INT13 ***\n" );
                        status = -INT13_STATUS_INVALID;
                        break;
                }
@@ -1152,8 +1159,9 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
                /* Negative status indicates an error */
                if ( status < 0 ) {
                        status = -status;
-                       DBGC ( sandev, "INT13,%02x (%02x) failed with status "
-                              "%02x\n", ix86->regs.ah, sandev->drive, status );
+                       DBGC ( sandev->drive, "INT13,%02x (%02x) failed with "
+                              "status %02x\n", ix86->regs.ah, sandev->drive,
+                              status );
                } else {
                        ix86->flags &= ~CF;
                }
@@ -1269,7 +1277,7 @@ static int int13_hook ( unsigned int drive, struct uri **uris,
 
        /* Register SAN device */
        if ( ( rc = register_sandev ( sandev, drive, flags ) ) != 0 ) {
-               DBGC ( sandev, "INT13 drive %02x could not register: %s\n",
+               DBGC ( drive, "INT13 drive %02x could not register: %s\n",
                       drive, strerror ( rc ) );
                goto err_register;
        }
@@ -1289,10 +1297,9 @@ static int int13_hook ( unsigned int drive, struct uri **uris,
             ( ( rc = int13_guess_geometry ( sandev, scratch ) ) != 0 ) )
                goto err_guess_geometry;
 
-       DBGC ( sandev, "INT13 drive %02x (naturally %02x) registered with "
-              "C/H/S geometry %d/%d/%d\n",
-              sandev->drive, int13->natural_drive, int13->cylinders,
-              int13->heads, int13->sectors_per_track );
+       DBGC ( drive, "INT13 drive %02x (naturally %02x) registered with "
+              "C/H/S geometry %d/%d/%d\n", drive, int13->natural_drive,
+              int13->cylinders, int13->heads, int13->sectors_per_track );
 
        /* Hook INT 13 vector if not already hooked */
        if ( need_hook ) {
@@ -1332,7 +1339,7 @@ static void int13_unhook ( unsigned int drive ) {
        /* Find drive */
        sandev = sandev_find ( drive );
        if ( ! sandev ) {
-               DBG ( "INT13 cannot find drive %02x\n", drive );
+               DBGC ( drive, "INT13 drive %02x is not a SAN drive\n", drive );
                return;
        }
 
@@ -1343,7 +1350,7 @@ static void int13_unhook ( unsigned int drive ) {
         * to do so reliably.
         */
 
-       DBGC ( sandev, "INT13 drive %02x unregistered\n", sandev->drive );
+       DBGC ( drive, "INT13 drive %02x unregistered\n", drive );
 
        /* Unhook INT 13 vector if no more drives */
        if ( ! have_sandevs() ) {
@@ -1387,8 +1394,8 @@ static int int13_load_mbr ( unsigned int drive, struct segoff *address ) {
                               : "a" ( 0x0201 ), "b" ( *address ),
                                 "c" ( 1 ), "d" ( drive ) );
        if ( status ) {
-               DBG ( "INT13 drive %02x could not read MBR (status %04x)\n",
-                     drive, status );
+               DBGC ( drive, "INT13 drive %02x could not read MBR (status "
+                      "%04x)\n", drive, status );
                return -EIO;
        }
 
@@ -1397,8 +1404,8 @@ static int int13_load_mbr ( unsigned int drive, struct segoff *address ) {
                   ( address->offset +
                     offsetof ( struct master_boot_record, magic ) ) );
        if ( magic != INT13_MBR_MAGIC ) {
-               DBG ( "INT13 drive %02x does not contain a valid MBR\n",
-                     drive );
+               DBGC ( drive, "INT13 drive %02x does not contain a valid MBR\n",
+                      drive );
                return -ENOEXEC;
        }
 
@@ -1444,8 +1451,8 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
                               : "a" ( 0x4d00 ), "d" ( drive ),
                                 "S" ( __from_data16 ( &eltorito_cmd ) ) );
        if ( status ) {
-               DBG ( "INT13 drive %02x could not read El Torito boot catalog "
-                     "(status %04x)\n", drive, status );
+               DBGC ( drive, "INT13 drive %02x could not read El Torito boot "
+                      "catalog (status %04x)\n", drive, status );
                return -EIO;
        }
        copy_from_user ( &catalog, phys_to_user ( eltorito_cmd.buffer ), 0,
@@ -1453,26 +1460,27 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
 
        /* Sanity checks */
        if ( catalog.valid.platform_id != ELTORITO_PLATFORM_X86 ) {
-               DBG ( "INT13 drive %02x El Torito specifies unknown platform "
-                     "%02x\n", drive, catalog.valid.platform_id );
+               DBGC ( drive, "INT13 drive %02x El Torito specifies unknown "
+                      "platform %02x\n", drive, catalog.valid.platform_id );
                return -ENOEXEC;
        }
        if ( catalog.boot.indicator != ELTORITO_BOOTABLE ) {
-               DBG ( "INT13 drive %02x El Torito is not bootable\n", drive );
+               DBGC ( drive, "INT13 drive %02x El Torito is not bootable\n",
+                      drive );
                return -ENOEXEC;
        }
        if ( catalog.boot.media_type != ELTORITO_NO_EMULATION ) {
-               DBG ( "INT13 drive %02x El Torito requires emulation "
+               DBGC ( drive, "INT13 drive %02x El Torito requires emulation "
                       "type %02x\n", drive, catalog.boot.media_type );
                return -ENOTSUP;
        }
-       DBG ( "INT13 drive %02x El Torito boot image at LBA %08x (count %d)\n",
-             drive, catalog.boot.start, catalog.boot.length );
+       DBGC ( drive, "INT13 drive %02x El Torito boot image at LBA %08x "
+              "(count %d)\n", drive, catalog.boot.start, catalog.boot.length );
        address->segment = ( catalog.boot.load_segment ?
                             catalog.boot.load_segment : 0x7c0 );
        address->offset = 0;
-       DBG ( "INT13 drive %02x El Torito boot image loads at %04x:%04x\n",
-             drive, address->segment, address->offset );
+       DBGC ( drive, "INT13 drive %02x El Torito boot image loads at "
+              "%04x:%04x\n", drive, address->segment, address->offset );
 
        /* Use INT 13, 42 to read the boot image */
        eltorito_address.bufsize =
@@ -1491,8 +1499,8 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
                               : "a" ( 0x4200 ), "d" ( drive ),
                                 "S" ( __from_data16 ( &eltorito_address ) ) );
        if ( status ) {
-               DBG ( "INT13 drive %02x could not read El Torito boot image "
-                     "(status %04x)\n", drive, status );
+               DBGC ( drive, "INT13 drive %02x could not read El Torito boot "
+                      "image (status %04x)\n", drive, status );
                return -EIO;
        }
 
@@ -1533,8 +1541,8 @@ static int int13_boot ( unsigned int drive, const char *filename __unused ) {
        /* Jump to boot sector */
        if ( ( rc = call_bootsector ( address.segment, address.offset,
                                      drive ) ) != 0 ) {
-               DBG ( "INT13 drive %02x boot returned: %s\n",
-                     drive, strerror ( rc ) );
+               DBGC ( drive, "INT13 drive %02x boot returned: %s\n",
+                      drive, strerror ( rc ) );
                return rc;
        }
 

diff --git a/src/core/dummy_sanboot.c b/src/core/dummy_sanboot.c
index e6293099a4b3eecd33bffd9da6f65bf8f7db47a7..506b20c1224e669721568f66df41434867679229 100644 (file)
--- a/src/core/dummy_sanboot.c
+++ b/src/core/dummy_sanboot.c
@@ -55,7 +55,7 @@ static int dummy_san_hook ( unsigned int drive, struct uri **uris,
 
        /* Register SAN device */
        if ( ( rc = register_sandev ( sandev, drive, flags ) ) != 0 ) {
-               DBGC ( sandev, "SAN %#02x could not register: %s\n",
+               DBGC ( sandev->drive, "SAN %#02x could not register: %s\n",
                       sandev->drive, strerror ( rc ) );
                goto err_register;
        }
@@ -80,7 +80,7 @@ static void dummy_san_unhook ( unsigned int drive ) {
        /* Find drive */
        sandev = sandev_find ( drive );
        if ( ! sandev ) {
-               DBG ( "SAN %#02x does not exist\n", drive );
+               DBGC ( drive, "SAN %#02x does not exist\n", drive );
                return;
        }
 

diff --git a/src/core/sanboot.c b/src/core/sanboot.c
index cabc48430e5682fb26d2d7d9bb9273dbae5e2ab8..7e3a09e45c87d0b5ea7655facb637054346d0814 100644 (file)
--- a/src/core/sanboot.c
+++ b/src/core/sanboot.c
@@ -197,7 +197,7 @@ static int sanpath_open ( struct san_path *sanpath ) {
 
        /* Open interface */
        if ( ( rc = xfer_open_uri ( &sanpath->block, sanpath->uri ) ) != 0 ) {
-               DBGC ( sandev, "SAN %#02x.%d could not (re)open URI: "
+               DBGC ( sandev->drive, "SAN %#02x.%d could not (re)open URI: "
                       "%s\n", sandev->drive, sanpath->index, strerror ( rc ) );
                return rc;
        }
@@ -265,7 +265,7 @@ static void sanpath_block_close ( struct san_path *sanpath, int rc ) {
        /* Any closure is an error from our point of view */
        if ( rc == 0 )
                rc = -ENOTCONN;
-       DBGC ( sandev, "SAN %#02x.%d closed: %s\n",
+       DBGC ( sandev->drive, "SAN %#02x.%d closed: %s\n",
               sandev->drive, sanpath->index, strerror ( rc ) );
 
        /* Close path */
@@ -307,11 +307,11 @@ static void sanpath_step ( struct san_path *sanpath ) {
 
        /* Mark as active path or close as applicable */
        if ( ! sandev->active ) {
-               DBGC ( sandev, "SAN %#02x.%d is active\n",
+               DBGC ( sandev->drive, "SAN %#02x.%d is active\n",
                       sandev->drive, sanpath->index );
                sandev->active = sanpath;
        } else {
-               DBGC ( sandev, "SAN %#02x.%d is available\n",
+               DBGC ( sandev->drive, "SAN %#02x.%d is available\n",
                       sandev->drive, sanpath->index );
                sanpath_close ( sanpath, 0 );
        }
@@ -398,8 +398,9 @@ int sandev_reopen ( struct san_device *sandev ) {
                                rc = sanpath->path_rc;
                                break;
                        }
-                       DBGC ( sandev, "SAN %#02x never became available: %s\n",
-                              sandev->drive, strerror ( rc ) );
+                       DBGC ( sandev->drive, "SAN %#02x never became "
+                              "available: %s\n", sandev->drive,
+                              strerror ( rc ) );
                        goto err_none;
                }
        }
@@ -453,8 +454,9 @@ static int sandev_command_rw ( struct san_device *sandev,
        if ( ( rc = params->rw.block_rw ( &sanpath->block, &sandev->command,
                                          params->rw.lba, params->rw.count,
                                          params->rw.buffer, len ) ) != 0 ) {
-               DBGC ( sandev, "SAN %#02x.%d could not initiate read/write: "
-                      "%s\n", sandev->drive, sanpath->index, strerror ( rc ) );
+               DBGC ( sandev->drive, "SAN %#02x.%d could not initiate "
+                      "read/write: %s\n", sandev->drive, sanpath->index,
+                      strerror ( rc ) );
                return rc;
        }
 
@@ -480,8 +482,9 @@ sandev_command_read_capacity ( struct san_device *sandev,
        /* Initiate read capacity command */
        if ( ( rc = block_read_capacity ( &sanpath->block,
                                          &sandev->command ) ) != 0 ) {
-               DBGC ( sandev, "SAN %#02x.%d could not initiate read capacity: "
-                      "%s\n", sandev->drive, sanpath->index, strerror ( rc ) );
+               DBGC ( sandev->drive, "SAN %#02x.%d could not initiate read "
+                      "capacity: %s\n", sandev->drive, sanpath->index,
+                      strerror ( rc ) );
                return rc;
        }
 
@@ -565,7 +568,7 @@ sandev_command ( struct san_device *sandev,
 int sandev_reset ( struct san_device *sandev ) {
        int rc;
 
-       DBGC ( sandev, "SAN %#02x reset\n", sandev->drive );
+       DBGC ( sandev->drive, "SAN %#02x reset\n", sandev->drive );
 
        /* Close and reopen underlying block device */
        if ( ( rc = sandev_reopen ( sandev ) ) != 0 )
@@ -698,8 +701,8 @@ static int sandev_describe ( struct san_device *sandev ) {
                        if ( ! desc )
                                continue;
                        if ( ( rc = desc->model->complete ( desc ) ) != 0 ) {
-                               DBGC ( sandev, "SAN %#02x.%d could not be "
-                                      "described: %s\n", sandev->drive,
+                               DBGC ( sandev->drive, "SAN %#02x.%d could not "
+                                      "be described: %s\n", sandev->drive,
                                       sanpath->index, strerror ( rc ) );
                                return rc;
                        }
@@ -792,8 +795,8 @@ static int sandev_parse_iso9660 ( struct san_device *sandev ) {
        /* Read primary volume descriptor */
        if ( ( rc = sandev_read ( sandev, lba, count,
                                  virt_to_user ( scratch ) ) ) != 0 ) {
-               DBGC ( sandev, "SAN %#02x could not read ISO9660 primary"
-                      "volume descriptor: %s\n",
+               DBGC ( sandev->drive, "SAN %#02x could not read ISO9660 "
+                      "primary volume descriptor: %s\n",
                       sandev->drive, strerror ( rc ) );
                goto err_rw;
        }
@@ -801,8 +804,8 @@ static int sandev_parse_iso9660 ( struct san_device *sandev ) {
        /* Configure as CD-ROM if applicable */
        if ( memcmp ( &scratch->primary.fixed, &primary_check,
                      sizeof ( primary_check ) ) == 0 ) {
-               DBGC ( sandev, "SAN %#02x contains an ISO9660 filesystem; "
-                      "treating as CD-ROM\n", sandev->drive );
+               DBGC ( sandev->drive, "SAN %#02x contains an ISO9660 "
+                      "filesystem; treating as CD-ROM\n", sandev->drive );
                sandev->blksize_shift = blksize_shift;
                sandev->is_cdrom = 1;
        }
@@ -871,7 +874,7 @@ int register_sandev ( struct san_device *sandev, unsigned int drive,
 
        /* Check that drive number is not in use */
        if ( sandev_find ( drive ) != NULL ) {
-               DBGC ( sandev, "SAN %#02x is already in use\n", drive );
+               DBGC ( sandev->drive, "SAN %#02x is already in use\n", drive );
                rc = -EADDRINUSE;
                goto err_in_use;
        }
@@ -902,7 +905,7 @@ int register_sandev ( struct san_device *sandev, unsigned int drive,
 
        /* Add to list of SAN devices */
        list_add_tail ( &sandev->list, &san_devices );
-       DBGC ( sandev, "SAN %#02x registered\n", sandev->drive );
+       DBGC ( sandev->drive, "SAN %#02x registered\n", sandev->drive );
 
        return 0;
 
@@ -936,7 +939,7 @@ void unregister_sandev ( struct san_device *sandev ) {
        /* Remove ACPI descriptors */
        sandev_undescribe ( sandev );
 
-       DBGC ( sandev, "SAN %#02x unregistered\n", sandev->drive );
+       DBGC ( sandev->drive, "SAN %#02x unregistered\n", sandev->drive );
 }
 
 /** The "san-drive" setting */

diff --git a/src/interface/efi/efi_block.c b/src/interface/efi/efi_block.c
index cb73260d5a59b751e96c714f6c4682a8f4c9b1b0..86186c0adedc94b2e2a1d4634033bdaa80f03bd3 100644 (file)
--- a/src/interface/efi/efi_block.c
+++ b/src/interface/efi/efi_block.c
@@ -101,7 +101,7 @@ static int efi_block_rw ( struct san_device *sandev, uint64_t lba,
        /* Sanity check */
        count = ( len / block->media.BlockSize );
        if ( ( count * block->media.BlockSize ) != len ) {
-               DBGC ( sandev, "EFIBLK %#02x impossible length %#zx\n",
+               DBGC ( sandev->drive, "EFIBLK %#02x impossible length %#zx\n",
                       sandev->drive, len );
                return -EINVAL;
        }
@@ -109,7 +109,7 @@ static int efi_block_rw ( struct san_device *sandev, uint64_t lba,
        /* Read from / write to block device */
        if ( ( rc = sandev_rw ( sandev, lba, count,
                                virt_to_user ( data ) ) ) != 0 ) {
-               DBGC ( sandev, "EFIBLK %#02x I/O failed: %s\n",
+               DBGC ( sandev->drive, "EFIBLK %#02x I/O failed: %s\n",
                       sandev->drive, strerror ( rc ) );
                return rc;
        }
@@ -131,7 +131,7 @@ static EFI_STATUS EFIAPI efi_block_io_reset ( EFI_BLOCK_IO_PROTOCOL *block_io,
        struct san_device *sandev = block->sandev;
        int rc;
 
-       DBGC2 ( sandev, "EFIBLK %#02x reset\n", sandev->drive );
+       DBGC2 ( sandev->drive, "EFIBLK %#02x reset\n", sandev->drive );
        efi_snp_claim();
        rc = sandev_reset ( sandev );
        efi_snp_release();
@@ -156,7 +156,7 @@ efi_block_io_read ( EFI_BLOCK_IO_PROTOCOL *block_io, UINT32 media __unused,
        struct san_device *sandev = block->sandev;
        int rc;
 
-       DBGC2 ( sandev, "EFIBLK %#02x read LBA %#08llx to %p+%#08zx\n",
+       DBGC2 ( sandev->drive, "EFIBLK %#02x read LBA %#08llx to %p+%#08zx\n",
                sandev->drive, lba, data, ( ( size_t ) len ) );
        efi_snp_claim();
        rc = efi_block_rw ( sandev, lba, data, len, sandev_read );
@@ -182,8 +182,8 @@ efi_block_io_write ( EFI_BLOCK_IO_PROTOCOL *block_io, UINT32 media __unused,
        struct san_device *sandev = block->sandev;
        int rc;
 
-       DBGC2 ( sandev, "EFIBLK %#02x write LBA %#08llx from %p+%#08zx\n",
-               sandev->drive, lba, data, ( ( size_t ) len ) );
+       DBGC2 ( sandev->drive, "EFIBLK %#02x write LBA %#08llx from "
+               "%p+%#08zx\n", sandev->drive, lba, data, ( ( size_t ) len ) );
        efi_snp_claim();
        rc = efi_block_rw ( sandev, lba, data, len, sandev_write );
        efi_snp_release();
@@ -202,7 +202,7 @@ efi_block_io_flush ( EFI_BLOCK_IO_PROTOCOL *block_io ) {
                container_of ( block_io, struct efi_block_data, block_io );
        struct san_device *sandev = block->sandev;
 
-       DBGC2 ( sandev, "EFIBLK %#02x flush\n", sandev->drive );
+       DBGC2 ( sandev->drive, "EFIBLK %#02x flush\n", sandev->drive );
 
        /* Nothing to do */
        return 0;
@@ -223,12 +223,13 @@ static void efi_block_connect ( struct san_device *sandev ) {
        if ( ( efirc = bs->ConnectController ( block->handle, NULL,
                                               NULL, TRUE ) ) != 0 ) {
                rc = -EEFI ( efirc );
-               DBGC ( sandev, "EFIBLK %#02x could not connect drivers: %s\n",
-                      sandev->drive, strerror ( rc ) );
+               DBGC ( sandev->drive, "EFIBLK %#02x could not connect "
+                      "drivers: %s\n", sandev->drive, strerror ( rc ) );
                /* May not be an error; may already be connected */
        }
-       DBGC2 ( sandev, "EFIBLK %#02x supports protocols:\n", sandev->drive );
-       DBGC2_EFI_PROTOCOLS ( sandev, block->handle );
+       DBGC2 ( sandev->drive, "EFIBLK %#02x supports protocols:\n",
+               sandev->drive );
+       DBGC2_EFI_PROTOCOLS ( sandev->drive, block->handle );
 }
 
 /**
@@ -251,7 +252,7 @@ static int efi_block_hook ( unsigned int drive, struct uri **uris,
 
        /* Sanity check */
        if ( ! count ) {
-               DBG ( "EFIBLK has no URIs\n" );
+               DBGC ( drive, "EFIBLK %#02x has no URIs\n", drive );
                rc = -ENOTTY;
                goto err_no_uris;
        }
@@ -275,7 +276,7 @@ static int efi_block_hook ( unsigned int drive, struct uri **uris,
 
        /* Register SAN device */
        if ( ( rc = register_sandev ( sandev, drive, flags ) ) != 0 ) {
-               DBGC ( sandev, "EFIBLK %#02x could not register: %s\n",
+               DBGC ( drive, "EFIBLK %#02x could not register: %s\n",
                       drive, strerror ( rc ) );
                goto err_register;
        }
@@ -289,17 +290,17 @@ static int efi_block_hook ( unsigned int drive, struct uri **uris,
        /* Construct device path */
        if ( ! sandev->active ) {
                rc = -ENODEV;
-               DBGC ( sandev, "EFIBLK %#02x not active after registration\n",
+               DBGC ( drive, "EFIBLK %#02x not active after registration\n",
                       drive );
                goto err_active;
        }
        block->path = efi_describe ( &sandev->active->block );
        if ( ! block->path ) {
                rc = -ENODEV;
-               DBGC ( sandev, "EFIBLK %#02x has no device path\n", drive );
+               DBGC ( drive, "EFIBLK %#02x has no device path\n", drive );
                goto err_describe;
        }
-       DBGC ( sandev, "EFIBLK %#02x has device path %s\n",
+       DBGC ( drive, "EFIBLK %#02x has device path %s\n",
               drive, efi_devpath_text ( block->path ) );
 
        /* Install protocols */
@@ -309,8 +310,8 @@ static int efi_block_hook ( unsigned int drive, struct uri **uris,
                        &efi_device_path_protocol_guid, block->path,
                        NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
-               DBGC ( sandev, "EFIBLK %#02x could not install protocols: %s\n",
-                      sandev->drive, strerror ( rc ) );
+               DBGC ( drive, "EFIBLK %#02x could not install protocols: %s\n",
+                      drive, strerror ( rc ) );
                goto err_install;
        }
 
@@ -324,8 +325,8 @@ static int efi_block_hook ( unsigned int drive, struct uri **uris,
                        &efi_block_io_protocol_guid, &block->block_io,
                        &efi_device_path_protocol_guid, block->path,
                        NULL ) ) != 0 ) {
-               DBGC ( sandev, "EFIBLK %#02x could not uninstall protocols: "
-                      "%s\n", sandev->drive, strerror ( -EEFI ( efirc ) ) );
+               DBGC ( drive, "EFIBLK %#02x could not uninstall protocols: "
+                      "%s\n", drive, strerror ( -EEFI ( efirc ) ) );
                leak = 1;
        }
        efi_nullify_block ( &block->block_io );
@@ -342,10 +343,8 @@ static int efi_block_hook ( unsigned int drive, struct uri **uris,
                sandev_put ( sandev );
  err_alloc:
  err_no_uris:
-       if ( leak ) {
-               DBGC ( sandev, "EFIBLK %#02x nullified and leaked\n",
-                      sandev->drive );
-       }
+       if ( leak )
+               DBGC ( drive, "EFIBLK %#02x nullified and leaked\n", drive );
        return rc;
 }
 
@@ -364,7 +363,7 @@ static void efi_block_unhook ( unsigned int drive ) {
        /* Find SAN device */
        sandev = sandev_find ( drive );
        if ( ! sandev ) {
-               DBG ( "EFIBLK cannot find drive %#02x\n", drive );
+               DBGC ( drive, "EFIBLK %#02x is not a SAN drive\n", drive );
                return;
        }
        block = sandev->priv;
@@ -376,8 +375,8 @@ static void efi_block_unhook ( unsigned int drive ) {
                        &efi_block_io_protocol_guid, &block->block_io,
                        &efi_device_path_protocol_guid, block->path,
                        NULL ) ) != 0 ) ) {
-               DBGC ( sandev, "EFIBLK %#02x could not uninstall protocols: "
-                      "%s\n", sandev->drive, strerror ( -EEFI ( efirc ) ) );
+               DBGC ( drive, "EFIBLK %#02x could not uninstall protocols: "
+                      "%s\n", drive, strerror ( -EEFI ( efirc ) ) );
                leak = 1;
        }
        efi_nullify_block ( &block->block_io );
@@ -396,10 +395,8 @@ static void efi_block_unhook ( unsigned int drive ) {
                sandev_put ( sandev );
 
        /* Report leakage, if applicable */
-       if ( leak && ( ! efi_shutdown_in_progress ) ) {
-               DBGC ( sandev, "EFIBLK %#02x nullified and leaked\n",
-                      sandev->drive );
-       }
+       if ( leak && ( ! efi_shutdown_in_progress ) )
+               DBGC ( drive, "EFIBLK %#02x nullified and leaked\n", drive );
 }
 
 /** An installed ACPI table */
@@ -539,8 +536,8 @@ static int efi_block_boot_image ( struct san_device *sandev, EFI_HANDLE handle,
                                          &path.interface, efi_image_handle,
                                          handle,
                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL ))!=0){
-               DBGC ( sandev, "EFIBLK %#02x found filesystem with no device "
-                      "path??", sandev->drive );
+               DBGC ( sandev->drive, "EFIBLK %#02x found filesystem with no "
+                      "device path??", sandev->drive );
                rc = -EEFI ( efirc );
                goto err_open_device_path;
        }
@@ -552,7 +549,7 @@ static int efi_block_boot_image ( struct san_device *sandev, EFI_HANDLE handle,
                rc = -ENOTTY;
                goto err_not_child;
        }
-       DBGC ( sandev, "EFIBLK %#02x found child device %s\n",
+       DBGC ( sandev->drive, "EFIBLK %#02x found child device %s\n",
               sandev->drive, efi_devpath_text ( path.path ) );
 
        /* Construct device path for boot image */
@@ -583,7 +580,7 @@ static int efi_block_boot_image ( struct san_device *sandev, EFI_HANDLE handle,
        }
        end = ( ( ( void * ) filepath ) + filepath_len );
        efi_path_terminate ( end );
-       DBGC ( sandev, "EFIBLK %#02x trying to load %s\n",
+       DBGC ( sandev->drive, "EFIBLK %#02x trying to load %s\n",
               sandev->drive, efi_devpath_text ( boot_path ) );
 
        /* Try loading boot image from this device */
@@ -591,7 +588,7 @@ static int efi_block_boot_image ( struct san_device *sandev, EFI_HANDLE handle,
        if ( ( efirc = bs->LoadImage ( FALSE, efi_image_handle, boot_path,
                                       NULL, 0, image ) ) != 0 ) {
                rc = -EEFI ( efirc );
-               DBGC ( sandev, "EFIBLK %#02x could not load image: %s\n",
+               DBGC ( sandev->drive, "EFIBLK %#02x could not load image: %s\n",
                       sandev->drive, strerror ( rc ) );
                if ( efirc == EFI_SECURITY_VIOLATION )
                        bs->UnloadImage ( *image );
@@ -629,7 +626,7 @@ static int efi_block_boot ( unsigned int drive, const char *filename ) {
        /* Find SAN device */
        sandev = sandev_find ( drive );
        if ( ! sandev ) {
-               DBG ( "EFIBLK cannot find drive %#02x\n", drive );
+               DBGC ( drive, "EFIBLK %#02x is not a SAN drive\n", drive );
                rc = -ENODEV;
                goto err_sandev_find;
        }
@@ -645,8 +642,8 @@ static int efi_block_boot ( unsigned int drive, const char *filename ) {
                        ByProtocol, &efi_simple_file_system_protocol_guid,
                        NULL, &count, &handles ) ) != 0 ) {
                rc = -EEFI ( efirc );
-               DBGC ( sandev, "EFIBLK %#02x cannot locate file systems: %s\n",
-                      sandev->drive, strerror ( rc ) );
+               DBGC ( drive, "EFIBLK %#02x cannot locate file systems: %s\n",
+                      drive, strerror ( rc ) );
                goto err_locate_file_systems;
        }
 
@@ -660,13 +657,12 @@ static int efi_block_boot ( unsigned int drive, const char *filename ) {
                if ( ( rc = efi_block_boot_image ( sandev, handles[i], filename,
                                                   &image ) ) != 0 )
                        continue;
-               DBGC ( sandev, "EFIBLK %#02x found boot image\n",
-                      sandev->drive );
+               DBGC ( drive, "EFIBLK %#02x found boot image\n", drive );
                efirc = bs->StartImage ( image, NULL, NULL );
                rc = ( efirc ? -EEFI ( efirc ) : 0 );
                bs->UnloadImage ( image );
-               DBGC ( sandev, "EFIBLK %#02x boot image returned: %s\n",
-                      sandev->drive, strerror ( rc ) );
+               DBGC ( drive, "EFIBLK %#02x boot image returned: %s\n",
+                      drive, strerror ( rc ) );
                break;
        }