2017-07-29 01:46:05 +03:00
|
|
|
# See docs/devel/tracing.txt for syntax documentation.
|
2016-06-16 11:39:51 +03:00
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# savevm.c
|
2016-06-16 11:39:51 +03:00
|
|
|
qemu_loadvm_state_section(unsigned int section_type) "%d"
|
|
|
|
|
qemu_loadvm_state_section_command(int ret) "%d"
|
|
|
|
|
qemu_loadvm_state_section_partend(uint32_t section_id) "%u"
|
|
|
|
|
qemu_loadvm_state_post_main(int ret) "%d"
|
|
|
|
|
qemu_loadvm_state_section_startfull(uint32_t section_id, const char *idstr, uint32_t instance_id, uint32_t version_id) "%u(%s) %u %u"
|
|
|
|
|
qemu_savevm_send_packaged(void) ""
|
2017-06-28 12:52:26 +03:00
|
|
|
loadvm_state_setup(void) ""
|
|
|
|
|
loadvm_state_cleanup(void) ""
|
2016-06-16 11:39:51 +03:00
|
|
|
loadvm_handle_cmd_packaged(unsigned int length) "%u"
|
|
|
|
|
loadvm_handle_cmd_packaged_main(int ret) "%d"
|
|
|
|
|
loadvm_handle_cmd_packaged_received(int ret) "%d"
|
2018-05-02 13:47:27 +03:00
|
|
|
loadvm_handle_recv_bitmap(char *s) "%s"
|
2016-06-16 11:39:51 +03:00
|
|
|
loadvm_postcopy_handle_advise(void) ""
|
|
|
|
|
loadvm_postcopy_handle_listen(void) ""
|
|
|
|
|
loadvm_postcopy_handle_run(void) ""
|
|
|
|
|
loadvm_postcopy_handle_run_cpu_sync(void) ""
|
|
|
|
|
loadvm_postcopy_handle_run_vmstart(void) ""
|
2018-05-02 13:47:29 +03:00
|
|
|
loadvm_postcopy_handle_resume(void) ""
|
2016-06-16 11:39:51 +03:00
|
|
|
loadvm_postcopy_ram_handle_discard(void) ""
|
|
|
|
|
loadvm_postcopy_ram_handle_discard_end(void) ""
|
|
|
|
|
loadvm_postcopy_ram_handle_discard_header(const char *ramid, uint16_t len) "%s: %ud"
|
|
|
|
|
loadvm_process_command(uint16_t com, uint16_t len) "com=0x%x len=%d"
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
loadvm_process_command_ping(uint32_t val) "0x%x"
|
2016-06-16 11:39:51 +03:00
|
|
|
postcopy_ram_listen_thread_exit(void) ""
|
|
|
|
|
postcopy_ram_listen_thread_start(void) ""
|
|
|
|
|
qemu_savevm_send_postcopy_advise(void) ""
|
|
|
|
|
qemu_savevm_send_postcopy_ram_discard(const char *id, uint16_t len) "%s: %ud"
|
|
|
|
|
savevm_command_send(uint16_t command, uint16_t len) "com=0x%x len=%d"
|
|
|
|
|
savevm_section_start(const char *id, unsigned int section_id) "%s, section_id %u"
|
|
|
|
|
savevm_section_end(const char *id, unsigned int section_id, int ret) "%s, section_id %u -> %d"
|
|
|
|
|
savevm_section_skip(const char *id, unsigned int section_id) "%s, section_id %u"
|
|
|
|
|
savevm_send_open_return_path(void) ""
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
savevm_send_ping(uint32_t val) "0x%x"
|
2016-06-16 11:39:51 +03:00
|
|
|
savevm_send_postcopy_listen(void) ""
|
|
|
|
|
savevm_send_postcopy_run(void) ""
|
2018-05-02 13:47:29 +03:00
|
|
|
savevm_send_postcopy_resume(void) ""
|
2018-09-03 07:38:47 +03:00
|
|
|
savevm_send_colo_enable(void) ""
|
2018-05-02 13:47:27 +03:00
|
|
|
savevm_send_recv_bitmap(char *name) "%s"
|
2017-06-28 12:52:24 +03:00
|
|
|
savevm_state_setup(void) ""
|
2018-05-02 13:47:31 +03:00
|
|
|
savevm_state_resume_prepare(void) ""
|
2016-06-16 11:39:51 +03:00
|
|
|
savevm_state_header(void) ""
|
|
|
|
|
savevm_state_iterate(void) ""
|
|
|
|
|
savevm_state_cleanup(void) ""
|
|
|
|
|
savevm_state_complete_precopy(void) ""
|
|
|
|
|
vmstate_save(const char *idstr, const char *vmsd_name) "%s, %s"
|
2017-09-25 14:29:13 +03:00
|
|
|
vmstate_save_state_pre_save_res(const char *name, int res) "%s/%d"
|
2016-12-12 15:58:38 +03:00
|
|
|
vmstate_save_state_loop(const char *name, const char *field, int n_elems) "%s/%s[%d]"
|
|
|
|
|
vmstate_save_state_top(const char *idstr) "%s"
|
|
|
|
|
vmstate_subsection_save_loop(const char *name, const char *sub) "%s/%s"
|
|
|
|
|
vmstate_subsection_save_top(const char *idstr) "%s"
|
2016-06-16 11:39:51 +03:00
|
|
|
vmstate_load(const char *idstr, const char *vmsd_name) "%s, %s"
|
|
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# vmstate.c
|
2016-06-16 11:39:51 +03:00
|
|
|
vmstate_load_field_error(const char *field, int ret) "field \"%s\" load failed, ret = %d"
|
|
|
|
|
vmstate_load_state(const char *name, int version_id) "%s v%d"
|
|
|
|
|
vmstate_load_state_end(const char *name, const char *reason, int val) "%s %s/%d"
|
|
|
|
|
vmstate_load_state_field(const char *name, const char *field) "%s:%s"
|
|
|
|
|
vmstate_n_elems(const char *name, int n_elems) "%s: %d"
|
|
|
|
|
vmstate_subsection_load(const char *parent) "%s"
|
|
|
|
|
vmstate_subsection_load_bad(const char *parent, const char *sub, const char *sub2) "%s: %s/%s"
|
|
|
|
|
vmstate_subsection_load_good(const char *parent) "%s"
|
2017-01-19 22:00:51 +03:00
|
|
|
get_qtailq(const char *name, int version_id) "%s v%d"
|
|
|
|
|
get_qtailq_end(const char *name, const char *reason, int val) "%s %s/%d"
|
|
|
|
|
put_qtailq(const char *name, int version_id) "%s v%d"
|
|
|
|
|
put_qtailq_end(const char *name, const char *reason) "%s %s"
|
2016-06-16 11:39:51 +03:00
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# qemu-file.c
|
2016-06-16 11:39:51 +03:00
|
|
|
qemu_file_fclose(void) ""
|
|
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# ram.c
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
get_queued_page(const char *block_name, uint64_t tmp_offset, unsigned long page_abs) "%s/0x%" PRIx64 " page_abs=0x%lx"
|
|
|
|
|
get_queued_page_not_dirty(const char *block_name, uint64_t tmp_offset, unsigned long page_abs, int sent) "%s/0x%" PRIx64 " page_abs=0x%lx (sent=%d)"
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_bitmap_sync_start(void) ""
|
|
|
|
|
migration_bitmap_sync_end(uint64_t dirty_pages) "dirty_pages %" PRIu64
|
|
|
|
|
migration_throttle(void) ""
|
2018-04-11 04:02:10 +03:00
|
|
|
multifd_recv(uint8_t id, uint64_t packet_num, uint32_t used, uint32_t flags) "channel %d packet number %" PRIu64 " pages %d flags 0x%x"
|
2018-02-28 11:10:07 +03:00
|
|
|
multifd_recv_sync_main(long packet_num) "packet num %ld"
|
|
|
|
|
multifd_recv_sync_main_signal(uint8_t id) "channel %d"
|
|
|
|
|
multifd_recv_sync_main_wait(uint8_t id) "channel %d"
|
2018-04-06 19:28:59 +03:00
|
|
|
multifd_recv_thread_end(uint8_t id, uint64_t packets, uint64_t pages) "channel %d packets %" PRIu64 " pages %" PRIu64
|
|
|
|
|
multifd_recv_thread_start(uint8_t id) "%d"
|
2018-04-11 04:02:10 +03:00
|
|
|
multifd_send(uint8_t id, uint64_t packet_num, uint32_t used, uint32_t flags) "channel %d packet_num %" PRIu64 " pages %d flags 0x%x"
|
2018-02-28 11:10:07 +03:00
|
|
|
multifd_send_sync_main(long packet_num) "packet num %ld"
|
|
|
|
|
multifd_send_sync_main_signal(uint8_t id) "channel %d"
|
|
|
|
|
multifd_send_sync_main_wait(uint8_t id) "channel %d"
|
2018-04-06 19:28:59 +03:00
|
|
|
multifd_send_thread_end(uint8_t id, uint64_t packets, uint64_t pages) "channel %d packets %" PRIu64 " pages %" PRIu64
|
|
|
|
|
multifd_send_thread_start(uint8_t id) "%d"
|
2017-02-24 21:28:32 +03:00
|
|
|
ram_discard_range(const char *rbname, uint64_t start, size_t len) "%s: start: %" PRIx64 " %zx"
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
ram_load_loop(const char *rbname, uint64_t addr, int flags, void *host) "%s: addr: 0x%" PRIx64 " flags: 0x%x host: %p"
|
2016-06-16 11:39:51 +03:00
|
|
|
ram_load_postcopy_loop(uint64_t addr, int flags) "@%" PRIx64 " %x"
|
|
|
|
|
ram_postcopy_send_discard_bitmap(void) ""
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
ram_save_page(const char *rbname, uint64_t offset, void *host) "%s: offset: 0x%" PRIx64 " host: %p"
|
|
|
|
|
ram_save_queue_pages(const char *rbname, size_t start, size_t len) "%s: start: 0x%zx len: 0x%zx"
|
migration: synchronize dirty bitmap for resume
This patch implements the first part of core RAM resume logic for
postcopy. ram_resume_prepare() is provided for the work.
When the migration is interrupted by network failure, the dirty bitmap
on the source side will be meaningless, because even the dirty bit is
cleared, it is still possible that the sent page was lost along the way
to destination. Here instead of continue the migration with the old
dirty bitmap on source, we ask the destination side to send back its
received bitmap, then invert it to be our initial dirty bitmap.
The source side send thread will issue the MIG_CMD_RECV_BITMAP requests,
once per ramblock, to ask for the received bitmap. On destination side,
MIG_RP_MSG_RECV_BITMAP will be issued, along with the requested bitmap.
Data will be received on the return-path thread of source, and the main
migration thread will be notified when all the ramblock bitmaps are
synchronized.
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Peter Xu <peterx@redhat.com>
Message-Id: <20180502104740.12123-17-peterx@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
2018-05-02 13:47:32 +03:00
|
|
|
ram_dirty_bitmap_request(char *str) "%s"
|
2018-05-02 13:47:28 +03:00
|
|
|
ram_dirty_bitmap_reload_begin(char *str) "%s"
|
|
|
|
|
ram_dirty_bitmap_reload_complete(char *str) "%s"
|
migration: synchronize dirty bitmap for resume
This patch implements the first part of core RAM resume logic for
postcopy. ram_resume_prepare() is provided for the work.
When the migration is interrupted by network failure, the dirty bitmap
on the source side will be meaningless, because even the dirty bit is
cleared, it is still possible that the sent page was lost along the way
to destination. Here instead of continue the migration with the old
dirty bitmap on source, we ask the destination side to send back its
received bitmap, then invert it to be our initial dirty bitmap.
The source side send thread will issue the MIG_CMD_RECV_BITMAP requests,
once per ramblock, to ask for the received bitmap. On destination side,
MIG_RP_MSG_RECV_BITMAP will be issued, along with the requested bitmap.
Data will be received on the return-path thread of source, and the main
migration thread will be notified when all the ramblock bitmaps are
synchronized.
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Peter Xu <peterx@redhat.com>
Message-Id: <20180502104740.12123-17-peterx@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
2018-05-02 13:47:32 +03:00
|
|
|
ram_dirty_bitmap_sync_start(void) ""
|
|
|
|
|
ram_dirty_bitmap_sync_wait(void) ""
|
|
|
|
|
ram_dirty_bitmap_sync_complete(void) ""
|
2018-05-02 13:47:33 +03:00
|
|
|
ram_state_resume_prepare(uint64_t v) "%" PRId64
|
2018-09-03 07:38:50 +03:00
|
|
|
colo_flush_ram_cache_begin(uint64_t dirty_pages) "dirty_pages %" PRIu64
|
|
|
|
|
colo_flush_ram_cache_end(void) ""
|
2016-06-16 11:39:51 +03:00
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# migration.c
|
2016-06-16 11:39:51 +03:00
|
|
|
await_return_path_close_on_source_close(void) ""
|
|
|
|
|
await_return_path_close_on_source_joining(void) ""
|
2017-08-30 11:32:01 +03:00
|
|
|
migrate_set_state(const char *new_state) "new state %s"
|
2016-06-16 11:39:51 +03:00
|
|
|
migrate_fd_cleanup(void) ""
|
|
|
|
|
migrate_fd_error(const char *error_desc) "error=%s"
|
|
|
|
|
migrate_fd_cancel(void) ""
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
migrate_handle_rp_req_pages(const char *rbname, size_t start, size_t len) "in %s at 0x%zx len 0x%zx"
|
2018-03-13 22:34:00 +03:00
|
|
|
migrate_pending(uint64_t size, uint64_t max, uint64_t pre, uint64_t compat, uint64_t post) "pending size %" PRIu64 " max %" PRIu64 " (pre = %" PRIu64 " compat=%" PRIu64 " post=%" PRIu64 ")"
|
2016-06-16 11:39:51 +03:00
|
|
|
migrate_send_rp_message(int msg_type, uint16_t len) "%d: len %d"
|
2018-05-02 13:47:28 +03:00
|
|
|
migrate_send_rp_recv_bitmap(char *name, int64_t size) "block '%s' size 0x%"PRIi64
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_completion_file_err(void) ""
|
|
|
|
|
migration_completion_postcopy_end(void) ""
|
|
|
|
|
migration_completion_postcopy_end_after_complete(void) ""
|
2017-05-31 13:35:34 +03:00
|
|
|
migration_return_path_end_before(void) ""
|
|
|
|
|
migration_return_path_end_after(int rp_error) "%d"
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_thread_after_loop(void) ""
|
|
|
|
|
migration_thread_file_err(void) ""
|
2018-06-13 13:26:41 +03:00
|
|
|
migration_thread_ratelimit_pre(int ms) "%d ms"
|
|
|
|
|
migration_thread_ratelimit_post(int urgent) "urgent: %d"
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_thread_setup_complete(void) ""
|
|
|
|
|
open_return_path_on_source(void) ""
|
|
|
|
|
open_return_path_on_source_continue(void) ""
|
|
|
|
|
postcopy_start(void) ""
|
2018-05-02 13:47:21 +03:00
|
|
|
postcopy_pause_return_path(void) ""
|
|
|
|
|
postcopy_pause_return_path_continued(void) ""
|
2018-05-02 13:47:22 +03:00
|
|
|
postcopy_pause_fault_thread(void) ""
|
|
|
|
|
postcopy_pause_fault_thread_continued(void) ""
|
2018-05-02 13:47:19 +03:00
|
|
|
postcopy_pause_continued(void) ""
|
2018-05-02 13:47:20 +03:00
|
|
|
postcopy_pause_incoming(void) ""
|
|
|
|
|
postcopy_pause_incoming_continued(void) ""
|
2016-06-16 11:39:51 +03:00
|
|
|
postcopy_start_set_run(void) ""
|
|
|
|
|
source_return_path_thread_bad_end(void) ""
|
|
|
|
|
source_return_path_thread_end(void) ""
|
|
|
|
|
source_return_path_thread_entry(void) ""
|
|
|
|
|
source_return_path_thread_loop_top(void) ""
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
source_return_path_thread_pong(uint32_t val) "0x%x"
|
|
|
|
|
source_return_path_thread_shut(uint32_t val) "0x%x"
|
2018-05-02 13:47:30 +03:00
|
|
|
source_return_path_thread_resume_ack(uint32_t v) "%"PRIu32
|
2016-06-16 11:39:51 +03:00
|
|
|
migrate_global_state_post_load(const char *state) "loaded state: %s"
|
|
|
|
|
migrate_global_state_pre_save(const char *state) "saved state: %s"
|
|
|
|
|
migration_thread_low_pending(uint64_t pending) "%" PRIu64
|
|
|
|
|
migrate_state_too_big(void) ""
|
2018-06-21 18:02:54 +03:00
|
|
|
migrate_transferred(uint64_t tranferred, uint64_t time_spent, uint64_t bandwidth, uint64_t size) "transferred %" PRIu64 " time_spent %" PRIu64 " bandwidth %" PRIu64 " max_size %" PRId64
|
2016-06-16 11:39:51 +03:00
|
|
|
process_incoming_migration_co_end(int ret, int ps) "ret=%d postcopy-state=%d"
|
|
|
|
|
process_incoming_migration_co_postcopy_end_main(void) ""
|
|
|
|
|
migration_set_incoming_channel(void *ioc, const char *ioctype) "ioc=%p ioctype=%s"
|
2017-12-15 20:16:55 +03:00
|
|
|
migration_set_outgoing_channel(void *ioc, const char *ioctype, const char *hostname, void *err) "ioc=%p ioctype=%s hostname=%s err=%p"
|
2018-03-22 21:17:24 +03:00
|
|
|
mark_postcopy_blocktime_begin(uint64_t addr, void *dd, uint32_t time, int cpu, int received) "addr: 0x%" PRIx64 ", dd: %p, time: %u, cpu: %d, already_received: %d"
|
|
|
|
|
mark_postcopy_blocktime_end(uint64_t addr, void *dd, uint32_t time, int affected_cpu) "addr: 0x%" PRIx64 ", dd: %p, time: %u, affected_cpu: %d"
|
2016-06-16 11:39:51 +03:00
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# rdma.c
|
2016-06-16 11:39:51 +03:00
|
|
|
qemu_rdma_accept_incoming_migration(void) ""
|
|
|
|
|
qemu_rdma_accept_incoming_migration_accepted(void) ""
|
|
|
|
|
qemu_rdma_accept_pin_state(bool pin) "%d"
|
|
|
|
|
qemu_rdma_accept_pin_verbsc(void *verbs) "Verbs context after listen: %p"
|
|
|
|
|
qemu_rdma_block_for_wrid_miss(const char *wcompstr, int wcomp, const char *gcompstr, uint64_t req) "A Wanted wrid %s (%d) but got %s (%" PRIu64 ")"
|
|
|
|
|
qemu_rdma_cleanup_disconnect(void) ""
|
|
|
|
|
qemu_rdma_close(void) ""
|
|
|
|
|
qemu_rdma_connect_pin_all_requested(void) ""
|
|
|
|
|
qemu_rdma_connect_pin_all_outcome(bool pin) "%d"
|
|
|
|
|
qemu_rdma_dest_init_trying(const char *host, const char *ip) "%s => %s"
|
|
|
|
|
qemu_rdma_dump_gid(const char *who, const char *src, const char *dst) "%s Source GID: %s, Dest GID: %s"
|
|
|
|
|
qemu_rdma_exchange_get_response_start(const char *desc) "CONTROL: %s receiving..."
|
|
|
|
|
qemu_rdma_exchange_get_response_none(const char *desc, int type) "Surprise: got %s (%d)"
|
|
|
|
|
qemu_rdma_exchange_send_issue_callback(void) ""
|
|
|
|
|
qemu_rdma_exchange_send_waiting(const char *desc) "Waiting for response %s"
|
|
|
|
|
qemu_rdma_exchange_send_received(const char *desc) "Response %s received."
|
|
|
|
|
qemu_rdma_fill(size_t control_len, size_t size) "RDMA %zd of %zd bytes already in buffer"
|
|
|
|
|
qemu_rdma_init_ram_blocks(int blocks) "Allocated %d local ram block structures"
|
|
|
|
|
qemu_rdma_poll_recv(const char *compstr, int64_t comp, int64_t id, int sent) "completion %s #%" PRId64 " received (%" PRId64 ") left %d"
|
|
|
|
|
qemu_rdma_poll_write(const char *compstr, int64_t comp, int left, uint64_t block, uint64_t chunk, void *local, void *remote) "completions %s (%" PRId64 ") left %d, block %" PRIu64 ", chunk: %" PRIu64 " %p %p"
|
|
|
|
|
qemu_rdma_poll_other(const char *compstr, int64_t comp, int left) "other completion %s (%" PRId64 ") received left %d"
|
|
|
|
|
qemu_rdma_post_send_control(const char *desc) "CONTROL: sending %s.."
|
|
|
|
|
qemu_rdma_register_and_get_keys(uint64_t len, void *start) "Registering %" PRIu64 " bytes @ %p"
|
|
|
|
|
qemu_rdma_registration_handle_compress(int64_t length, int index, int64_t offset) "Zapping zero chunk: %" PRId64 " bytes, index %d, offset %" PRId64
|
|
|
|
|
qemu_rdma_registration_handle_finished(void) ""
|
|
|
|
|
qemu_rdma_registration_handle_ram_blocks(void) ""
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
qemu_rdma_registration_handle_ram_blocks_loop(const char *name, uint64_t offset, uint64_t length, void *local_host_addr, unsigned int src_index) "%s: @0x%" PRIx64 "/%" PRIu64 " host:@%p src_index: %u"
|
2016-06-16 11:39:51 +03:00
|
|
|
qemu_rdma_registration_handle_register(int requests) "%d requests"
|
|
|
|
|
qemu_rdma_registration_handle_register_loop(int req, int index, uint64_t addr, uint64_t chunks) "Registration request (%d): index %d, current_addr %" PRIu64 " chunks: %" PRIu64
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
qemu_rdma_registration_handle_register_rkey(int rkey) "0x%x"
|
2016-06-16 11:39:51 +03:00
|
|
|
qemu_rdma_registration_handle_unregister(int requests) "%d requests"
|
|
|
|
|
qemu_rdma_registration_handle_unregister_loop(int count, int index, uint64_t chunk) "Unregistration request (%d): index %d, chunk %" PRIu64
|
|
|
|
|
qemu_rdma_registration_handle_unregister_success(uint64_t chunk) "%" PRIu64
|
|
|
|
|
qemu_rdma_registration_handle_wait(void) ""
|
|
|
|
|
qemu_rdma_registration_start(uint64_t flags) "%" PRIu64
|
|
|
|
|
qemu_rdma_registration_stop(uint64_t flags) "%" PRIu64
|
|
|
|
|
qemu_rdma_registration_stop_ram(void) ""
|
|
|
|
|
qemu_rdma_resolve_host_trying(const char *host, const char *ip) "Trying %s => %s"
|
|
|
|
|
qemu_rdma_signal_unregister_append(uint64_t chunk, int pos) "Appending unregister chunk %" PRIu64 " at position %d"
|
|
|
|
|
qemu_rdma_signal_unregister_already(uint64_t chunk) "Unregister chunk %" PRIu64 " already in queue"
|
|
|
|
|
qemu_rdma_unregister_waiting_inflight(uint64_t chunk) "Cannot unregister inflight chunk: %" PRIu64
|
|
|
|
|
qemu_rdma_unregister_waiting_proc(uint64_t chunk, int pos) "Processing unregister for chunk: %" PRIu64 " at position %d"
|
|
|
|
|
qemu_rdma_unregister_waiting_send(uint64_t chunk) "Sending unregister for chunk: %" PRIu64
|
|
|
|
|
qemu_rdma_unregister_waiting_complete(uint64_t chunk) "Unregister for chunk: %" PRIu64 " complete."
|
|
|
|
|
qemu_rdma_write_flush(int sent) "sent total: %d"
|
|
|
|
|
qemu_rdma_write_one_block(int count, int block, uint64_t chunk, uint64_t current, uint64_t len, int nb_sent, int nb_chunks) "(%d) Not clobbering: block: %d chunk %" PRIu64 " current %" PRIu64 " len %" PRIu64 " %d %d"
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
qemu_rdma_write_one_post(uint64_t chunk, long addr, long remote, uint32_t len) "Posting chunk: %" PRIu64 ", addr: 0x%lx remote: 0x%lx, bytes %" PRIu32
|
2016-06-16 11:39:51 +03:00
|
|
|
qemu_rdma_write_one_queue_full(void) ""
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
qemu_rdma_write_one_recvregres(int mykey, int theirkey, uint64_t chunk) "Received registration result: my key: 0x%x their key 0x%x, chunk %" PRIu64
|
2016-06-16 11:39:51 +03:00
|
|
|
qemu_rdma_write_one_sendreg(uint64_t chunk, int len, int index, int64_t offset) "Sending registration request chunk %" PRIu64 " for %d bytes, index: %d, offset: %" PRId64
|
|
|
|
|
qemu_rdma_write_one_top(uint64_t chunks, uint64_t size) "Writing %" PRIu64 " chunks, (%" PRIu64 " MB)"
|
|
|
|
|
qemu_rdma_write_one_zero(uint64_t chunk, int len, int index, int64_t offset) "Entire chunk is zero, sending compress: %" PRIu64 " for %d bytes, index: %d, offset: %" PRId64
|
|
|
|
|
rdma_add_block(const char *block_name, int block, uint64_t addr, uint64_t offset, uint64_t len, uint64_t end, uint64_t bits, int chunks) "Added Block: '%s':%d, addr: %" PRIu64 ", offset: %" PRIu64 " length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d"
|
|
|
|
|
rdma_block_notification_handle(const char *name, int index) "%s at %d"
|
|
|
|
|
rdma_delete_block(void *block, uint64_t addr, uint64_t offset, uint64_t len, uint64_t end, uint64_t bits, int chunks) "Deleted Block: %p, addr: %" PRIu64 ", offset: %" PRIu64 " length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d"
|
|
|
|
|
rdma_start_incoming_migration(void) ""
|
|
|
|
|
rdma_start_incoming_migration_after_dest_init(void) ""
|
|
|
|
|
rdma_start_incoming_migration_after_rdma_listen(void) ""
|
|
|
|
|
rdma_start_outgoing_migration_after_rdma_connect(void) ""
|
|
|
|
|
rdma_start_outgoing_migration_after_rdma_source_init(void) ""
|
|
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# postcopy-ram.c
|
2016-06-16 11:39:51 +03:00
|
|
|
postcopy_discard_send_finish(const char *ramblock, int nwords, int ncmds) "%s mask words sent=%d in %d commands"
|
|
|
|
|
postcopy_discard_send_range(const char *ramblock, unsigned long start, unsigned long length) "%s:%lx/%lx"
|
trace-events: fix code style: print 0x before hex numbers
The only exception are groups of numers separated by symbols
'.', ' ', ':', '/', like 'ab.09.7d'.
This patch is made by the following:
> find . -name trace-events | xargs python script.py
where script.py is the following python script:
=========================
#!/usr/bin/env python
import sys
import re
import fileinput
rhex = '%[-+ *.0-9]*(?:[hljztL]|ll|hh)?(?:x|X|"\s*PRI[xX][^"]*"?)'
rgroup = re.compile('((?:' + rhex + '[.:/ ])+' + rhex + ')')
rbad = re.compile('(?<!0x)' + rhex)
files = sys.argv[1:]
for fname in files:
for line in fileinput.input(fname, inplace=True):
arr = re.split(rgroup, line)
for i in range(0, len(arr), 2):
arr[i] = re.sub(rbad, '0x\g<0>', arr[i])
sys.stdout.write(''.join(arr))
=========================
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Message-id: 20170731160135.12101-5-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-07-31 19:01:35 +03:00
|
|
|
postcopy_cleanup_range(const char *ramblock, void *host_addr, size_t offset, size_t length) "%s: %p offset=0x%zx length=0x%zx"
|
|
|
|
|
postcopy_init_range(const char *ramblock, void *host_addr, size_t offset, size_t length) "%s: %p offset=0x%zx length=0x%zx"
|
|
|
|
|
postcopy_nhp_range(const char *ramblock, void *host_addr, size_t offset, size_t length) "%s: %p offset=0x%zx length=0x%zx"
|
2016-06-16 11:39:51 +03:00
|
|
|
postcopy_place_page(void *host_addr) "host=%p"
|
|
|
|
|
postcopy_place_page_zero(void *host_addr) "host=%p"
|
|
|
|
|
postcopy_ram_enable_notify(void) ""
|
|
|
|
|
postcopy_ram_fault_thread_entry(void) ""
|
|
|
|
|
postcopy_ram_fault_thread_exit(void) ""
|
2018-03-12 20:21:04 +03:00
|
|
|
postcopy_ram_fault_thread_fds_core(int baseufd, int quitfd) "ufd: %d quitfd: %d"
|
|
|
|
|
postcopy_ram_fault_thread_fds_extra(size_t index, const char *name, int fd) "%zd/%s: %d"
|
2016-06-16 11:39:51 +03:00
|
|
|
postcopy_ram_fault_thread_quit(void) ""
|
2018-03-22 21:17:24 +03:00
|
|
|
postcopy_ram_fault_thread_request(uint64_t hostaddr, const char *ramblock, size_t offset, uint32_t pid) "Request for HVA=0x%" PRIx64 " rb=%s offset=0x%zx pid=%u"
|
2016-06-16 11:39:51 +03:00
|
|
|
postcopy_ram_incoming_cleanup_closeuf(void) ""
|
|
|
|
|
postcopy_ram_incoming_cleanup_entry(void) ""
|
|
|
|
|
postcopy_ram_incoming_cleanup_exit(void) ""
|
|
|
|
|
postcopy_ram_incoming_cleanup_join(void) ""
|
2018-03-22 21:17:27 +03:00
|
|
|
postcopy_ram_incoming_cleanup_blocktime(uint64_t total) "total blocktime %" PRIu64
|
2018-03-12 20:21:12 +03:00
|
|
|
postcopy_request_shared_page(const char *sharer, const char *rb, uint64_t rb_offset) "for %s in %s offset 0x%"PRIx64
|
2018-03-12 20:21:17 +03:00
|
|
|
postcopy_request_shared_page_present(const char *sharer, const char *rb, uint64_t rb_offset) "%s already %s offset 0x%"PRIx64
|
2018-03-12 20:21:14 +03:00
|
|
|
postcopy_wake_shared(uint64_t client_addr, const char *rb) "at 0x%"PRIx64" in %s"
|
2018-03-12 20:21:12 +03:00
|
|
|
|
2017-01-24 00:32:05 +03:00
|
|
|
save_xbzrle_page_skipping(void) ""
|
|
|
|
|
save_xbzrle_page_overflow(void) ""
|
|
|
|
|
ram_save_iterate_big_wait(uint64_t milliconds, int iterations) "big wait: %" PRIu64 " milliseconds, %d iterations"
|
|
|
|
|
ram_load_complete(int ret, uint64_t seq_iter) "exit_code %d seq iteration %" PRIu64
|
2018-03-22 21:17:24 +03:00
|
|
|
get_mem_fault_cpu_index(int cpu, uint32_t pid) "cpu: %d, pid: %u"
|
2016-06-16 11:39:51 +03:00
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# exec.c
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_exec_outgoing(const char *cmd) "cmd=%s"
|
|
|
|
|
migration_exec_incoming(const char *cmd) "cmd=%s"
|
|
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# fd.c
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_fd_outgoing(int fd) "fd=%d"
|
|
|
|
|
migration_fd_incoming(int fd) "fd=%d"
|
|
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# socket.c
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_socket_incoming_accepted(void) ""
|
|
|
|
|
migration_socket_outgoing_connected(const char *hostname) "hostname=%s"
|
|
|
|
|
migration_socket_outgoing_error(const char *err) "error=%s"
|
|
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# tls.c
|
2016-06-16 11:39:51 +03:00
|
|
|
migration_tls_outgoing_handshake_start(const char *hostname) "hostname=%s"
|
|
|
|
|
migration_tls_outgoing_handshake_error(const char *err) "err=%s"
|
|
|
|
|
migration_tls_outgoing_handshake_complete(void) ""
|
|
|
|
|
migration_tls_incoming_handshake_start(void) ""
|
|
|
|
|
migration_tls_incoming_handshake_error(const char *err) "err=%s"
|
|
|
|
|
migration_tls_incoming_handshake_complete(void) ""
|
2016-10-27 09:42:54 +03:00
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# colo.c
|
2016-10-27 09:42:54 +03:00
|
|
|
colo_vm_state_change(const char *old, const char *new) "Change '%s' => '%s'"
|
2016-10-27 09:42:57 +03:00
|
|
|
colo_send_message(const char *msg) "Send '%s' message"
|
|
|
|
|
colo_receive_message(const char *msg) "Receive '%s' message"
|
2016-10-27 09:43:04 +03:00
|
|
|
colo_failover_set_state(const char *new_state) "new state %s"
|
2018-03-13 22:34:01 +03:00
|
|
|
|
2019-03-14 21:09:26 +03:00
|
|
|
# block-dirty-bitmap.c
|
2018-03-13 22:34:01 +03:00
|
|
|
send_bitmap_header_enter(void) ""
|
|
|
|
|
send_bitmap_bits(uint32_t flags, uint64_t start_sector, uint32_t nr_sectors, uint64_t data_size) "flags: 0x%x, start_sector: %" PRIu64 ", nr_sectors: %" PRIu32 ", data_size: %" PRIu64
|
|
|
|
|
dirty_bitmap_save_iterate(int in_postcopy) "in postcopy: %d"
|
|
|
|
|
dirty_bitmap_save_complete_enter(void) ""
|
|
|
|
|
dirty_bitmap_save_complete_finish(void) ""
|
|
|
|
|
dirty_bitmap_save_pending(uint64_t pending, uint64_t max_size) "pending %" PRIu64 " max: %" PRIu64
|
|
|
|
|
dirty_bitmap_load_complete(void) ""
|
|
|
|
|
dirty_bitmap_load_bits_enter(uint64_t first_sector, uint32_t nr_sectors) "chunk: %" PRIu64 " %" PRIu32
|
|
|
|
|
dirty_bitmap_load_bits_zeroes(void) ""
|
|
|
|
|
dirty_bitmap_load_header(uint32_t flags) "flags 0x%x"
|
|
|
|
|
dirty_bitmap_load_enter(void) ""
|
|
|
|
|
dirty_bitmap_load_success(void) ""
|