exec/rom_reset: Free rom data during inmigrate skip
PATCH 1/1 exec/rom_reset: Free rom data during inmigrate skip
From: "Dr. David Alan Gilbert" <[email protected]>
Commit 355477f8c73e9 skips rom reset when we're an incoming migration so as not to overwrite shared ram in the ignore-shared migration optimisation.
However, it's got an unexpected side effect that because it skips freeing the ROM data, when rom_reset gets called later on, after migration (e.g. during a reboot), the ROM does get reset to the original file contents. Because of seabios/x86's weird reboot process this confuses a reboot into hanging after a migration.
https://bugzilla.redhat.com/show_bug.cgi?id=1809380
--- hw/core/loader.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)
hw/core/loader.c +14 -9
@@ -1119,19 +1119,24 @@ static void rom_reset(void *unused) {Rom *rom; -/* -* We don't need to fill in the RAM with ROM data because we'll fill -* the data in during the next incoming migration in all cases. Note -* that some of those RAMs can actually be modified by the guest on ARM -* so this is probably the only right thing to do here. -*/ -if (runstate_check (RUN_STATE_INMIGRATE )) -return ; - QTAILQ_FOREACH(rom, &roms, next) {if (rom->fw_file) {continue ; } +/* +* We don't need to fill in the RAM with ROM data because we'll fill +* the data in during the next incoming migration in all cases. Note +* that some of those RAMs can actually be modified by the guest on ARM +* so this is probably the only right thing to do here. +*/ +if (runstate_check (RUN_STATE_INMIGRATE ) && rom->data) { +/* +* Free it so that a rom_reset after migration doesn't overwrite a +* potentially modified 'rom'. +*/ +rom_free_data (rom); + } +if (rom->data ==NULL ) {continue ; }
Signature · 1 line
2.24.1
Quoted 27 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
Commit
355477f8c73e9skips rom reset when we're an incoming migration so as not to overwrite shared ram in the ignore-shared migration optimisation.
However, it's got an unexpected side effect that because it skips freeing the ROM data, whenrom_resetgets called later on, after migration (e.g. during a reboot), the ROM does get reset to the original file contents. Because of seabios/x86's weird reboot process this confuses a reboot into hanging after a migration.Fixes 355477f8c73e9 ("migration: do not rom_reset() during incoming migration")https://bugzilla.redhat.com/show_bug.cgi?id=1809380
Signed-off-by Dr. David Alan Gilbert <[email protected]>--- hw/core/loader.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)QTAILQ_FOREACH(rom, &roms, next) { if (rom->fw_file) { continue; }hw/core/loader.c +2
-0+/* +* We don't need to fill in the RAM with ROM data because we'll fill
hw/core/loader.c static void rom_reset(void *unused) · line 1137
Quoted 10 lines
hw/core/loader.c +10
-0+* the data in during the next incoming migration in all cases. Note +* that some of those RAMs can actually be modified by the guest on ARM +* so this is probably the only right thing to do here. +*/ +if (runstate_check (RUN_STATE_INMIGRATE ) && rom->data) { +/* +* Free it so that a rom_reset after migration doesn't overwrite a +* potentially modified 'rom'. +*/ +rom_free_data (rom);
Shouldn't this condition match the condition in rom_reset() for when we call rom_free_data()? You want the behaviour on a subsequent reset to match the behaviour you'd get if you did a reset on the source end without the migration.
hw/core/loader.c static void rom_reset(void *unused) · line 1142
Quoted 5 lines
hw/core/loader.c +2
-0+ } +if (rom->data ==NULL ) {continue ; }
If you put this check above your new one you wouldn't need to check rom->data in it. Also it would make the loop structure better match rom_reset(), which checks rom->fw_file first, then rom->data, then has the condition for "do we need to call rom_free_data()".
thanks
-- PMM
Quoted 41 lines · Peter Maydell
Quoted 27 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
Commit
355477f8c73e9skips rom reset when we're an incoming migration so as not to overwrite shared ram in the ignore-shared migration optimisation.
However, it's got an unexpected side effect that because it skips freeing the ROM data, whenrom_resetgets called later on, after migration (e.g. during a reboot), the ROM does get reset to the original file contents. Because of seabios/x86's weird reboot process this confuses a reboot into hanging after a migration.Fixes 355477f8c73e9 ("migration: do not rom_reset() during incoming migration")https://bugzilla.redhat.com/show_bug.cgi?id=1809380
Signed-off-by Dr. David Alan Gilbert <[email protected]>--- hw/core/loader.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)QTAILQ_FOREACH(rom, &roms, next) { if (rom->fw_file) { continue; }hw/core/loader.c +2
-0+/* +* We don't need to fill in the RAM with ROM data because we'll fill hw/core/loader.c static void rom_reset(void *unused) · line 1137
Quoted 10 lines
hw/core/loader.c +10
-0+* the data in during the next incoming migration in all cases. Note +* that some of those RAMs can actually be modified by the guest on ARM +* so this is probably the only right thing to do here. +*/ +if (runstate_check (RUN_STATE_INMIGRATE ) && rom->data) { +/* +* Free it so that a rom_reset after migration doesn't overwrite a +* potentially modified 'rom'. +*/ +rom_free_data (rom);
Quoted 4 lines
Shouldn't this condition match the condition in
rom_reset()for when we callrom_free_data()? You want the behaviour on a subsequent reset to match the behaviour you'd get if you did a reset on the source end without the migration.
Wait, this *is* rom_reset(). Now I'm really confused.
thanks
-- PMM
Quoted 42 lines · * Peter Maydell ([email protected]) wrote:
Quoted 41 lines · Peter Maydell
Quoted 37 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
Commit
355477f8c73e9skips rom reset when we're an incoming migration so as not to overwrite shared ram in the ignore-shared migration optimisation.
However, it's got an unexpected side effect that because it skips freeing the ROM data, whenrom_resetgets called later on, after migration (e.g. during a reboot), the ROM does get reset to the original file contents. Because of seabios/x86's weird reboot process this confuses a reboot into hanging after a migration.Fixes 355477f8c73e9 ("migration: do not rom_reset() during incoming migration")https://bugzilla.redhat.com/show_bug.cgi?id=1809380
Signed-off-by Dr. David Alan Gilbert <[email protected]>--- hw/core/loader.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)QTAILQ_FOREACH(rom, &roms, next) { if (rom->fw_file) { continue; }hw/core/loader.c +12
-0+/* +* We don't need to fill in the RAM with ROM data because we'll fill +* the data in during the next incoming migration in all cases. Note +* that some of those RAMs can actually be modified by the guest on ARM +* so this is probably the only right thing to do here. +*/ +if (runstate_check (RUN_STATE_INMIGRATE ) && rom->data) { +/* +* Free it so that a rom_reset after migration doesn't overwrite a +* potentially modified 'rom'. +*/ +rom_free_data (rom);
Quoted 6 lines
Quoted 4 lines
Shouldn't this condition match the condition in
rom_reset()for when we callrom_free_data()? You want the behaviour on a subsequent reset to match the behaviour you'd get if you did a reset on the source end without the migration.Wait, this *is*
rom_reset(). Now I'm really confused.
The exsiting rom_reset gets called multiple times:
a) During init
This actually copies the ROMs and then calls rom_free_data
b) During a subsequent reboot
This is mostly skipped because rom->data is now free because of the prior call to rom_free_data during (a)
During an inbound migrate, (a) happens before the migration, and
(b) happens during a reboot after the migration.
The problem is that 355477f8c73e9 caused (a) to be skipped then when (b) happens it actually overwrites the ROM because the rom_free_data had been skipped. What I'm doing here is doing the rom_free_data(..) which causes it to then skip this iteration during (a) AND causes it to skip it during (b).
Dave
Quoted 3 lines
thanks
-- PMM
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Quoted 59 lines · Dr. David Alan Gilbert
Quoted 42 lines · * Peter Maydell ([email protected]) wrote:
Quoted 41 lines · Peter Maydell
Quoted 37 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
Commit
355477f8c73e9skips rom reset when we're an incoming migration so as not to overwrite shared ram in the ignore-shared migration optimisation.
However, it's got an unexpected side effect that because it skips freeing the ROM data, whenrom_resetgets called later on, after migration (e.g. during a reboot), the ROM does get reset to the original file contents. Because of seabios/x86's weird reboot process this confuses a reboot into hanging after a migration.Fixes 355477f8c73e9 ("migration: do not rom_reset() during incoming migration")https://bugzilla.redhat.com/show_bug.cgi?id=1809380
Signed-off-by Dr. David Alan Gilbert <[email protected]>--- hw/core/loader.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)QTAILQ_FOREACH(rom, &roms, next) { if (rom->fw_file) { continue; }hw/core/loader.c +12
-0+/* +* We don't need to fill in the RAM with ROM data because we'll fill +* the data in during the next incoming migration in all cases. Note +* that some of those RAMs can actually be modified by the guest on ARM +* so this is probably the only right thing to do here. +*/ +if (runstate_check (RUN_STATE_INMIGRATE ) && rom->data) { +/* +* Free it so that a rom_reset after migration doesn't overwrite a +* potentially modified 'rom'. +*/ +rom_free_data (rom);Quoted 6 lines
Quoted 4 lines
Shouldn't this condition match the condition in
rom_reset()for when we callrom_free_data()? You want the behaviour on a subsequent reset to match the behaviour you'd get if you did a reset on the source end without the migration.Wait, this *is*
rom_reset(). Now I'm really confused.The exsiting
rom_resetgets called multiple times:
a) During init
This actually copies the ROMs and then callsrom_free_datab) During a subsequent reboot
This is mostly skipped becauserom->datais now free because of the prior call torom_free_dataduring (a)
Quoted 8 lines
During an inbound migrate, (a) happens before the migration, and
(b) happens during a reboot after the migration.The problem is that
355477f8c73e9caused (a) to be skipped then when (b) happens it actually overwrites the ROM because therom_free_datahad been skipped. What I'm doing here is doing therom_free_data(..)which causes it to then skip this iteration during (a) AND causes it to skip it during (b).
OK, but why is your condition for when to call rom_free_data() in this special case not the same as the condition that we use in the normal no-migration-involved case? I would expect those to match up.
thanks
-- PMM
Quoted 70 lines · * Peter Maydell ([email protected]) wrote:
Quoted 59 lines · Dr. David Alan Gilbert
Quoted 42 lines · * Peter Maydell ([email protected]) wrote:
Quoted 41 lines · Peter Maydell
Quoted 37 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
Commit
355477f8c73e9skips rom reset when we're an incoming migration so as not to overwrite shared ram in the ignore-shared migration optimisation.
However, it's got an unexpected side effect that because it skips freeing the ROM data, whenrom_resetgets called later on, after migration (e.g. during a reboot), the ROM does get reset to the original file contents. Because of seabios/x86's weird reboot process this confuses a reboot into hanging after a migration.Fixes 355477f8c73e9 ("migration: do not rom_reset() during incoming migration")https://bugzilla.redhat.com/show_bug.cgi?id=1809380
Signed-off-by Dr. David Alan Gilbert <[email protected]>--- hw/core/loader.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)QTAILQ_FOREACH(rom, &roms, next) { if (rom->fw_file) { continue; }hw/core/loader.c +12
-0+/* +* We don't need to fill in the RAM with ROM data because we'll fill +* the data in during the next incoming migration in all cases. Note +* that some of those RAMs can actually be modified by the guest on ARM +* so this is probably the only right thing to do here. +*/ +if (runstate_check (RUN_STATE_INMIGRATE ) && rom->data) { +/* +* Free it so that a rom_reset after migration doesn't overwrite a +* potentially modified 'rom'. +*/ +rom_free_data (rom);Quoted 6 lines
Quoted 4 lines
Shouldn't this condition match the condition in
rom_reset()for when we callrom_free_data()? You want the behaviour on a subsequent reset to match the behaviour you'd get if you did a reset on the source end without the migration.Wait, this *is*
rom_reset(). Now I'm really confused.The exsiting
rom_resetgets called multiple times:
a) During init
This actually copies the ROMs and then callsrom_free_datab) During a subsequent reboot
This is mostly skipped becauserom->datais now free because of the prior call torom_free_dataduring (a)Quoted 8 lines
During an inbound migrate, (a) happens before the migration, and
(b) happens during a reboot after the migration.The problem is that
355477f8c73e9caused (a) to be skipped then when (b) happens it actually overwrites the ROM because therom_free_datahad been skipped. What I'm doing here is doing therom_free_data(..)which causes it to then skip this iteration during (a) AND causes it to skip it during (b).
Quoted 4 lines
OK, but why is your condition for when to call
rom_free_data()in this special case not the same as the condition that we use in the normal no-migration-involved case? I would expect those to match up.
Ah yes, I think you're right, so something like:
if (runstate_check(RUN_STATE_INMIGRATE) && rom->data && rom->isrom) {I'll try that after lunch.
Dave
Quoted 3 lines
thanks
-- PMM
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Quoted 3 lines · Dr. David Alan Gilbert
Ah yes, I think you're right, so something like:
if (runstate_check(RUN_STATE_INMIGRATE) && rom->data && rom->isrom) {
I think you would see the difference here for images loaded into RAM, rather than ROM -- they need to be reinstated on reset, because the guest can scribble on them. So we retain the data and don't free it.
thanks
-- PMM
Quoted 10 lines · * Peter Maydell ([email protected]) wrote:
Quoted 3 lines · Dr. David Alan Gilbert
Ah yes, I think you're right, so something like:
if (runstate_check(RUN_STATE_INMIGRATE) && rom->data && rom->isrom) {I think you would see the difference here for images loaded into RAM, rather than ROM -- they need to be reinstated on reset, because the guest can scribble on them. So we retain the data and don't free it.
Hmm, that's true; so I'm failing to skip a copy in the !isrom case, whch the original patch needed.
So what I think we'll need is:
if (runstate_check(RUN_STATE_INMIGRATE))
{
if (rom->data && rom->isrom) {
rom_free_data(rom);
}
continue;
}Quoted 3 lines
thanks
-- PMM
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK