On Tue, Dec 12, 2017 at 01:56:00PM +0000, Dr. David Alan Gilbert (git) wrote: > From: "Dr. David Alan Gilbert" <dgilb...@redhat.com> > > Mostly just manual conversion with very minor fixes. > > Signed-off-by: Dr. David Alan Gilbert <dgilb...@redhat.com>
Reviewed-by: Peter Xu <pet...@redhat.com> Some nits below, but r-b is fine with/without changing them. Mostly it's about wrapping lines. I think .rst supports wrapping lines? Thanks, > --- > docs/devel/{migration.txt => migration.rst} | 326 > +++++++++++++++------------- > 1 file changed, 176 insertions(+), 150 deletions(-) > rename docs/devel/{migration.txt => migration.rst} (74%) > > diff --git a/docs/devel/migration.txt b/docs/devel/migration.rst > similarity index 74% > rename from docs/devel/migration.txt > rename to docs/devel/migration.rst > index 4030703726..7d64298cd7 100644 > --- a/docs/devel/migration.txt > +++ b/docs/devel/migration.rst > @@ -1,4 +1,6 @@ > -= Migration = > +========= > +Migration > +========= > > QEMU has code to load/save the state of the guest that it is running. > These are two complementary operations. Saving the state just does > @@ -26,7 +28,8 @@ the guest to be stopped. Typically the time that the guest > is > unresponsive during live migration is the low hundred of milliseconds > (notice that this depends on a lot of things). > > -=== Types of migration === > +Types of migration > +================== > > Now that we have talked about live migration, there are several ways > to do migration: > @@ -41,21 +44,25 @@ All these four migration protocols use the same > infrastructure to > save/restore state devices. This infrastructure is shared with the > savevm/loadvm functionality. > > -=== State Live Migration === > +State Live Migration > +==================== > > This is used for RAM and block devices. It is not yet ported to vmstate. > <Fill more information here> > > -=== What is the common infrastructure === > +Common infrastructure > +===================== > > QEMU uses a QEMUFile abstraction to be able to do migration. Any type > of migration that wants to use QEMU infrastructure has to create a > QEMUFile with: > > -QEMUFile *qemu_fopen_ops(void *opaque, > - QEMUFilePutBufferFunc *put_buffer, > - QEMUFileGetBufferFunc *get_buffer, > - QEMUFileCloseFunc *close); > +.. code:: c > + > + QEMUFile *qemu_fopen_ops(void *opaque, > + QEMUFilePutBufferFunc *put_buffer, > + QEMUFileGetBufferFunc *get_buffer, > + QEMUFileCloseFunc *close); > > The functions have the following functionality: > > @@ -63,19 +70,25 @@ This function writes a chunk of data to a file at the > given position. > The pos argument can be ignored if the file is only used for > streaming. The handler should try to write all of the data it can. > > -typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf, > - int64_t pos, int size); > +.. code:: c > + > + typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf, > + int64_t pos, int size); > > Read a chunk of data from a file at the given position. The pos argument > can be ignored if the file is only be used for streaming. The number of > bytes actually read should be returned. > > -typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf, > - int64_t pos, int size); > +.. code:: c > + > + typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf, > + int64_t pos, int size); > > Close a file and return an error code. > > -typedef int (QEMUFileCloseFunc)(void *opaque); > +.. code:: c > + > + typedef int (QEMUFileCloseFunc)(void *opaque); > > You can use any internal state that you need using the opaque void * > pointer that is passed to all functions. > @@ -83,7 +96,8 @@ pointer that is passed to all functions. > The important functions for us are put_buffer()/get_buffer() that > allow to write/read a buffer into the QEMUFile. > > -=== How to save the state of one device === > +Saving the state of one device > +============================== > > The state of a device is saved using intermediate buffers. There are > some helper functions to assist this saving. > @@ -97,30 +111,34 @@ associated with a series of fields saved. The > save_state always saves > the state as the newer version. But load_state sometimes is able to > load state from an older version. > > -=== Legacy way === > +Legacy way > +---------- > > This way is going to disappear as soon as all current users are ported to > VMSTATE. > > Each device has to register two functions, one to save the state and > another to load the state back. > > -int register_savevm(DeviceState *dev, > - const char *idstr, > - int instance_id, > - int version_id, > - SaveStateHandler *save_state, > - LoadStateHandler *load_state, > - void *opaque); > +.. code:: c > + > + int register_savevm(DeviceState *dev, > + const char *idstr, > + int instance_id, > + int version_id, > + SaveStateHandler *save_state, > + LoadStateHandler *load_state, > + void *opaque); > > -typedef void SaveStateHandler(QEMUFile *f, void *opaque); > -typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id); > + typedef void SaveStateHandler(QEMUFile *f, void *opaque); > + typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id); > > The important functions for the device state format are the save_state > and load_state. Notice that load_state receives a version_id > parameter to know what state format is receiving. save_state doesn't > have a version_id parameter because it always uses the latest version. > > -=== VMState === > +VMState > +------- > > The legacy way of saving/loading state of the device had the problem > that we have to maintain two functions in sync. If we did one change > @@ -135,23 +153,27 @@ save/load functions. > > An example (from hw/input/pckbd.c) > > -static const VMStateDescription vmstate_kbd = { > - .name = "pckbd", > - .version_id = 3, > - .minimum_version_id = 3, > - .fields = (VMStateField[]) { > - VMSTATE_UINT8(write_cmd, KBDState), > - VMSTATE_UINT8(status, KBDState), > - VMSTATE_UINT8(mode, KBDState), > - VMSTATE_UINT8(pending, KBDState), > - VMSTATE_END_OF_LIST() > - } > -}; > +.. code:: c > + > + static const VMStateDescription vmstate_kbd = { > + .name = "pckbd", > + .version_id = 3, > + .minimum_version_id = 3, > + .fields = (VMStateField[]) { > + VMSTATE_UINT8(write_cmd, KBDState), > + VMSTATE_UINT8(status, KBDState), > + VMSTATE_UINT8(mode, KBDState), > + VMSTATE_UINT8(pending, KBDState), > + VMSTATE_END_OF_LIST() > + } > + }; > > We are declaring the state with name "pckbd". > The version_id is 3, and the fields are 4 uint8_t in a KBDState structure. > We registered this with: > > +.. code:: c > + > vmstate_register(NULL, 0, &vmstate_kbd, s); > > Note: talk about how vmstate <-> qdev interact, and what the instance ids > mean. > @@ -159,7 +181,8 @@ Note: talk about how vmstate <-> qdev interact, and what > the instance ids mean. > You can search for VMSTATE_* macros for lots of types used in QEMU in > include/hw/hw.h. > > -=== More about versions === > +More about versions > +------------------- > > Version numbers are intended for major incompatible changes to the > migration of a device, and using them breaks backwards-migration > @@ -183,7 +206,8 @@ function is deprecated and will be removed when no more > users are left. > Saving state will always create a section with the 'version_id' value > and thus can't be loaded by any older QEMU. > > -=== Massaging functions === > +Massaging functions > +------------------- > > Sometimes, it is not enough to be able to save the state directly > from one structure, we need to fill the correct values there. One > @@ -194,20 +218,19 @@ load the state for the cpu that we have just loaded > from the QEMUFile. > > The functions to do that are inside a vmstate definition, and are called: > > -- int (*pre_load)(void *opaque); > +- ``int (*pre_load)(void *opaque);`` > > This function is called before we load the state of one device. > > -- int (*post_load)(void *opaque, int version_id); > +- ``int (*post_load)(void *opaque, int version_id);`` > > This function is called after we load the state of one device. > > -- int (*pre_save)(void *opaque); > +- ``int (*pre_save)(void *opaque);`` > > This function is called before we save the state of one device. > > -Example: You can look at hpet.c, that uses the three function to > - massage the state that is transferred. > +Example: You can look at hpet.c, that uses the three function to massage the > state that is transferred. This change seems meaningless, I would prefer keep it wrapped, but I'm fine with it. > > If you use memory API functions that update memory layout outside > initialization (i.e., in response to a guest action), this is a strong > @@ -221,7 +244,8 @@ Examples of such memory API functions are: > - memory_region_set_address() > - memory_region_set_alias_offset() > > -=== Subsections === > +Subsections > +----------- > > The use of version_id allows to be able to migrate from older versions > to newer versions of a device. But not the other way around. This > @@ -251,48 +275,50 @@ value that it uses. > > Example: > > -static bool ide_drive_pio_state_needed(void *opaque) > -{ > - IDEState *s = opaque; > - > - return ((s->status & DRQ_STAT) != 0) > - || (s->bus->error_status & BM_STATUS_PIO_RETRY); > -} > - > -const VMStateDescription vmstate_ide_drive_pio_state = { > - .name = "ide_drive/pio_state", > - .version_id = 1, > - .minimum_version_id = 1, > - .pre_save = ide_drive_pio_pre_save, > - .post_load = ide_drive_pio_post_load, > - .needed = ide_drive_pio_state_needed, > - .fields = (VMStateField[]) { > - VMSTATE_INT32(req_nb_sectors, IDEState), > - VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 1, > - vmstate_info_uint8, uint8_t), > - VMSTATE_INT32(cur_io_buffer_offset, IDEState), > - VMSTATE_INT32(cur_io_buffer_len, IDEState), > - VMSTATE_UINT8(end_transfer_fn_idx, IDEState), > - VMSTATE_INT32(elementary_transfer_size, IDEState), > - VMSTATE_INT32(packet_transfer_size, IDEState), > - VMSTATE_END_OF_LIST() > - } > -}; > - > -const VMStateDescription vmstate_ide_drive = { > - .name = "ide_drive", > - .version_id = 3, > - .minimum_version_id = 0, > - .post_load = ide_drive_post_load, > - .fields = (VMStateField[]) { > - .... several fields .... > - VMSTATE_END_OF_LIST() > - }, > - .subsections = (const VMStateDescription*[]) { > - &vmstate_ide_drive_pio_state, > - NULL > - } > -}; > +.. code:: c > + > + static bool ide_drive_pio_state_needed(void *opaque) > + { > + IDEState *s = opaque; > + > + return ((s->status & DRQ_STAT) != 0) > + || (s->bus->error_status & BM_STATUS_PIO_RETRY); > + } > + > + const VMStateDescription vmstate_ide_drive_pio_state = { > + .name = "ide_drive/pio_state", > + .version_id = 1, > + .minimum_version_id = 1, > + .pre_save = ide_drive_pio_pre_save, > + .post_load = ide_drive_pio_post_load, > + .needed = ide_drive_pio_state_needed, > + .fields = (VMStateField[]) { > + VMSTATE_INT32(req_nb_sectors, IDEState), > + VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 1, > + vmstate_info_uint8, uint8_t), > + VMSTATE_INT32(cur_io_buffer_offset, IDEState), > + VMSTATE_INT32(cur_io_buffer_len, IDEState), > + VMSTATE_UINT8(end_transfer_fn_idx, IDEState), > + VMSTATE_INT32(elementary_transfer_size, IDEState), > + VMSTATE_INT32(packet_transfer_size, IDEState), > + VMSTATE_END_OF_LIST() > + } > + }; > + > + const VMStateDescription vmstate_ide_drive = { > + .name = "ide_drive", > + .version_id = 3, > + .minimum_version_id = 0, > + .post_load = ide_drive_post_load, > + .fields = (VMStateField[]) { > + .... several fields .... > + VMSTATE_END_OF_LIST() > + }, > + .subsections = (const VMStateDescription*[]) { > + &vmstate_ide_drive_pio_state, > + NULL > + } > + }; > > Here we have a subsection for the pio state. We only need to > save/send this state when we are in the middle of a pio operation > @@ -305,14 +331,11 @@ to send a subsection allows backwards migration > compatibility when > new subsections are added. > > For example; > - a) Add a new property using DEFINE_PROP_BOOL - e.g. support-foo and > - default it to true. > - b) Add an entry to the HW_COMPAT_ for the previous version > - that sets the property to false. > + a) Add a new property using ``DEFINE_PROP_BOOL`` - e.g. support-foo and > default it to true. > + b) Add an entry to the ``HW_COMPAT_`` for the previous version that sets > the property to false. > c) Add a static bool support_foo function that tests the property. > d) Add a subsection with a .needed set to the support_foo function > - e) (potentially) Add a pre_load that sets up a default value for 'foo' > - to be used if the subsection isn't loaded. > + e) (potentially) Add a pre_load that sets up a default value for 'foo' to > be used if the subsection isn't loaded. (same to these lines) > > Now that subsection will not be generated when using an older > machine type and the migration stream will be accepted by older > @@ -332,25 +355,28 @@ in most cases. In general the preference is to tie the > subsection to > the machine type, and allow reliable migrations, unless the behaviour > from omission of the subsection is really bad. > > -= Not sending existing elements = > +Not sending existing elements > +----------------------------- > > Sometimes members of the VMState are no longer needed; > - removing them will break migration compatibility > - making them version dependent and bumping the version will break backwards > - migration compatibility. > + - removing them will break migration compatibility > + > + - making them version dependent and bumping the version will break > backwards migration compatibility. > > The best way is to: > - a) Add a new property/compatibility/function in the same way for > subsections > - above. > + a) Add a new property/compatibility/function in the same way for > subsections above. > b) replace the VMSTATE macro with the _TEST version of the macro, e.g.: > - VMSTATE_UINT32(foo, barstruct) > + > + ``VMSTATE_UINT32(foo, barstruct)`` > + > becomes > - VMSTATE_UINT32_TEST(foo, barstruct, pre_version_baz) > > - Sometime in the future when we no longer care about the ancient > -versions these can be killed off. > + ``VMSTATE_UINT32_TEST(foo, barstruct, pre_version_baz)`` > > -= Return path = > + Sometime in the future when we no longer care about the ancient versions > these can be killed off. > + > +Return path > +----------- > > In most migration scenarios there is only a single data path that runs > from the source VM to the destination, typically along a single fd (although > @@ -369,10 +395,11 @@ path. > > Destination side > Forward path - read by main thread > - Return path - opened by main thread, written by main thread AND > postcopy > - thread (protected by rp_mutex) > + Return path - opened by main thread, written by main thread AND > postcopy thread (protected by rp_mutex) (same here) > + > +Postcopy > +======== > > -= Postcopy = > 'Postcopy' migration is a way to deal with migrations that refuse to converge > (or take too long to converge) its plus side is that there is an upper bound > on > the amount of migration traffic and time it takes, the down side is that > during > @@ -386,17 +413,18 @@ a fault that's translated by QEMU into a request to the > source QEMU. > Postcopy can be combined with precopy (i.e. normal migration) so that if > precopy > doesn't finish in a given time the switch is made to postcopy. > > -=== Enabling postcopy === > +Enabling postcopy > +----------------- > > To enable postcopy, issue this command on the monitor prior to the > start of migration: > > -migrate_set_capability postcopy-ram on > +``migrate_set_capability postcopy-ram on`` > > The normal commands are then used to start a migration, which is still > started in precopy mode. Issuing: > > -migrate_start_postcopy > +``migrate_start_postcopy`` > > will now cause the transition from precopy to postcopy. > It can be issued immediately after migration is started or any > @@ -406,7 +434,8 @@ Note: During the postcopy phase, the bandwidth limits set > using > migrate_set_speed is ignored (to avoid delaying requested pages that > the destination is waiting for). > > -=== Postcopy device transfer === > +Postcopy device transfer > +------------------------ > > Loading of device data may cause the device emulation to access guest RAM > that may trigger faults that have to be resolved by the source, as such > @@ -416,6 +445,7 @@ before the device load begins to free the stream up. > This is achieved by > 'packaging' the device data into a blob that's read in one go. > > Source behaviour > +---------------- > > Until postcopy is entered the migration stream is identical to normal > precopy, except for the addition of a 'postcopy advise' command at > @@ -423,11 +453,10 @@ the beginning, to tell the destination that postcopy > might happen. > When postcopy starts the source sends the page discard data and then > forms the 'package' containing: > > - Command: 'postcopy listen' > - The device state > - A series of sections, identical to the precopy streams device state > stream > - containing everything except postcopiable devices (i.e. RAM) > - Command: 'postcopy run' > + - Command: 'postcopy listen' > + - The device state > + A series of sections, identical to the precopy streams device state > stream containing everything except postcopiable devices (i.e. RAM) (a super long line, fine too) > + - Command: 'postcopy run' > > The 'package' is sent as the data part of a Command: 'CMD_PACKAGED', and the > contents are formatted in the same way as the main migration stream. > @@ -441,44 +470,38 @@ to be sent quickly in the hope that those pages are > likely to be used > by the destination soon. > > Destination behaviour > +--------------------- > > Initially the destination looks the same as precopy, with a single thread > reading the migration stream; the 'postcopy advise' and 'discard' commands > are processed to change the way RAM is managed, but don't affect the stream > processing. > > ------------------------------------------------------------------------------- > - 1 2 3 4 5 6 7 > -main -----DISCARD-CMD_PACKAGED ( LISTEN DEVICE DEVICE DEVICE RUN ) > -thread | | > - | (page request) > - | \___ > - v \ > -listen thread: --- page -- page -- page -- page -- page > -- > - > - a b c > ------------------------------------------------------------------------------- > - > -On receipt of CMD_PACKAGED (1) > - All the data associated with the package - the ( ... ) section in the > -diagram - is read into memory, and the main thread recurses into > -qemu_loadvm_state_main to process the contents of the package (2) > -which contains commands (3,6) and devices (4...) > - > -On receipt of 'postcopy listen' - 3 -(i.e. the 1st command in the package) > -a new thread (a) is started that takes over servicing the migration stream, > -while the main thread carries on loading the package. It loads normal > -background page data (b) but if during a device load a fault happens (5) the > -returned page (c) is loaded by the listen thread allowing the main threads > -device load to carry on. > - > -The last thing in the CMD_PACKAGED is a 'RUN' command (6) letting the > destination > -CPUs start running. > -At the end of the CMD_PACKAGED (7) the main thread returns to normal running > behaviour > -and is no longer used by migration, while the listen thread carries > -on servicing page data until the end of migration. > - > -=== Postcopy states === > +:: > + > + > ------------------------------------------------------------------------------ > + 1 2 3 4 5 6 7 > + main -----DISCARD-CMD_PACKAGED ( LISTEN DEVICE DEVICE DEVICE RUN ) > + thread | | > + | (page request) > + | \___ > + v \ > + listen thread: --- page -- page -- page -- page -- > page -- > + > + a b c > + > ------------------------------------------------------------------------------ > + > +- On receipt of CMD_PACKAGED (1) > + All the data associated with the package - the ( ... ) section in the > diagram - is read into memory, and the main thread recurses into > qemu_loadvm_state_main to process the contents of the package (2) which > contains commands (3,6) and devices (4...) > + > +- On receipt of 'postcopy listen' - 3 -(i.e. the 1st command in the package) > + a new thread (a) is started that takes over servicing the migration > stream, while the main thread carries on loading the package. It loads > normal background page data (b) but if during a device load a fault happens > (5) the returned page (c) is loaded by the listen thread allowing the main > threads device load to carry on. > + > +- The last thing in the CMD_PACKAGED is a 'RUN' command (6) > + letting the destination CPUs start running. At the end of the > CMD_PACKAGED (7) the main thread returns to normal running behaviour and is > no longer used by migration, while the listen thread carries on servicing > page data until the end of migration. (here the lines can be wrapped too?) > + > +Postcopy states > +--------------- > > Postcopy moves through a series of states (see postcopy_state) from > ADVISE->DISCARD->LISTEN->RUNNING->END > @@ -516,7 +539,8 @@ ADVISE->DISCARD->LISTEN->RUNNING->END > End: The listen thread can now quit, and perform the cleanup of > migration > state, the migration is now complete. > > -=== Source side page maps === > +Source side page maps > +--------------------- > > The source side keeps two bitmaps during postcopy; 'the migration bitmap' > and 'unsent map'. The 'migration bitmap' is basically the same as in > @@ -529,6 +553,7 @@ The 'unsent map' is used for the transition to postcopy. > It is a bitmap that > has a bit cleared whenever a page is sent to the destination, however during > the transition to postcopy mode it is combined with the migration bitmap > to form a set of pages that: > + > a) Have been sent but then redirtied (which must be discarded) > b) Have not yet been sent - which also must be discarded to cause any > transparent huge pages built during precopy to be broken. > @@ -540,7 +565,8 @@ request for a page that has already been sent is ignored. > Duplicate requests > such as this can happen as a page is sent at about the same time the > destination accesses it. > > -=== Postcopy with hugepages === > +Postcopy with hugepages > +----------------------- > > Postcopy now works with hugetlbfs backed memory: > a) The linux kernel on the destination must support userfault on hugepages. > -- > 2.14.3 > -- Peter Xu