Changeset
src/block.c          |  36 ++++-----
src/block.h          |   2 +-
src/boot.c           |  16 ++--
src/cdrom.c          |   6 +-
src/disk.c           | 218 +++++++++++++++++++++++++--------------------------
src/hw/ahci.c        |   4 +-
src/hw/ata.c         |  26 +++---
src/hw/blockcmd.c    |  10 +--
src/hw/esp-scsi.c    |   2 +-
src/hw/floppy.c      |  20 ++---
src/hw/lsi-scsi.c    |   2 +-
src/hw/megasas.c     |   2 +-
src/hw/mpt-scsi.c    |   2 +-
src/hw/nvme.c        |   2 +-
src/hw/pvscsi.c      |   2 +-
src/hw/ramdisk.c     |   2 +-
src/hw/sdcard.c      |   2 +-
src/hw/usb-msc.c     |   4 +-
src/hw/usb-uas.c     |   2 +-
src/hw/virtio-blk.c  |  14 ++--
src/hw/virtio-ring.c |   1 -
src/hw/virtio-scsi.c |   5 +-
22 files changed, 189 insertions(+), 191 deletions(-)
Git apply log
Switched to a new branch '20170711165032.2443-1-kevin@koconnor.net'
Applying: boot: Rename drive_g to drive
Applying: disk: Don't require the 'struct drive_s' to be in the f-segment
Applying: block: Rename disk_op_s->drive_gf to drive_fl
Applying: virtio: Allocate drive_s storage in low memory
To https://github.com/patchew-project/seabios
 * [new tag]         patchew/20170711165032.2443-1-kevin@koconnor.net -> patchew/20170711165032.2443-1-kevin@koconnor.net
[SeaBIOS] [PATCH 0/4] Avoid using f-segment memory for virtio
Posted by Kevin O'Connor, 10 weeks ago
This series updates the generic code so that either "low" memory or
the f-segment can be used for storing drive mapping information.  It
also updates the virtio code to use "low" memory for its allocations.
I think there is a good chance this series will, in practice, avoid
running out of memory when a large number of virtio drives are
available.

There are other ways to tackle this problem (eg, more of the virtio
storage could be moved into "high" memory), but I think this approach
has the benefit of avoiding a "big bang" patch series.

Comments welcome.

-Kevin


Kevin O'Connor (4):
  boot: Rename drive_g to drive
  disk: Don't require the 'struct drive_s' to be in the f-segment
  block: Rename disk_op_s->drive_gf to drive_fl
  virtio: Allocate drive_s storage in low memory

 src/block.c          |  36 ++++-----
 src/block.h          |   2 +-
 src/boot.c           |  16 ++--
 src/cdrom.c          |   6 +-
 src/disk.c           | 218 +++++++++++++++++++++++++--------------------------
 src/hw/ahci.c        |   4 +-
 src/hw/ata.c         |  26 +++---
 src/hw/blockcmd.c    |  10 +--
 src/hw/esp-scsi.c    |   2 +-
 src/hw/floppy.c      |  20 ++---
 src/hw/lsi-scsi.c    |   2 +-
 src/hw/megasas.c     |   2 +-
 src/hw/mpt-scsi.c    |   2 +-
 src/hw/nvme.c        |   2 +-
 src/hw/pvscsi.c      |   2 +-
 src/hw/ramdisk.c     |   2 +-
 src/hw/sdcard.c      |   2 +-
 src/hw/usb-msc.c     |   4 +-
 src/hw/usb-uas.c     |   2 +-
 src/hw/virtio-blk.c  |  14 ++--
 src/hw/virtio-ring.c |   1 -
 src/hw/virtio-scsi.c |   5 +-
 22 files changed, 189 insertions(+), 191 deletions(-)

-- 
2.9.4


_______________________________________________
SeaBIOS mailing list
SeaBIOS@seabios.org
https://mail.coreboot.org/mailman/listinfo/seabios
[SeaBIOS] [PATCH 1/4] boot: Rename drive_g to drive
Posted by Kevin O'Connor, 10 weeks ago
The 'struct drive_s' pointer is a 32bit pointer (and boot.c code is
only compiled in 32bit mode), so avoid using the "_g" suffix on the
pointer.

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>
---
 src/boot.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/boot.c b/src/boot.c
index 59623fb..83d48f2 100644
--- a/src/boot.c
+++ b/src/boot.c
@@ -372,24 +372,24 @@ boot_add_bcv(u16 seg, u16 ip, u16 desc, int prio)
 }
 
 void
-boot_add_floppy(struct drive_s *drive_g, const char *desc, int prio)
+boot_add_floppy(struct drive_s *drive, const char *desc, int prio)
 {
     bootentry_add(IPL_TYPE_FLOPPY, defPrio(prio, DefaultFloppyPrio)
-                  , (u32)drive_g, desc);
+                  , (u32)drive, desc);
 }
 
 void
-boot_add_hd(struct drive_s *drive_g, const char *desc, int prio)
+boot_add_hd(struct drive_s *drive, const char *desc, int prio)
 {
     bootentry_add(IPL_TYPE_HARDDISK, defPrio(prio, DefaultHDPrio)
-                  , (u32)drive_g, desc);
+                  , (u32)drive, desc);
 }
 
 void
-boot_add_cd(struct drive_s *drive_g, const char *desc, int prio)
+boot_add_cd(struct drive_s *drive, const char *desc, int prio)
 {
     bootentry_add(IPL_TYPE_CDROM, defPrio(prio, DefaultCDPrio)
-                  , (u32)drive_g, desc);
+                  , (u32)drive, desc);
 }
 
 // Add a CBFS payload entry
@@ -648,13 +648,13 @@ boot_disk(u8 bootdrv, int checksig)
 
 // Boot from a CD-ROM
 static void
-boot_cdrom(struct drive_s *drive_g)
+boot_cdrom(struct drive_s *drive)
 {
     if (! CONFIG_CDROM_BOOT)
         return;
     printf("Booting from DVD/CD...\n");
 
-    int status = cdrom_boot(drive_g);
+    int status = cdrom_boot(drive);
     if (status) {
         printf("Boot failed: Could not read from CDROM (code %04x)\n", status);
         return;
-- 
2.9.4


_______________________________________________
SeaBIOS mailing list
SeaBIOS@seabios.org
https://mail.coreboot.org/mailman/listinfo/seabios
[SeaBIOS] [PATCH 2/4] disk: Don't require the 'struct drive_s' to be in the f-segment
Posted by Kevin O'Connor, 10 weeks ago
Allow the 'struct drive_s' drive description structure to be in either
the "low" memory segment or the f-segment.

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>
---
 src/block.c       | 22 +++++++++++-----------
 src/disk.c        | 10 +++++-----
 src/hw/blockcmd.c |  4 ++--
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/block.c b/src/block.c
index d104f6d..8c5fb2d 100644
--- a/src/block.c
+++ b/src/block.c
@@ -312,12 +312,12 @@ fill_generic_edd(struct segoff_s edd, struct drive_s *drive_gf
 
     // EDD 1.x
 
-    u8  type    = GET_GLOBALFLAT(drive_gf->type);
-    u16 npc     = GET_GLOBALFLAT(drive_gf->pchs.cylinder);
-    u16 nph     = GET_GLOBALFLAT(drive_gf->pchs.head);
-    u16 nps     = GET_GLOBALFLAT(drive_gf->pchs.sector);
-    u64 lba     = GET_GLOBALFLAT(drive_gf->sectors);
-    u16 blksize = GET_GLOBALFLAT(drive_gf->blksize);
+    u8  type    = GET_FLATPTR(drive_gf->type);
+    u16 npc     = GET_FLATPTR(drive_gf->pchs.cylinder);
+    u16 nph     = GET_FLATPTR(drive_gf->pchs.head);
+    u16 nps     = GET_FLATPTR(drive_gf->pchs.sector);
+    u64 lba     = GET_FLATPTR(drive_gf->sectors);
+    u16 blksize = GET_FLATPTR(drive_gf->blksize);
 
     dprintf(DEBUG_HDL_13, "disk_1348 size=%d t=%d chs=%d,%d,%d lba=%d bs=%d\n"
             , size, type, npc, nph, nps, (u32)lba, blksize);
@@ -469,7 +469,7 @@ fill_ata_edd(struct segoff_s edd, struct drive_s *drive_gf)
 int noinline
 fill_edd(struct segoff_s edd, struct drive_s *drive_gf)
 {
-    switch (GET_GLOBALFLAT(drive_gf->type)) {
+    switch (GET_FLATPTR(drive_gf->type)) {
     case DTYPE_ATA:
     case DTYPE_ATA_ATAPI:
         return fill_ata_edd(edd, drive_gf);
@@ -477,7 +477,7 @@ fill_edd(struct segoff_s edd, struct drive_s *drive_gf)
     case DTYPE_VIRTIO_SCSI:
         return fill_generic_edd(
             edd, drive_gf, 0xffffffff, EDD_PCI | EDD_SCSI
-            , edd_pci_path(GET_GLOBALFLAT(drive_gf->cntl_id), 0), 0);
+            , edd_pci_path(GET_FLATPTR(drive_gf->cntl_id), 0), 0);
     default:
         return fill_generic_edd(edd, drive_gf, 0, 0, 0, 0);
     }
@@ -527,7 +527,7 @@ default_process_op(struct disk_op_s *op)
 static int
 process_op_both(struct disk_op_s *op)
 {
-    switch (GET_GLOBALFLAT(op->drive_gf->type)) {
+    switch (GET_FLATPTR(op->drive_gf->type)) {
     case DTYPE_ATA_ATAPI:
         return ata_atapi_process_op(op);
     case DTYPE_USB:
@@ -585,7 +585,7 @@ static int
 process_op_16(struct disk_op_s *op)
 {
     ASSERT16();
-    switch (GET_GLOBALFLAT(op->drive_gf->type)) {
+    switch (GET_FLATPTR(op->drive_gf->type)) {
     case DTYPE_FLOPPY:
         return floppy_process_op(op);
     case DTYPE_ATA:
@@ -608,7 +608,7 @@ process_op(struct disk_op_s *op)
             , op->count, op->command);
 
     int ret, origcount = op->count;
-    if (origcount * GET_GLOBALFLAT(op->drive_gf->blksize) > 64*1024) {
+    if (origcount * GET_FLATPTR(op->drive_gf->blksize) > 64*1024) {
         op->count = 0;
         return DISK_RET_EBOUNDARY;
     }
diff --git a/src/disk.c b/src/disk.c
index 6e58428..5a4fe9d 100644
--- a/src/disk.c
+++ b/src/disk.c
@@ -81,9 +81,9 @@ getLCHS(struct drive_s *drive_gf)
         res.sector = sptcyl & 0x3f;
         return res;
     }
-    res.cylinder = GET_GLOBALFLAT(drive_gf->lchs.cylinder);
-    res.head = GET_GLOBALFLAT(drive_gf->lchs.head);
-    res.sector = GET_GLOBALFLAT(drive_gf->lchs.sector);
+    res.cylinder = GET_FLATPTR(drive_gf->lchs.cylinder);
+    res.head = GET_FLATPTR(drive_gf->lchs.head);
+    res.sector = GET_FLATPTR(drive_gf->lchs.sector);
     return res;
 }
 
@@ -168,7 +168,7 @@ extended_access(struct bregs *regs, struct drive_s *drive_gf, u16 command)
     dop.lba = GET_FARVAR(regs->ds, param_far->lba);
     dop.command = command;
     dop.drive_gf = drive_gf;
-    if (dop.lba >= GET_GLOBALFLAT(drive_gf->sectors)) {
+    if (dop.lba >= GET_FLATPTR(drive_gf->sectors)) {
         warn_invalid(regs);
         disk_ret(regs, DISK_RET_EPARAM);
         return;
@@ -287,7 +287,7 @@ disk_1308(struct bregs *regs, struct drive_s *drive_gf)
         if (CONFIG_CDROM_EMU && drive_gf == GET_GLOBAL(cdemu_drive_gf))
             regs->bx = GET_LOW(CDEmu.media) * 2;
         else
-            regs->bx = GET_GLOBALFLAT(drive_gf->floppy_type);
+            regs->bx = GET_FLATPTR(drive_gf->floppy_type);
 
         // set es & di to point to 11 byte diskette param table in ROM
         regs->es = SEG_BIOS;
diff --git a/src/hw/blockcmd.c b/src/hw/blockcmd.c
index 98c06ce..f260dd8 100644
--- a/src/hw/blockcmd.c
+++ b/src/hw/blockcmd.c
@@ -5,10 +5,10 @@
 //
 // This file may be distributed under the terms of the GNU LGPLv3 license.
 
-#include "biosvar.h" // GET_GLOBALFLAT
 #include "block.h" // struct disk_op_s
 #include "blockcmd.h" // struct cdb_request_sense
 #include "byteorder.h" // be32_to_cpu
+#include "farptr.h" // GET_FLATPTR
 #include "output.h" // dprintf
 #include "std/disk.h" // DISK_RET_EPARAM
 #include "string.h" // memset
@@ -117,7 +117,7 @@ scsi_fill_cmd(struct disk_op_s *op, void *cdbcmd, int maxcdb)
                         : CDB_CMD_WRITE_10);
         cmd->lba = cpu_to_be32(op->lba);
         cmd->count = cpu_to_be16(op->count);
-        return GET_GLOBALFLAT(op->drive_gf->blksize);
+        return GET_FLATPTR(op->drive_gf->blksize);
     case CMD_SCSI:
         if (MODESEGMENT)
             return -1;
-- 
2.9.4


_______________________________________________
SeaBIOS mailing list
SeaBIOS@seabios.org
https://mail.coreboot.org/mailman/listinfo/seabios
[SeaBIOS] [PATCH 3/4] block: Rename disk_op_s->drive_gf to drive_fl
Posted by Kevin O'Connor, 10 weeks ago
Now that the drive_s struct does not need to be in the f-segment,
rename references to drive_gf in the generic drive code to drive_fl.

This is just variable renames - no code changes.

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>
---
 src/block.c          |  36 ++++-----
 src/block.h          |   2 +-
 src/cdrom.c          |   6 +-
 src/disk.c           | 218 +++++++++++++++++++++++++--------------------------
 src/hw/ahci.c        |   4 +-
 src/hw/ata.c         |  26 +++---
 src/hw/blockcmd.c    |   8 +-
 src/hw/esp-scsi.c    |   2 +-
 src/hw/floppy.c      |  20 ++---
 src/hw/lsi-scsi.c    |   2 +-
 src/hw/megasas.c     |   2 +-
 src/hw/mpt-scsi.c    |   2 +-
 src/hw/nvme.c        |   2 +-
 src/hw/pvscsi.c      |   2 +-
 src/hw/ramdisk.c     |   2 +-
 src/hw/sdcard.c      |   2 +-
 src/hw/usb-msc.c     |   4 +-
 src/hw/usb-uas.c     |   2 +-
 src/hw/virtio-blk.c  |   2 +-
 src/hw/virtio-scsi.c |   2 +-
 20 files changed, 173 insertions(+), 173 deletions(-)

diff --git a/src/block.c b/src/block.c
index 8c5fb2d..f73ec18 100644
--- a/src/block.c
+++ b/src/block.c
@@ -298,7 +298,7 @@ map_floppy_drive(struct drive_s *drive)
 
 // Fill in EDD info
 static int
-fill_generic_edd(struct segoff_s edd, struct drive_s *drive_gf
+fill_generic_edd(struct segoff_s edd, struct drive_s *drive_fl
                  , u32 dpte_so, u8 bus_iface, u32 iface_path, u32 device_path)
 {
     u16 seg = edd.seg;
@@ -312,12 +312,12 @@ fill_generic_edd(struct segoff_s edd, struct drive_s *drive_gf
 
     // EDD 1.x
 
-    u8  type    = GET_FLATPTR(drive_gf->type);
-    u16 npc     = GET_FLATPTR(drive_gf->pchs.cylinder);
-    u16 nph     = GET_FLATPTR(drive_gf->pchs.head);
-    u16 nps     = GET_FLATPTR(drive_gf->pchs.sector);
-    u64 lba     = GET_FLATPTR(drive_gf->sectors);
-    u16 blksize = GET_FLATPTR(drive_gf->blksize);
+    u8  type    = GET_FLATPTR(drive_fl->type);
+    u16 npc     = GET_FLATPTR(drive_fl->pchs.cylinder);
+    u16 nph     = GET_FLATPTR(drive_fl->pchs.head);
+    u16 nps     = GET_FLATPTR(drive_fl->pchs.sector);
+    u64 lba     = GET_FLATPTR(drive_fl->sectors);
+    u16 blksize = GET_FLATPTR(drive_fl->blksize);
 
     dprintf(DEBUG_HDL_13, "disk_1348 size=%d t=%d chs=%d,%d,%d lba=%d bs=%d\n"
             , size, type, npc, nph, nps, (u32)lba, blksize);
@@ -467,19 +467,19 @@ fill_ata_edd(struct segoff_s edd, struct drive_s *drive_gf)
 
 // Fill Extended Disk Drive (EDD) "Get drive parameters" info for a drive
 int noinline
-fill_edd(struct segoff_s edd, struct drive_s *drive_gf)
+fill_edd(struct segoff_s edd, struct drive_s *drive_fl)
 {
-    switch (GET_FLATPTR(drive_gf->type)) {
+    switch (GET_FLATPTR(drive_fl->type)) {
     case DTYPE_ATA:
     case DTYPE_ATA_ATAPI:
-        return fill_ata_edd(edd, drive_gf);
+        return fill_ata_edd(edd, drive_fl);
     case DTYPE_VIRTIO_BLK:
     case DTYPE_VIRTIO_SCSI:
         return fill_generic_edd(
-            edd, drive_gf, 0xffffffff, EDD_PCI | EDD_SCSI
-            , edd_pci_path(GET_FLATPTR(drive_gf->cntl_id), 0), 0);
+            edd, drive_fl, 0xffffffff, EDD_PCI | EDD_SCSI
+            , edd_pci_path(GET_FLATPTR(drive_fl->cntl_id), 0), 0);
     default:
-        return fill_generic_edd(edd, drive_gf, 0, 0, 0, 0);
+        return fill_generic_edd(edd, drive_fl, 0, 0, 0, 0);
     }
 }
 
@@ -527,7 +527,7 @@ default_process_op(struct disk_op_s *op)
 static int
 process_op_both(struct disk_op_s *op)
 {
-    switch (GET_FLATPTR(op->drive_gf->type)) {
+    switch (GET_FLATPTR(op->drive_fl->type)) {
     case DTYPE_ATA_ATAPI:
         return ata_atapi_process_op(op);
     case DTYPE_USB:
@@ -556,7 +556,7 @@ int VISIBLE32FLAT
 process_op_32(struct disk_op_s *op)
 {
     ASSERT32FLAT();
-    switch (op->drive_gf->type) {
+    switch (op->drive_fl->type) {
     case DTYPE_VIRTIO_BLK:
         return virtio_blk_process_op(op);
     case DTYPE_AHCI:
@@ -585,7 +585,7 @@ static int
 process_op_16(struct disk_op_s *op)
 {
     ASSERT16();
-    switch (GET_FLATPTR(op->drive_gf->type)) {
+    switch (GET_FLATPTR(op->drive_fl->type)) {
     case DTYPE_FLOPPY:
         return floppy_process_op(op);
     case DTYPE_ATA:
@@ -604,11 +604,11 @@ int
 process_op(struct disk_op_s *op)
 {
     dprintf(DEBUG_HDL_13, "disk_op d=%p lba=%d buf=%p count=%d cmd=%d\n"
-            , op->drive_gf, (u32)op->lba, op->buf_fl
+            , op->drive_fl, (u32)op->lba, op->buf_fl
             , op->count, op->command);
 
     int ret, origcount = op->count;
-    if (origcount * GET_FLATPTR(op->drive_gf->blksize) > 64*1024) {
+    if (origcount * GET_FLATPTR(op->drive_fl->blksize) > 64*1024) {
         op->count = 0;
         return DISK_RET_EBOUNDARY;
     }
diff --git a/src/block.h b/src/block.h
index f03ec38..a380f16 100644
--- a/src/block.h
+++ b/src/block.h
@@ -10,7 +10,7 @@
 
 struct disk_op_s {
     void *buf_fl;
-    struct drive_s *drive_gf;
+    struct drive_s *drive_fl;
     u8 command;
     u16 count;
     union {
diff --git a/src/cdrom.c b/src/cdrom.c
index a4f31ad..828fb3b 100644
--- a/src/cdrom.c
+++ b/src/cdrom.c
@@ -31,7 +31,7 @@ cdemu_read(struct disk_op_s *op)
 {
     struct drive_s *drive_gf = GET_LOW(emulated_drive_gf);
     struct disk_op_s dop;
-    dop.drive_gf = drive_gf;
+    dop.drive_fl = drive_gf;
     dop.command = op->command;
     dop.lba = GET_LOW(CDEmu.ilba) + op->lba / 4;
 
@@ -136,8 +136,8 @@ cdrom_boot(struct drive_s *drive)
     struct disk_op_s dop;
     int cdid = getDriveId(EXTTYPE_CD, drive);
     memset(&dop, 0, sizeof(dop));
-    dop.drive_gf = drive;
-    if (!dop.drive_gf || cdid < 0)
+    dop.drive_fl = drive;
+    if (!dop.drive_fl || cdid < 0)
         return 1;
 
     int ret = scsi_is_ready(&dop);
diff --git a/src/disk.c b/src/disk.c
index 5a4fe9d..0328fbd 100644
--- a/src/disk.c
+++ b/src/disk.c
@@ -67,10 +67,10 @@ __disk_stub(struct bregs *regs, int lineno, const char *fname)
 
 // Get the cylinders/heads/sectors for the given drive.
 static struct chs_s
-getLCHS(struct drive_s *drive_gf)
+getLCHS(struct drive_s *drive_fl)
 {
     struct chs_s res = { };
-    if (CONFIG_CDROM_EMU && drive_gf == GET_GLOBAL(cdemu_drive_gf)) {
+    if (CONFIG_CDROM_EMU && drive_fl == GET_GLOBAL(cdemu_drive_gf)) {
         // Emulated drive - get info from CDEmu.  (It's not possible to
         // populate the geometry directly in the driveid because the
         // geometry is only known after the bios segment is made
@@ -81,9 +81,9 @@ getLCHS(struct drive_s *drive_gf)
         res.sector = sptcyl & 0x3f;
         return res;
     }
-    res.cylinder = GET_FLATPTR(drive_gf->lchs.cylinder);
-    res.head = GET_FLATPTR(drive_gf->lchs.head);
-    res.sector = GET_FLATPTR(drive_gf->lchs.sector);
+    res.cylinder = GET_FLATPTR(drive_fl->lchs.cylinder);
+    res.head = GET_FLATPTR(drive_fl->lchs.head);
+    res.sector = GET_FLATPTR(drive_fl->lchs.sector);
     return res;
 }
 
@@ -117,10 +117,10 @@ send_disk_op(struct disk_op_s *op)
 
 // Perform read/write/verify using old-style chs accesses
 static void noinline
-basic_access(struct bregs *regs, struct drive_s *drive_gf, u16 command)
+basic_access(struct bregs *regs, struct drive_s *drive_fl, u16 command)
 {
     struct disk_op_s dop;
-    dop.drive_gf = drive_gf;
+    dop.drive_fl = drive_fl;
     dop.command = command;
 
     u8 count = regs->al;
@@ -135,7 +135,7 @@ basic_access(struct bregs *regs, struct drive_s *drive_gf, u16 command)
     }
     dop.count = count;
 
-    struct chs_s chs = getLCHS(drive_gf);
+    struct chs_s chs = getLCHS(drive_fl);
     u16 nlc=chs.cylinder, nlh=chs.head, nls=chs.sector;
 
     // sanity check on cyl heads, sec
@@ -160,15 +160,15 @@ basic_access(struct bregs *regs, struct drive_s *drive_gf, u16 command)
 
 // Perform read/write/verify using new-style "int13ext" accesses.
 static void noinline
-extended_access(struct bregs *regs, struct drive_s *drive_gf, u16 command)
+extended_access(struct bregs *regs, struct drive_s *drive_fl, u16 command)
 {
     struct disk_op_s dop;
     struct int13ext_s *param_far = (struct int13ext_s*)(regs->si+0);
     // Get lba and check.
     dop.lba = GET_FARVAR(regs->ds, param_far->lba);
     dop.command = command;
-    dop.drive_gf = drive_gf;
-    if (dop.lba >= GET_FLATPTR(drive_gf->sectors)) {
+    dop.drive_fl = drive_fl;
+    if (dop.lba >= GET_FLATPTR(drive_fl->sectors)) {
         warn_invalid(regs);
         disk_ret(regs, DISK_RET_EPARAM);
         return;
@@ -196,10 +196,10 @@ extended_access(struct bregs *regs, struct drive_s *drive_gf, u16 command)
 
 // disk controller reset
 static void
-disk_1300(struct bregs *regs, struct drive_s *drive_gf)
+disk_1300(struct bregs *regs, struct drive_s *drive_fl)
 {
     struct disk_op_s dop;
-    dop.drive_gf = drive_gf;
+    dop.drive_fl = drive_fl;
     dop.command = CMD_RESET;
     dop.count = 0;
     int status = send_disk_op(&dop);
@@ -208,7 +208,7 @@ disk_1300(struct bregs *regs, struct drive_s *drive_gf)
 
 // read disk status
 static void
-disk_1301(struct bregs *regs, struct drive_s *drive_gf)
+disk_1301(struct bregs *regs, struct drive_s *drive_fl)
 {
     u8 v;
     if (regs->dl < EXTSTART_HD)
@@ -223,32 +223,32 @@ disk_1301(struct bregs *regs, struct drive_s *drive_gf)
 
 // read disk sectors
 static void
-disk_1302(struct bregs *regs, struct drive_s *drive_gf)
+disk_1302(struct bregs *regs, struct drive_s *drive_fl)
 {
-    basic_access(regs, drive_gf, CMD_READ);
+    basic_access(regs, drive_fl, CMD_READ);
 }
 
 // write disk sectors
 static void
-disk_1303(struct bregs *regs, struct drive_s *drive_gf)
+disk_1303(struct bregs *regs, struct drive_s *drive_fl)
 {
-    basic_access(regs, drive_gf, CMD_WRITE);
+    basic_access(regs, drive_fl, CMD_WRITE);
 }
 
 // verify disk sectors
 static void
-disk_1304(struct bregs *regs, struct drive_s *drive_gf)
+disk_1304(struct bregs *regs, struct drive_s *drive_fl)
 {
-    basic_access(regs, drive_gf, CMD_VERIFY);
+    basic_access(regs, drive_fl, CMD_VERIFY);
 }
 
 // format disk track
 static void noinline
-disk_1305(struct bregs *regs, struct drive_s *drive_gf)
+disk_1305(struct bregs *regs, struct drive_s *drive_fl)
 {
     debug_stub(regs);
 
-    struct chs_s chs = getLCHS(drive_gf);
+    struct chs_s chs = getLCHS(drive_fl);
     u16 nlc=chs.cylinder, nlh=chs.head, nls=chs.sector;
 
     u8 count = regs->al;
@@ -261,7 +261,7 @@ disk_1305(struct bregs *regs, struct drive_s *drive_gf)
     }
 
     struct disk_op_s dop;
-    dop.drive_gf = drive_gf;
+    dop.drive_fl = drive_fl;
     dop.command = CMD_FORMAT;
     dop.lba = (((u32)cylinder * (u32)nlh) + (u32)head) * (u32)nls;
     dop.count = count;
@@ -272,10 +272,10 @@ disk_1305(struct bregs *regs, struct drive_s *drive_gf)
 
 // read disk drive parameters
 static void noinline
-disk_1308(struct bregs *regs, struct drive_s *drive_gf)
+disk_1308(struct bregs *regs, struct drive_s *drive_fl)
 {
     // Get logical geometry from table
-    struct chs_s chs = getLCHS(drive_gf);
+    struct chs_s chs = getLCHS(drive_fl);
     u16 nlc=chs.cylinder, nlh=chs.head, nls=chs.sector;
     nlc--;
     nlh--;
@@ -284,10 +284,10 @@ disk_1308(struct bregs *regs, struct drive_s *drive_gf)
         // Floppy
         count = GET_GLOBAL(FloppyCount);
 
-        if (CONFIG_CDROM_EMU && drive_gf == GET_GLOBAL(cdemu_drive_gf))
+        if (CONFIG_CDROM_EMU && drive_fl == GET_GLOBAL(cdemu_drive_gf))
             regs->bx = GET_LOW(CDEmu.media) * 2;
         else
-            regs->bx = GET_FLATPTR(drive_gf->floppy_type);
+            regs->bx = GET_FLATPTR(drive_fl->floppy_type);
 
         // set es & di to point to 11 byte diskette param table in ROM
         regs->es = SEG_BIOS;
@@ -323,33 +323,33 @@ disk_1308(struct bregs *regs, struct drive_s *drive_gf)
 
 // initialize drive parameters
 static void
-disk_1309(struct bregs *regs, struct drive_s *drive_gf)
+disk_1309(struct bregs *regs, struct drive_s *drive_fl)
 {
     DISK_STUB(regs);
 }
 
 // seek to specified cylinder
 static void
-disk_130c(struct bregs *regs, struct drive_s *drive_gf)
+disk_130c(struct bregs *regs, struct drive_s *drive_fl)
 {
     DISK_STUB(regs);
 }
 
 // alternate disk reset
 static void
-disk_130d(struct bregs *regs, struct drive_s *drive_gf)
+disk_130d(struct bregs *regs, struct drive_s *drive_fl)
 {
     DISK_STUB(regs);
 }
 
 // check drive ready
 static void
-disk_1310(struct bregs *regs, struct drive_s *drive_gf)
+disk_1310(struct bregs *regs, struct drive_s *drive_fl)
 {
     // should look at 40:8E also???
 
     struct disk_op_s dop;
-    dop.drive_gf = drive_gf;
+    dop.drive_fl = drive_fl;
     dop.command = CMD_ISREADY;
     dop.count = 0;
     int status = send_disk_op(&dop);
@@ -358,21 +358,21 @@ disk_1310(struct bregs *regs, struct drive_s *drive_gf)
 
 // recalibrate
 static void
-disk_1311(struct bregs *regs, struct drive_s *drive_gf)
+disk_1311(struct bregs *regs, struct drive_s *drive_fl)
 {
     DISK_STUB(regs);
 }
 
 // controller internal diagnostic
 static void
-disk_1314(struct bregs *regs, struct drive_s *drive_gf)
+disk_1314(struct bregs *regs, struct drive_s *drive_fl)
 {
     DISK_STUB(regs);
 }
 
 // read disk drive size
 static void noinline
-disk_1315(struct bregs *regs, struct drive_s *drive_gf)
+disk_1315(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret(regs, DISK_RET_SUCCESS);
     if (regs->dl < EXTSTART_HD || regs->dl >= EXTSTART_CD) {
@@ -383,7 +383,7 @@ disk_1315(struct bregs *regs, struct drive_s *drive_gf)
     // Hard drive
 
     // Get logical geometry from table
-    struct chs_s chs = getLCHS(drive_gf);
+    struct chs_s chs = getLCHS(drive_fl);
     u16 nlc=chs.cylinder, nlh=chs.head, nls=chs.sector;
 
     // Compute sector count seen by int13
@@ -394,7 +394,7 @@ disk_1315(struct bregs *regs, struct drive_s *drive_gf)
 }
 
 static void
-disk_1316(struct bregs *regs, struct drive_s *drive_gf)
+disk_1316(struct bregs *regs, struct drive_s *drive_fl)
 {
     if (regs->dl >= EXTSTART_HD) {
         // Hard drive
@@ -406,7 +406,7 @@ disk_1316(struct bregs *regs, struct drive_s *drive_gf)
 
 // IBM/MS installation check
 static void
-disk_1341(struct bregs *regs, struct drive_s *drive_gf)
+disk_1341(struct bregs *regs, struct drive_s *drive_fl)
 {
     regs->bx = 0xaa55;  // install check
     regs->cx = 0x0007;  // ext disk access and edd, removable supported
@@ -416,23 +416,23 @@ disk_1341(struct bregs *regs, struct drive_s *drive_gf)
 
 // IBM/MS extended read
 static void
-disk_1342(struct bregs *regs, struct drive_s *drive_gf)
+disk_1342(struct bregs *regs, struct drive_s *drive_fl)
 {
-    extended_access(regs, drive_gf, CMD_READ);
+    extended_access(regs, drive_fl, CMD_READ);
 }
 
 // IBM/MS extended write
 static void
-disk_1343(struct bregs *regs, struct drive_s *drive_gf)
+disk_1343(struct bregs *regs, struct drive_s *drive_fl)
 {
-    extended_access(regs, drive_gf, CMD_WRITE);
+    extended_access(regs, drive_fl, CMD_WRITE);
 }
 
 // IBM/MS verify
 static void
-disk_1344(struct bregs *regs, struct drive_s *drive_gf)
+disk_1344(struct bregs *regs, struct drive_s *drive_fl)
 {
-    extended_access(regs, drive_gf, CMD_VERIFY);
+    extended_access(regs, drive_fl, CMD_VERIFY);
 }
 
 // Locks for removable devices
@@ -440,7 +440,7 @@ u8 CDRom_locks[BUILD_MAX_EXTDRIVE] VARLOW;
 
 // lock
 static void
-disk_134500(struct bregs *regs, struct drive_s *drive_gf)
+disk_134500(struct bregs *regs, struct drive_s *drive_fl)
 {
     int cdid = regs->dl - EXTSTART_CD;
     u8 locks = GET_LOW(CDRom_locks[cdid]);
@@ -456,7 +456,7 @@ disk_134500(struct bregs *regs, struct drive_s *drive_gf)
 
 // unlock
 static void
-disk_134501(struct bregs *regs, struct drive_s *drive_gf)
+disk_134501(struct bregs *regs, struct drive_s *drive_fl)
 {
     int cdid = regs->dl - EXTSTART_CD;
     u8 locks = GET_LOW(CDRom_locks[cdid]);
@@ -473,7 +473,7 @@ disk_134501(struct bregs *regs, struct drive_s *drive_gf)
 
 // status
 static void
-disk_134502(struct bregs *regs, struct drive_s *drive_gf)
+disk_134502(struct bregs *regs, struct drive_s *drive_fl)
 {
     int cdid = regs->dl - EXTSTART_CD;
     u8 locks = GET_LOW(CDRom_locks[cdid]);
@@ -482,14 +482,14 @@ disk_134502(struct bregs *regs, struct drive_s *drive_gf)
 }
 
 static void
-disk_1345XX(struct bregs *regs, struct drive_s *drive_gf)
+disk_1345XX(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret_unimplemented(regs, DISK_RET_EPARAM);
 }
 
 // IBM/MS lock/unlock drive
 static void
-disk_1345(struct bregs *regs, struct drive_s *drive_gf)
+disk_1345(struct bregs *regs, struct drive_s *drive_fl)
 {
     if (regs->dl < EXTSTART_CD) {
         // Always success for HD
@@ -498,16 +498,16 @@ disk_1345(struct bregs *regs, struct drive_s *drive_gf)
     }
 
     switch (regs->al) {
-    case 0x00: disk_134500(regs, drive_gf); break;
-    case 0x01: disk_134501(regs, drive_gf); break;
-    case 0x02: disk_134502(regs, drive_gf); break;
-    default:   disk_1345XX(regs, drive_gf); break;
+    case 0x00: disk_134500(regs, drive_fl); break;
+    case 0x01: disk_134501(regs, drive_fl); break;
+    case 0x02: disk_134502(regs, drive_fl); break;
+    default:   disk_1345XX(regs, drive_fl); break;
     }
 }
 
 // IBM/MS eject media
 static void noinline
-disk_1346(struct bregs *regs, struct drive_s *drive_gf)
+disk_1346(struct bregs *regs, struct drive_s *drive_fl)
 {
     if (regs->dl < EXTSTART_CD) {
         // Volume Not Removable
@@ -541,22 +541,22 @@ disk_1346(struct bregs *regs, struct drive_s *drive_gf)
 
 // IBM/MS extended seek
 static void
-disk_1347(struct bregs *regs, struct drive_s *drive_gf)
+disk_1347(struct bregs *regs, struct drive_s *drive_fl)
 {
-    extended_access(regs, drive_gf, CMD_SEEK);
+    extended_access(regs, drive_fl, CMD_SEEK);
 }
 
 // IBM/MS get drive parameters
 static void
-disk_1348(struct bregs *regs, struct drive_s *drive_gf)
+disk_1348(struct bregs *regs, struct drive_s *drive_fl)
 {
-    int ret = fill_edd(SEGOFF(regs->ds, regs->si), drive_gf);
+    int ret = fill_edd(SEGOFF(regs->ds, regs->si), drive_fl);
     disk_ret(regs, ret);
 }
 
 // IBM/MS extended media change
 static void
-disk_1349(struct bregs *regs, struct drive_s *drive_gf)
+disk_1349(struct bregs *regs, struct drive_s *drive_fl)
 {
     if (regs->dl < EXTSTART_CD) {
         // Always success for HD
@@ -569,56 +569,56 @@ disk_1349(struct bregs *regs, struct drive_s *drive_gf)
 }
 
 static void
-disk_134e01(struct bregs *regs, struct drive_s *drive_gf)
+disk_134e01(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret(regs, DISK_RET_SUCCESS);
 }
 
 static void
-disk_134e03(struct bregs *regs, struct drive_s *drive_gf)
+disk_134e03(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret(regs, DISK_RET_SUCCESS);
 }
 
 static void
-disk_134e04(struct bregs *regs, struct drive_s *drive_gf)
+disk_134e04(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret(regs, DISK_RET_SUCCESS);
 }
 
 static void
-disk_134e06(struct bregs *regs, struct drive_s *drive_gf)
+disk_134e06(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret(regs, DISK_RET_SUCCESS);
 }
 
 static void
-disk_134eXX(struct bregs *regs, struct drive_s *drive_gf)
+disk_134eXX(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret(regs, DISK_RET_EPARAM);
 }
 
 // IBM/MS set hardware configuration
 static void
-disk_134e(struct bregs *regs, struct drive_s *drive_gf)
+disk_134e(struct bregs *regs, struct drive_s *drive_fl)
 {
     switch (regs->al) {
-    case 0x01: disk_134e01(regs, drive_gf); break;
-    case 0x03: disk_134e03(regs, drive_gf); break;
-    case 0x04: disk_134e04(regs, drive_gf); break;
-    case 0x06: disk_134e06(regs, drive_gf); break;
-    default:   disk_134eXX(regs, drive_gf); break;
+    case 0x01: disk_134e01(regs, drive_fl); break;
+    case 0x03: disk_134e03(regs, drive_fl); break;
+    case 0x04: disk_134e04(regs, drive_fl); break;
+    case 0x06: disk_134e06(regs, drive_fl); break;
+    default:   disk_134eXX(regs, drive_fl); break;
     }
 }
 
 static void
-disk_13XX(struct bregs *regs, struct drive_s *drive_gf)
+disk_13XX(struct bregs *regs, struct drive_s *drive_fl)
 {
     disk_ret_unimplemented(regs, DISK_RET_EPARAM);
 }
 
 static void
-disk_13(struct bregs *regs, struct drive_s *drive_gf)
+disk_13(struct bregs *regs, struct drive_s *drive_fl)
 {
     //debug_stub(regs);
 
@@ -626,37 +626,37 @@ disk_13(struct bregs *regs, struct drive_s *drive_gf)
     SET_BDA(disk_interrupt_flag, 0);
 
     switch (regs->ah) {
-    case 0x00: disk_1300(regs, drive_gf); break;
-    case 0x01: disk_1301(regs, drive_gf); break;
-    case 0x02: disk_1302(regs, drive_gf); break;
-    case 0x03: disk_1303(regs, drive_gf); break;
-    case 0x04: disk_1304(regs, drive_gf); break;
-    case 0x05: disk_1305(regs, drive_gf); break;
-    case 0x08: disk_1308(regs, drive_gf); break;
-    case 0x09: disk_1309(regs, drive_gf); break;
-    case 0x0c: disk_130c(regs, drive_gf); break;
-    case 0x0d: disk_130d(regs, drive_gf); break;
-    case 0x10: disk_1310(regs, drive_gf); break;
-    case 0x11: disk_1311(regs, drive_gf); break;
-    case 0x14: disk_1314(regs, drive_gf); break;
-    case 0x15: disk_1315(regs, drive_gf); break;
-    case 0x16: disk_1316(regs, drive_gf); break;
-    case 0x41: disk_1341(regs, drive_gf); break;
-    case 0x42: disk_1342(regs, drive_gf); break;
-    case 0x43: disk_1343(regs, drive_gf); break;
-    case 0x44: disk_1344(regs, drive_gf); break;
-    case 0x45: disk_1345(regs, drive_gf); break;
-    case 0x46: disk_1346(regs, drive_gf); break;
-    case 0x47: disk_1347(regs, drive_gf); break;
-    case 0x48: disk_1348(regs, drive_gf); break;
-    case 0x49: disk_1349(regs, drive_gf); break;
-    case 0x4e: disk_134e(regs, drive_gf); break;
-    default:   disk_13XX(regs, drive_gf); break;
+    case 0x00: disk_1300(regs, drive_fl); break;
+    case 0x01: disk_1301(regs, drive_fl); break;
+    case 0x02: disk_1302(regs, drive_fl); break;
+    case 0x03: disk_1303(regs, drive_fl); break;
+    case 0x04: disk_1304(regs, drive_fl); break;
+    case 0x05: disk_1305(regs, drive_fl); break;
+    case 0x08: disk_1308(regs, drive_fl); break;
+    case 0x09: disk_1309(regs, drive_fl); break;
+    case 0x0c: disk_130c(regs, drive_fl); break;
+    case 0x0d: disk_130d(regs, drive_fl); break;
+    case 0x10: disk_1310(regs, drive_fl); break;
+    case 0x11: disk_1311(regs, drive_fl); break;
+    case 0x14: disk_1314(regs, drive_fl); break;
+    case 0x15: disk_1315(regs, drive_fl); break;
+    case 0x16: disk_1316(regs, drive_fl); break;
+    case 0x41: disk_1341(regs, drive_fl); break;
+    case 0x42: disk_1342(regs, drive_fl); break;
+    case 0x43: disk_1343(regs, drive_fl); break;
+    case 0x44: disk_1344(regs, drive_fl); break;
+    case 0x45: disk_1345(regs, drive_fl); break;
+    case 0x46: disk_1346(regs, drive_fl); break;
+    case 0x47: disk_1347(regs, drive_fl); break;
+    case 0x48: disk_1348(regs, drive_fl); break;
+    case 0x49: disk_1349(regs, drive_fl); break;
+    case 0x4e: disk_134e(regs, drive_fl); break;
+    default:   disk_13XX(regs, drive_fl); break;
     }
 }
 
 static void
-floppy_13(struct bregs *regs, struct drive_s *drive_gf)
+floppy_13(struct bregs *regs, struct drive_s *drive_fl)
 {
     // Only limited commands are supported on floppies.
     switch (regs->ah) {
@@ -669,9 +669,9 @@ floppy_13(struct bregs *regs, struct drive_s *drive_gf)
     case 0x08:
     case 0x15:
     case 0x16:
-        disk_13(regs, drive_gf);
+        disk_13(regs, drive_fl);
         break;
-    default:   disk_13XX(regs, drive_gf); break;
+    default:   disk_13XX(regs, drive_fl); break;
     }
 }
 
@@ -707,21 +707,21 @@ handle_legacy_disk(struct bregs *regs, u8 extdrive)
     }
 
     if (extdrive < EXTSTART_HD) {
-        struct drive_s *drive_gf = getDrive(EXTTYPE_FLOPPY, extdrive);
-        if (!drive_gf)
+        struct drive_s *drive_fl = getDrive(EXTTYPE_FLOPPY, extdrive);
+        if (!drive_fl)
             goto fail;
-        floppy_13(regs, drive_gf);
+        floppy_13(regs, drive_fl);
         return;
     }
 
-    struct drive_s *drive_gf;
+    struct drive_s *drive_fl;
     if (extdrive >= EXTSTART_CD)
-        drive_gf = getDrive(EXTTYPE_CD, extdrive - EXTSTART_CD);
+        drive_fl = getDrive(EXTTYPE_CD, extdrive - EXTSTART_CD);
     else
-        drive_gf = getDrive(EXTTYPE_HD, extdrive - EXTSTART_HD);
-    if (!drive_gf)
+        drive_fl = getDrive(EXTTYPE_HD, extdrive - EXTSTART_HD);
+    if (!drive_fl)
         goto fail;
-    disk_13(regs, drive_gf);
+    disk_13(regs, drive_fl);
     return;
 
 fail:
diff --git a/src/hw/ahci.c b/src/hw/ahci.c
index b9043b9..1746e7a 100644
--- a/src/hw/ahci.c
+++ b/src/hw/ahci.c
@@ -217,7 +217,7 @@ int ahci_atapi_process_op(struct disk_op_s *op)
         return 0;
 
     struct ahci_port_s *port_gf = container_of(
-        op->drive_gf, struct ahci_port_s, drive);
+        op->drive_fl, struct ahci_port_s, drive);
     struct ahci_cmd_s *cmd = port_gf->cmd;
 
     if (op->command == CMD_WRITE || op->command == CMD_FORMAT)
@@ -237,7 +237,7 @@ static int
 ahci_disk_readwrite_aligned(struct disk_op_s *op, int iswrite)
 {
     struct ahci_port_s *port_gf = container_of(
-        op->drive_gf, struct ahci_port_s, drive);
+        op->drive_fl, struct ahci_port_s, drive);
     struct ahci_cmd_s *cmd = port_gf->cmd;
     int rc;
 
diff --git a/src/hw/ata.c b/src/hw/ata.c
index 9a4b435..b6e073c 100644
--- a/src/hw/ata.c
+++ b/src/hw/ata.c
@@ -271,15 +271,15 @@ fail:
  ****************************************************************/
 
 // Transfer 'op->count' blocks (of 'blocksize' bytes) to/from drive
-// 'op->drive_gf'.
+// 'op->drive_fl'.
 static int
 ata_pio_transfer(struct disk_op_s *op, int iswrite, int blocksize)
 {
     dprintf(16, "ata_pio_transfer id=%p write=%d count=%d bs=%d buf=%p\n"
-            , op->drive_gf, iswrite, op->count, blocksize, op->buf_fl);
+            , op->drive_fl, iswrite, op->count, blocksize, op->buf_fl);
 
     struct atadrive_s *adrive_gf = container_of(
-        op->drive_gf, struct atadrive_s, drive);
+        op->drive_fl, struct atadrive_s, drive);
     struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf);
     u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1);
     u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2);
@@ -289,14 +289,14 @@ ata_pio_transfer(struct disk_op_s *op, int iswrite, int blocksize)
     for (;;) {
         if (iswrite) {
             // Write data to controller
-            dprintf(16, "Write sector id=%p dest=%p\n", op->drive_gf, buf_fl);
+            dprintf(16, "Write sector id=%p dest=%p\n", op->drive_fl, buf_fl);
             if (CONFIG_ATA_PIO32)
                 outsl_fl(iobase1, buf_fl, blocksize / 4);
             else
                 outsw_fl(iobase1, buf_fl, blocksize / 2);
         } else {
             // Read data from controller
-            dprintf(16, "Read sector id=%p dest=%p\n", op->drive_gf, buf_fl);
+            dprintf(16, "Read sector id=%p dest=%p\n", op->drive_fl, buf_fl);
             if (CONFIG_ATA_PIO32)
                 insl_fl(iobase1, buf_fl, blocksize / 4);
             else
@@ -366,7 +366,7 @@ ata_try_dma(struct disk_op_s *op, int iswrite, int blocksize)
         // Need minimum alignment of 1.
         return -1;
     struct atadrive_s *adrive_gf = container_of(
-        op->drive_gf, struct atadrive_s, drive);
+        op->drive_fl, struct atadrive_s, drive);
     struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf);
     u16 iomaster = GET_GLOBALFLAT(chan_gf->iomaster);
     if (! iomaster)
@@ -413,10 +413,10 @@ ata_dma_transfer(struct disk_op_s *op)
 {
     if (! CONFIG_ATA_DMA)
         return -1;
-    dprintf(16, "ata_dma_transfer id=%p buf=%p\n", op->drive_gf, op->buf_fl);
+    dprintf(16, "ata_dma_transfer id=%p buf=%p\n", op->drive_fl, op->buf_fl);
 
     struct atadrive_s *adrive_gf = container_of(
-        op->drive_gf, struct atadrive_s, drive);
+        op->drive_fl, struct atadrive_s, drive);
     struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf);
     u16 iomaster = GET_GLOBALFLAT(chan_gf->iomaster);
 
@@ -466,7 +466,7 @@ static int
 ata_pio_cmd_data(struct disk_op_s *op, int iswrite, struct ata_pio_command *cmd)
 {
     struct atadrive_s *adrive_gf = container_of(
-        op->drive_gf, struct atadrive_s, drive);
+        op->drive_fl, struct atadrive_s, drive);
     struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf);
     u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1);
     u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2);
@@ -495,7 +495,7 @@ ata_dma_cmd_data(struct disk_op_s *op, struct ata_pio_command *cmd)
     if (! CONFIG_ATA_DMA)
         return -1;
     struct atadrive_s *adrive_gf = container_of(
-        op->drive_gf, struct atadrive_s, drive);
+        op->drive_fl, struct atadrive_s, drive);
     int ret = send_cmd(adrive_gf, cmd);
     if (ret)
         return ret;
@@ -559,7 +559,7 @@ ata_process_op(struct disk_op_s *op)
         return 0;
 
     struct atadrive_s *adrive_gf = container_of(
-        op->drive_gf, struct atadrive_s, drive);
+        op->drive_fl, struct atadrive_s, drive);
     switch (op->command) {
     case CMD_READ:
         return ata_readwrite(op, 0);
@@ -597,7 +597,7 @@ ata_atapi_process_op(struct disk_op_s *op)
         return default_process_op(op);
 
     struct atadrive_s *adrive_gf = container_of(
-        op->drive_gf, struct atadrive_s, drive);
+        op->drive_fl, struct atadrive_s, drive);
     struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf);
     u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1);
     u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2);
@@ -667,7 +667,7 @@ send_ata_identity(struct atadrive_s *adrive, u16 *buffer, int command)
 
     struct disk_op_s dop;
     memset(&dop, 0, sizeof(dop));
-    dop.drive_gf = &adrive->drive;
+    dop.drive_fl = &adrive->drive;
     dop.count = 1;
     dop.lba = 1;
     dop.buf_fl = MAKE_FLATPTR(GET_SEG(SS), buffer);
diff --git a/src/hw/blockcmd.c b/src/hw/blockcmd.c
index f260dd8..1f15081 100644
--- a/src/hw/blockcmd.c
+++ b/src/hw/blockcmd.c
@@ -117,7 +117,7 @@ scsi_fill_cmd(struct disk_op_s *op, void *cdbcmd, int maxcdb)
                         : CDB_CMD_WRITE_10);
         cmd->lba = cpu_to_be32(op->lba);
         cmd->count = cpu_to_be16(op->count);
-        return GET_FLATPTR(op->drive_gf->blksize);
+        return GET_FLATPTR(op->drive_fl->blksize);
     case CMD_SCSI:
         if (MODESEGMENT)
             return -1;
@@ -141,7 +141,7 @@ int
 scsi_is_ready(struct disk_op_s *op)
 {
     ASSERT32FLAT();
-    dprintf(6, "scsi_is_ready (drive=%p)\n", op->drive_gf);
+    dprintf(6, "scsi_is_ready (drive=%p)\n", op->drive_fl);
 
     /* Retry TEST UNIT READY for 5 seconds unless MEDIUM NOT PRESENT is
      * reported by the device.  If the device reports "IN PROGRESS",
@@ -223,7 +223,7 @@ int scsi_rep_luns_scan(struct drive_s *tmp_drive, scsi_add_lun add_lun)
         .command = CDB_CMD_REPORT_LUNS,
     };
     struct disk_op_s op = {
-        .drive_gf = tmp_drive,
+        .drive_fl = tmp_drive,
         .command = CMD_SCSI,
         .count = 1,
         .cdbcmd = &cdb,
@@ -284,7 +284,7 @@ scsi_drive_setup(struct drive_s *drive, const char *s, int prio)
     ASSERT32FLAT();
     struct disk_op_s dop;
     memset(&dop, 0, sizeof(dop));
-    dop.drive_gf = drive;
+    dop.drive_fl = drive;
     struct cdbres_inquiry data;
     int ret = cdb_get_inquiry(&dop, &data);
     if (ret)
diff --git a/src/hw/esp-scsi.c b/src/hw/esp-scsi.c
index 57d3832..ffd86d0 100644
--- a/src/hw/esp-scsi.c
+++ b/src/hw/esp-scsi.c
@@ -83,7 +83,7 @@ esp_scsi_process_op(struct disk_op_s *op)
     if (!CONFIG_ESP_SCSI)
         return DISK_RET_EBADTRACK;
     struct esp_lun_s *llun_gf =
-        container_of(op->drive_gf, struct esp_lun_s, drive);
+        container_of(op->drive_fl, struct esp_lun_s, drive);
     u16 target = GET_GLOBALFLAT(llun_gf->target);
     u16 lun = GET_GLOBALFLAT(llun_gf->lun);
     u8 cdbcmd[16];
diff --git a/src/hw/floppy.c b/src/hw/floppy.c
index 98ed9bb..f2577c5 100644
--- a/src/hw/floppy.c
+++ b/src/hw/floppy.c
@@ -473,7 +473,7 @@ floppy_dma_cmd(struct disk_op_s *op, int count, int command, u8 *param)
         return DISK_RET_EBOUNDARY;
 
     // Invoke floppy controller
-    u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id);
+    u8 floppyid = GET_GLOBALFLAT(op->drive_fl->cntl_id);
     ret = floppy_drive_pio(floppyid, command, param);
     if (ret)
         return ret;
@@ -506,11 +506,11 @@ lba2chs(struct disk_op_s *op)
     struct chs_s res = { };
 
     u32 tmp = op->lba;
-    u16 nls = GET_GLOBALFLAT(op->drive_gf->lchs.sector);
+    u16 nls = GET_GLOBALFLAT(op->drive_fl->lchs.sector);
     res.sector = (tmp % nls) + 1;
 
     tmp /= nls;
-    u16 nlh = GET_GLOBALFLAT(op->drive_gf->lchs.head);
+    u16 nlh = GET_GLOBALFLAT(op->drive_fl->lchs.head);
     res.head = tmp % nlh;
 
     tmp /= nlh;
@@ -538,12 +538,12 @@ static int
 floppy_read(struct disk_op_s *op)
 {
     struct chs_s chs = lba2chs(op);
-    int ret = floppy_prep(op->drive_gf, chs.cylinder);
+    int ret = floppy_prep(op->drive_fl, chs.cylinder);
     if (ret)
         return ret;
 
     // send read-normal-data command to controller
-    u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id);
+    u8 floppyid = GET_GLOBALFLAT(op->drive_fl->cntl_id);
     u8 param[8];
     param[0] = (chs.head << 2) | floppyid; // HD DR1 DR2
     param[1] = chs.cylinder;
@@ -561,12 +561,12 @@ static int
 floppy_write(struct disk_op_s *op)
 {
     struct chs_s chs = lba2chs(op);
-    int ret = floppy_prep(op->drive_gf, chs.cylinder);
+    int ret = floppy_prep(op->drive_fl, chs.cylinder);
     if (ret)
         return ret;
 
     // send write-normal-data command to controller
-    u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id);
+    u8 floppyid = GET_GLOBALFLAT(op->drive_fl->cntl_id);
     u8 param[8];
     param[0] = (chs.head << 2) | floppyid; // HD DR1 DR2
     param[1] = chs.cylinder;
@@ -584,7 +584,7 @@ static int
 floppy_verify(struct disk_op_s *op)
 {
     struct chs_s chs = lba2chs(op);
-    int ret = floppy_prep(op->drive_gf, chs.cylinder);
+    int ret = floppy_prep(op->drive_fl, chs.cylinder);
     if (ret)
         return ret;
 
@@ -597,12 +597,12 @@ static int
 floppy_format(struct disk_op_s *op)
 {
     struct chs_s chs = lba2chs(op);
-    int ret = floppy_prep(op->drive_gf, chs.cylinder);
+    int ret = floppy_prep(op->drive_fl, chs.cylinder);
     if (ret)
         return ret;
 
     // send format-track command to controller
-    u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id);
+    u8 floppyid = GET_GLOBALFLAT(op->drive_fl->cntl_id);
     u8 param[7];
     param[0] = (chs.head << 2) | floppyid; // HD DR1 DR2
     param[1] = FLOPPY_SIZE_CODE;
diff --git a/src/hw/lsi-scsi.c b/src/hw/lsi-scsi.c
index 5233251..d5fc3e4 100644
--- a/src/hw/lsi-scsi.c
+++ b/src/hw/lsi-scsi.c
@@ -57,7 +57,7 @@ lsi_scsi_process_op(struct disk_op_s *op)
     if (!CONFIG_LSI_SCSI)
         return DISK_RET_EBADTRACK;
     struct lsi_lun_s *llun_gf =
-        container_of(op->drive_gf, struct lsi_lun_s, drive);
+        container_of(op->drive_fl, struct lsi_lun_s, drive);
     u16 target = GET_GLOBALFLAT(llun_gf->target);
     u16 lun = GET_GLOBALFLAT(llun_gf->lun);
     u8 cdbcmd[16];
diff --git a/src/hw/megasas.c b/src/hw/megasas.c
index efd0f6e..d267580 100644
--- a/src/hw/megasas.c
+++ b/src/hw/megasas.c
@@ -167,7 +167,7 @@ megasas_process_op(struct disk_op_s *op)
     if (blocksize < 0)
         return default_process_op(op);
     struct megasas_lun_s *mlun_gf =
-        container_of(op->drive_gf, struct megasas_lun_s, drive);
+        container_of(op->drive_fl, struct megasas_lun_s, drive);
     struct megasas_cmd_frame *frame = GET_GLOBALFLAT(mlun_gf->frame);
     u16 pci_id = GET_GLOBALFLAT(mlun_gf->pci_id);
     int i;
diff --git a/src/hw/mpt-scsi.c b/src/hw/mpt-scsi.c
index 80c6d6b..1faede6 100644
--- a/src/hw/mpt-scsi.c
+++ b/src/hw/mpt-scsi.c
@@ -188,7 +188,7 @@ mpt_scsi_process_op(struct disk_op_s *op)
         return default_process_op(op);
 
     struct mpt_lun_s *llun_gf =
-        container_of(op->drive_gf, struct mpt_lun_s, drive);
+        container_of(op->drive_fl, struct mpt_lun_s, drive);
     u16 target = GET_GLOBALFLAT(llun_gf->target);
     u16 lun = GET_GLOBALFLAT(llun_gf->lun);
     u32 iobase = GET_GLOBALFLAT(llun_gf->iobase);
diff --git a/src/hw/nvme.c b/src/hw/nvme.c
index 556a9a4..93c25f5 100644
--- a/src/hw/nvme.c
+++ b/src/hw/nvme.c
@@ -601,7 +601,7 @@ nvme_process_op(struct disk_op_s *op)
     if (!CONFIG_NVME)
         return DISK_RET_SUCCESS;
 
-    struct nvme_namespace *ns = container_of(op->drive_gf, struct nvme_namespace,
+    struct nvme_namespace *ns = container_of(op->drive_fl, struct nvme_namespace,
                                              drive);
 
     switch (op->command) {
diff --git a/src/hw/pvscsi.c b/src/hw/pvscsi.c
index 7c850a9..d62d0a0 100644
--- a/src/hw/pvscsi.c
+++ b/src/hw/pvscsi.c
@@ -213,7 +213,7 @@ pvscsi_process_op(struct disk_op_s *op)
     if (!CONFIG_PVSCSI)
         return DISK_RET_EBADTRACK;
     struct pvscsi_lun_s *plun =
-        container_of(op->drive_gf, struct pvscsi_lun_s, drive);
+        container_of(op->drive_fl, struct pvscsi_lun_s, drive);
     struct pvscsi_ring_dsc_s *ring_dsc = plun->ring_dsc;
     struct PVSCSIRingsState *s = ring_dsc->ring_state;
     u32 req_entries = s->reqNumEntriesLog2;
diff --git a/src/hw/ramdisk.c b/src/hw/ramdisk.c
index adec1d1..b9e9baa 100644
--- a/src/hw/ramdisk.c
+++ b/src/hw/ramdisk.c
@@ -62,7 +62,7 @@ ramdisk_setup(void)
 static int
 ramdisk_copy(struct disk_op_s *op, int iswrite)
 {
-    u32 offset = GET_GLOBALFLAT(op->drive_gf->cntl_id);
+    u32 offset = GET_GLOBALFLAT(op->drive_fl->cntl_id);
     offset += (u32)op->lba * DISK_SECTOR_SIZE;
     u64 opd = GDT_DATA | GDT_LIMIT(0xfffff) | GDT_BASE((u32)op->buf_fl);
     u64 ramd = GDT_DATA | GDT_LIMIT(0xfffff) | GDT_BASE(offset);
diff --git a/src/hw/sdcard.c b/src/hw/sdcard.c
index 73fef29..6410340 100644
--- a/src/hw/sdcard.c
+++ b/src/hw/sdcard.c
@@ -266,7 +266,7 @@ static int
 sdcard_readwrite(struct disk_op_s *op, int iswrite)
 {
     struct sddrive_s *drive = container_of(
-        op->drive_gf, struct sddrive_s, drive);
+        op->drive_fl, struct sddrive_s, drive);
     int cmd = iswrite ? SC_WRITE_SINGLE : SC_READ_SINGLE;
     if (op->count > 1)
         cmd = iswrite ? SC_WRITE_MULTIPLE : SC_READ_MULTIPLE;
diff --git a/src/hw/usb-msc.c b/src/hw/usb-msc.c
index a234f13..2b18828 100644
--- a/src/hw/usb-msc.c
+++ b/src/hw/usb-msc.c
@@ -69,9 +69,9 @@ usb_process_op(struct disk_op_s *op)
         return 0;
 
     dprintf(16, "usb_cmd_data id=%p write=%d count=%d buf=%p\n"
-            , op->drive_gf, 0, op->count, op->buf_fl);
+            , op->drive_fl, 0, op->count, op->buf_fl);
     struct usbdrive_s *udrive_gf = container_of(
-        op->drive_gf, struct usbdrive_s, drive);
+        op->drive_fl, struct usbdrive_s, drive);
 
     // Setup command block wrapper.
     struct cbw_s cbw;
diff --git a/src/hw/usb-uas.c b/src/hw/usb-uas.c
index f00221a..6a8decc 100644
--- a/src/hw/usb-uas.c
+++ b/src/hw/usb-uas.c
@@ -98,7 +98,7 @@ uas_process_op(struct disk_op_s *op)
         return DISK_RET_EBADTRACK;
 
     struct uasdrive_s *drive_gf = container_of(
-        op->drive_gf, struct uasdrive_s, drive);
+        op->drive_fl, struct uasdrive_s, drive);
 
     uas_ui ui;
     memset(&ui, 0, sizeof(ui));
diff --git a/src/hw/virtio-blk.c b/src/hw/virtio-blk.c
index 901b8f5..ad16200 100644
--- a/src/hw/virtio-blk.c
+++ b/src/hw/virtio-blk.c
@@ -33,7 +33,7 @@ static int
 virtio_blk_op(struct disk_op_s *op, int write)
 {
     struct virtiodrive_s *vdrive_gf =
-        container_of(op->drive_gf, struct virtiodrive_s, drive);
+        container_of(op->drive_fl, struct virtiodrive_s, drive);
     struct vring_virtqueue *vq = vdrive_gf->vq;
     struct virtio_blk_outhdr hdr = {
         .type = write ? VIRTIO_BLK_T_OUT : VIRTIO_BLK_T_IN,
diff --git a/src/hw/virtio-scsi.c b/src/hw/virtio-scsi.c
index 4eea5c3..466b305 100644
--- a/src/hw/virtio-scsi.c
+++ b/src/hw/virtio-scsi.c
@@ -39,7 +39,7 @@ virtio_scsi_process_op(struct disk_op_s *op)
     if (! CONFIG_VIRTIO_SCSI)
         return 0;
     struct virtio_lun_s *vlun =
-        container_of(op->drive_gf, struct virtio_lun_s, drive);
+        container_of(op->drive_fl, struct virtio_lun_s, drive);
     struct vp_device *vp = vlun->vp;
     struct vring_virtqueue *vq = vlun->vq;
     struct virtio_scsi_req_cmd req;
-- 
2.9.4


_______________________________________________
SeaBIOS mailing list
SeaBIOS@seabios.org
https://mail.coreboot.org/mailman/listinfo/seabios
[SeaBIOS] [PATCH 4/4] virtio: Allocate drive_s storage in low memory
Posted by Kevin O'Connor, 10 weeks ago
Use the "low" memory segment instead of the f-segment for the drive_s
storage.  This can help avoid running out of memory in the f-segment.

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>
---
 src/hw/virtio-blk.c  | 12 ++++++------
 src/hw/virtio-ring.c |  1 -
 src/hw/virtio-scsi.c |  3 +--
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/hw/virtio-blk.c b/src/hw/virtio-blk.c
index ad16200..88d7e54 100644
--- a/src/hw/virtio-blk.c
+++ b/src/hw/virtio-blk.c
@@ -32,9 +32,9 @@ struct virtiodrive_s {
 static int
 virtio_blk_op(struct disk_op_s *op, int write)
 {
-    struct virtiodrive_s *vdrive_gf =
+    struct virtiodrive_s *vdrive =
         container_of(op->drive_fl, struct virtiodrive_s, drive);
-    struct vring_virtqueue *vq = vdrive_gf->vq;
+    struct vring_virtqueue *vq = vdrive->vq;
     struct virtio_blk_outhdr hdr = {
         .type = write ? VIRTIO_BLK_T_OUT : VIRTIO_BLK_T_IN,
         .ioprio = 0,
@@ -48,7 +48,7 @@ virtio_blk_op(struct disk_op_s *op, int write)
         },
         {
             .addr       = op->buf_fl,
-            .length     = vdrive_gf->drive.blksize * op->count,
+            .length     = vdrive->drive.blksize * op->count,
         },
         {
             .addr       = (void*)(&status),
@@ -61,7 +61,7 @@ virtio_blk_op(struct disk_op_s *op, int write)
         vring_add_buf(vq, sg, 2, 1, 0, 0);
     else
         vring_add_buf(vq, sg, 1, 2, 0, 0);
-    vring_kick(&vdrive_gf->vp, vq, 1);
+    vring_kick(&vdrive->vp, vq, 1);
 
     /* Wait for reply */
     while (!vring_more_used(vq))
@@ -73,7 +73,7 @@ virtio_blk_op(struct disk_op_s *op, int write)
     /* Clear interrupt status register.  Avoid leaving interrupts stuck if
      * VRING_AVAIL_F_NO_INTERRUPT was ignored and interrupts were raised.
      */
-    vp_get_isr(&vdrive_gf->vp);
+    vp_get_isr(&vdrive->vp);
 
     return status == VIRTIO_BLK_S_OK ? DISK_RET_SUCCESS : DISK_RET_EBADTRACK;
 }
@@ -99,7 +99,7 @@ init_virtio_blk(void *data)
     struct pci_device *pci = data;
     u8 status = VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER;
     dprintf(1, "found virtio-blk at %pP\n", pci);
-    struct virtiodrive_s *vdrive = malloc_fseg(sizeof(*vdrive));
+    struct virtiodrive_s *vdrive = malloc_low(sizeof(*vdrive));
     if (!vdrive) {
         warn_noalloc();
         return;
diff --git a/src/hw/virtio-ring.c b/src/hw/virtio-ring.c
index 7205a0a..0ed3189 100644
--- a/src/hw/virtio-ring.c
+++ b/src/hw/virtio-ring.c
@@ -16,7 +16,6 @@
  *
  */
 
-#include "biosvar.h" // GET_GLOBAL
 #include "output.h" // panic
 #include "virtio-ring.h"
 #include "virtio-pci.h"
diff --git a/src/hw/virtio-scsi.c b/src/hw/virtio-scsi.c
index 466b305..a87cad8 100644
--- a/src/hw/virtio-scsi.c
+++ b/src/hw/virtio-scsi.c
@@ -7,7 +7,6 @@
 //
 // This file may be distributed under the terms of the GNU LGPLv3 license.
 
-#include "biosvar.h" // GET_GLOBALFLAT
 #include "block.h" // struct drive_s
 #include "blockcmd.h" // scsi_drive_setup
 #include "config.h" // CONFIG_*
@@ -114,7 +113,7 @@ virtio_scsi_add_lun(u32 lun, struct drive_s *tmpl_drv)
 {
     struct virtio_lun_s *tmpl_vlun =
         container_of(tmpl_drv, struct virtio_lun_s, drive);
-    struct virtio_lun_s *vlun = malloc_fseg(sizeof(*vlun));
+    struct virtio_lun_s *vlun = malloc_low(sizeof(*vlun));
     if (!vlun) {
         warn_noalloc();
         return -1;
-- 
2.9.4


_______________________________________________
SeaBIOS mailing list
SeaBIOS@seabios.org
https://mail.coreboot.org/mailman/listinfo/seabios