block.h 18.5 KB
Newer Older
pbrook's avatar
pbrook committed
1 2 3
#ifndef BLOCK_H
#define BLOCK_H

4
#include "block/aio.h"
5
#include "qemu-common.h"
6
#include "qemu/option.h"
7
#include "block/coroutine.h"
8
#include "qapi/qmp/qobject.h"
9
#include "qapi-types.h"
10

pbrook's avatar
pbrook committed
11 12
/* block.c */
typedef struct BlockDriver BlockDriver;
13
typedef struct BlockJob BlockJob;
pbrook's avatar
pbrook committed
14 15 16 17 18 19

typedef struct BlockDriverInfo {
    /* in bytes, 0 if irrelevant */
    int cluster_size;
    /* offset at which the VM state can be saved (0 if not possible) */
    int64_t vm_state_offset;
Dong Xu Wang's avatar
Dong Xu Wang committed
20
    bool is_dirty;
pbrook's avatar
pbrook committed
21 22
} BlockDriverInfo;

23 24 25 26
typedef struct BlockFragInfo {
    uint64_t allocated_clusters;
    uint64_t total_clusters;
    uint64_t fragmented_clusters;
27
    uint64_t compressed_clusters;
28 29
} BlockFragInfo;

pbrook's avatar
pbrook committed
30 31 32 33
typedef struct QEMUSnapshotInfo {
    char id_str[128]; /* unique snapshot id */
    /* the following fields are informative. They are not needed for
       the consistency of the snapshot */
34
    char name[256]; /* user chosen name */
Kevin Wolf's avatar
Kevin Wolf committed
35
    uint64_t vm_state_size; /* VM state info size */
pbrook's avatar
pbrook committed
36 37 38 39 40
    uint32_t date_sec; /* UTC date of the snapshot */
    uint32_t date_nsec;
    uint64_t vm_clock_nsec; /* VM clock relative to boot */
} QEMUSnapshotInfo;

41
/* Callbacks for block device models */
42
typedef struct BlockDevOps {
43 44
    /*
     * Runs when virtual media changed (monitor commands eject, change)
45
     * Argument load is true on load and false on eject.
46 47
     * Beware: doesn't run when a host device's physical media
     * changes.  Sure would be useful if it did.
48
     * Device models with removable media must implement this callback.
49
     */
50
    void (*change_media_cb)(void *opaque, bool load);
51 52 53 54 55 56 57 58 59
    /*
     * Runs when an eject request is issued from the monitor, the tray
     * is closed, and the medium is locked.
     * Device models that do not implement is_medium_locked will not need
     * this callback.  Device models that can lock the medium or tray might
     * want to implement the callback and unlock the tray when "force" is
     * true, even if they do not support eject requests.
     */
    void (*eject_request_cb)(void *opaque, bool force);
60 61 62 63 64
    /*
     * Is the virtual tray open?
     * Device models implement this only when the device has a tray.
     */
    bool (*is_tray_open)(void *opaque);
65 66 67 68 69
    /*
     * Is the virtual medium locked into the device?
     * Device models implement this only when device has such a lock.
     */
    bool (*is_medium_locked)(void *opaque);
70 71 72 73
    /*
     * Runs when the size changed (e.g. monitor command block_resize)
     */
    void (*resize_cb)(void *opaque);
74 75
} BlockDevOps;

pbrook's avatar
pbrook committed
76 77
#define BDRV_O_RDWR        0x0002
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
78 79
#define BDRV_O_NOCACHE     0x0020 /* do not use the host page cache */
#define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */
80
#define BDRV_O_NATIVE_AIO  0x0080 /* use native AIO instead of the thread pool */
81
#define BDRV_O_NO_BACKING  0x0100 /* don't open the backing file */
82
#define BDRV_O_NO_FLUSH    0x0200 /* disable flushing on this disk */
83
#define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
84
#define BDRV_O_INCOMING    0x0800  /* consistency hint for incoming migration */
85
#define BDRV_O_CHECK       0x1000  /* open solely for consistency check */
86
#define BDRV_O_ALLOW_RDWR  0x2000  /* allow reopen to change from r/o to r/w */
Paolo Bonzini's avatar
Paolo Bonzini committed
87
#define BDRV_O_UNMAP       0x4000  /* execute guest UNMAP/TRIM operations */
88

Kevin Wolf's avatar
Kevin Wolf committed
89
#define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
pbrook's avatar
pbrook committed
90

91
#define BDRV_SECTOR_BITS   9
92
#define BDRV_SECTOR_SIZE   (1ULL << BDRV_SECTOR_BITS)
93
#define BDRV_SECTOR_MASK   ~(BDRV_SECTOR_SIZE - 1)
94

95 96
typedef enum {
    BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
97
} BlockErrorAction;
98

99 100 101 102 103 104 105 106 107
typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;

typedef struct BDRVReopenState {
    BlockDriverState *bs;
    int flags;
    void *opaque;
} BDRVReopenState;


108 109 110 111 112
void bdrv_iostatus_enable(BlockDriverState *bs);
void bdrv_iostatus_reset(BlockDriverState *bs);
void bdrv_iostatus_disable(BlockDriverState *bs);
bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
113 114
void bdrv_info_print(Monitor *mon, const QObject *data);
void bdrv_info(Monitor *mon, QObject **ret_data);
115 116
void bdrv_stats_print(Monitor *mon, const QObject *data);
void bdrv_info_stats(Monitor *mon, QObject **ret_data);
pbrook's avatar
pbrook committed
117

118 119
/* disk I/O throttling */
void bdrv_io_limits_enable(BlockDriverState *bs);
120
void bdrv_io_limits_disable(BlockDriverState *bs);
121 122
bool bdrv_io_limits_enabled(BlockDriverState *bs);

pbrook's avatar
pbrook committed
123
void bdrv_init(void);
124
void bdrv_init_with_whitelist(void);
125
BlockDriver *bdrv_find_protocol(const char *filename);
pbrook's avatar
pbrook committed
126
BlockDriver *bdrv_find_format(const char *format_name);
127
BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
128 129
int bdrv_create(BlockDriver *drv, const char* filename,
    QEMUOptionParameter *options);
130
int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
pbrook's avatar
pbrook committed
131
BlockDriverState *bdrv_new(const char *device_name);
132
void bdrv_make_anon(BlockDriverState *bs);
133
void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
134
void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
pbrook's avatar
pbrook committed
135
void bdrv_delete(BlockDriverState *bs);
136
int bdrv_parse_cache_flags(const char *mode, int *flags);
Paolo Bonzini's avatar
Paolo Bonzini committed
137
int bdrv_parse_discard_flags(const char *mode, int *flags);
138 139
int bdrv_file_open(BlockDriverState **pbs, const char *filename,
                   QDict *options, int flags);
140
int bdrv_open_backing_file(BlockDriverState *bs, QDict *options);
141 142
int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
              int flags, BlockDriver *drv);
143 144 145 146 147 148 149 150
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
                                    BlockDriverState *bs, int flags);
int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
                        BlockReopenQueue *queue, Error **errp);
void bdrv_reopen_commit(BDRVReopenState *reopen_state);
void bdrv_reopen_abort(BDRVReopenState *reopen_state);
pbrook's avatar
pbrook committed
151
void bdrv_close(BlockDriverState *bs);
Paolo Bonzini's avatar
Paolo Bonzini committed
152
void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify);
153 154 155 156
int bdrv_attach_dev(BlockDriverState *bs, void *dev);
void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
void bdrv_detach_dev(BlockDriverState *bs, void *dev);
void *bdrv_get_attached_dev(BlockDriverState *bs);
157 158
void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
                      void *opaque);
159
void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
160
bool bdrv_dev_has_removable_media(BlockDriverState *bs);
161
bool bdrv_dev_is_tray_open(BlockDriverState *bs);
162
bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
pbrook's avatar
pbrook committed
163 164
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
              uint8_t *buf, int nb_sectors);
165 166
int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
                          uint8_t *buf, int nb_sectors);
pbrook's avatar
pbrook committed
167 168
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
               const uint8_t *buf, int nb_sectors);
169
int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov);
pbrook's avatar
pbrook committed
170 171 172 173
int bdrv_pread(BlockDriverState *bs, int64_t offset,
               void *buf, int count);
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                const void *buf, int count);
174
int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov);
Kevin Wolf's avatar
Kevin Wolf committed
175 176
int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
    const void *buf, int count);
Kevin Wolf's avatar
Kevin Wolf committed
177 178
int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, QEMUIOVector *qiov);
179 180
int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
Kevin Wolf's avatar
Kevin Wolf committed
181 182
int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, QEMUIOVector *qiov);
183 184 185 186 187 188 189 190
/*
 * Efficiently zero a region of the disk image.  Note that this is a regular
 * I/O request like read or write and should have a reasonable size.  This
 * function is not suitable for zeroing the entire image in a single request
 * because it may allocate memory for the entire region.
 */
int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors);
191 192
int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, int *pnum);
193 194 195 196
int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
                                            BlockDriverState *base,
                                            int64_t sector_num,
                                            int nb_sectors, int *pnum);
197 198
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
    const char *backing_file);
199
int bdrv_get_backing_file_depth(BlockDriverState *bs);
pbrook's avatar
pbrook committed
200 201
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
int64_t bdrv_getlength(BlockDriverState *bs);
202
int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
203
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
pbrook's avatar
pbrook committed
204
int bdrv_commit(BlockDriverState *bs);
205
int bdrv_commit_all(void);
206 207
int bdrv_change_backing_file(BlockDriverState *bs,
    const char *backing_file, const char *backing_fmt);
208
void bdrv_register(BlockDriver *bdrv);
209 210 211 212
int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
                           BlockDriverState *base);
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
                                    BlockDriverState *bs);
213
BlockDriverState *bdrv_find_base(BlockDriverState *bs);
214

215 216 217 218 219

typedef struct BdrvCheckResult {
    int corruptions;
    int leaks;
    int check_errors;
220 221
    int corruptions_fixed;
    int leaks_fixed;
222
    int64_t image_end_offset;
223
    BlockFragInfo bfi;
224 225
} BdrvCheckResult;

226 227 228 229 230 231
typedef enum {
    BDRV_FIX_LEAKS    = 1,
    BDRV_FIX_ERRORS   = 2,
} BdrvCheckMode;

int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
232

pbrook's avatar
pbrook committed
233
/* async block I/O */
234
typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
235
                                     int sector_num);
236 237 238 239 240 241
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
                                 QEMUIOVector *iov, int nb_sectors,
                                 BlockDriverCompletionFunc *cb, void *opaque);
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                  QEMUIOVector *iov, int nb_sectors,
                                  BlockDriverCompletionFunc *cb, void *opaque);
242
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
243
                                 BlockDriverCompletionFunc *cb, void *opaque);
244 245 246
BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
                                   int64_t sector_num, int nb_sectors,
                                   BlockDriverCompletionFunc *cb, void *opaque);
pbrook's avatar
pbrook committed
247 248
void bdrv_aio_cancel(BlockDriverAIOCB *acb);

Kevin Wolf's avatar
Kevin Wolf committed
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
typedef struct BlockRequest {
    /* Fields to be filled by multiwrite caller */
    int64_t sector;
    int nb_sectors;
    QEMUIOVector *qiov;
    BlockDriverCompletionFunc *cb;
    void *opaque;

    /* Filled by multiwrite implementation */
    int error;
} BlockRequest;

int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
    int num_reqs);

264
/* sg packet commands */
265 266 267 268
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque);
269

270 271 272 273
/* Invalidate any cached metadata used by image formats */
void bdrv_invalidate_cache(BlockDriverState *bs);
void bdrv_invalidate_cache_all(void);

274 275
void bdrv_clear_incoming_migration_all(void);

pbrook's avatar
pbrook committed
276
/* Ensure contents are flushed to disk.  */
277
int bdrv_flush(BlockDriverState *bs);
278
int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
aliguori's avatar
aliguori committed
279
void bdrv_flush_all(void);
280
void bdrv_close_all(void);
281
void bdrv_drain_all(void);
aliguori's avatar
aliguori committed
282

Christoph Hellwig's avatar
Christoph Hellwig committed
283
int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
284
int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
Kevin Wolf's avatar
Kevin Wolf committed
285
int bdrv_has_zero_init(BlockDriverState *bs);
286
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
287
                      int *pnum);
288 289
int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                            int64_t sector_num, int nb_sectors, int *pnum);
pbrook's avatar
pbrook committed
290

291 292
void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
                       BlockdevOnError on_write_error);
293
BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read);
294 295 296
BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error);
void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
                       bool is_read, int error);
pbrook's avatar
pbrook committed
297
int bdrv_is_read_only(BlockDriverState *bs);
298
int bdrv_is_sg(BlockDriverState *bs);
299
int bdrv_enable_write_cache(BlockDriverState *bs);
300
void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce);
pbrook's avatar
pbrook committed
301 302
int bdrv_is_inserted(BlockDriverState *bs);
int bdrv_media_changed(BlockDriverState *bs);
303
void bdrv_lock_medium(BlockDriverState *bs, bool locked);
304
void bdrv_eject(BlockDriverState *bs, bool eject_flag);
305
const char *bdrv_get_format_name(BlockDriverState *bs);
pbrook's avatar
pbrook committed
306
BlockDriverState *bdrv_find(const char *name);
Markus Armbruster's avatar
Markus Armbruster committed
307
BlockDriverState *bdrv_next(BlockDriverState *bs);
308 309
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
                  void *opaque);
pbrook's avatar
pbrook committed
310
int bdrv_is_encrypted(BlockDriverState *bs);
311
int bdrv_key_required(BlockDriverState *bs);
pbrook's avatar
pbrook committed
312
int bdrv_set_key(BlockDriverState *bs, const char *key);
313
int bdrv_query_missing_keys(void);
pbrook's avatar
pbrook committed
314 315 316
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
                         void *opaque);
const char *bdrv_get_device_name(BlockDriverState *bs);
317
int bdrv_get_flags(BlockDriverState *bs);
pbrook's avatar
pbrook committed
318 319 320
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
                          const uint8_t *buf, int nb_sectors);
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
321 322 323 324
void bdrv_round_to_clusters(BlockDriverState *bs,
                            int64_t sector_num, int nb_sectors,
                            int64_t *cluster_sector_num,
                            int *cluster_nb_sectors);
pbrook's avatar
pbrook committed
325

326
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
pbrook's avatar
pbrook committed
327 328
void bdrv_get_backing_filename(BlockDriverState *bs,
                               char *filename, int filename_size);
329 330
void bdrv_get_full_backing_filename(BlockDriverState *bs,
                                    char *dest, size_t sz);
Paolo Bonzini's avatar
Paolo Bonzini committed
331
BlockInfo *bdrv_query_info(BlockDriverState *s);
Paolo Bonzini's avatar
Paolo Bonzini committed
332
BlockStats *bdrv_query_stats(const BlockDriverState *bs);
333
int bdrv_can_snapshot(BlockDriverState *bs);
334
int bdrv_is_snapshot(BlockDriverState *bs);
335
BlockDriverState *bdrv_snapshots(void);
pbrook's avatar
pbrook committed
336 337 338 339 340 341 342
int bdrv_snapshot_create(BlockDriverState *bs,
                         QEMUSnapshotInfo *sn_info);
int bdrv_snapshot_goto(BlockDriverState *bs,
                       const char *snapshot_id);
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
int bdrv_snapshot_list(BlockDriverState *bs,
                       QEMUSnapshotInfo **psn_info);
edison's avatar
edison committed
343 344
int bdrv_snapshot_load_tmp(BlockDriverState *bs,
                           const char *snapshot_name);
pbrook's avatar
pbrook committed
345 346 347 348 349 350 351 352
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);

char *get_human_readable_size(char *buf, int buf_size, int64_t size);
int path_is_absolute(const char *path);
void path_combine(char *dest, int dest_size,
                  const char *base_path,
                  const char *filename);

353
int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
354 355
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                      int64_t pos, int size);
356

357 358
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                      int64_t pos, int size);
359

360 361
void bdrv_img_create(const char *filename, const char *fmt,
                     const char *base_filename, const char *base_fmt,
362 363
                     char *options, uint64_t img_size, int flags,
                     Error **errp, bool quiet);
364

365
void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
366
void *qemu_blockalign(BlockDriverState *bs, size_t size);
367
bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
368

369
struct HBitmapIter;
370
void bdrv_set_dirty_tracking(BlockDriverState *bs, int granularity);
371
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
372 373
void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
374
void bdrv_dirty_iter_init(BlockDriverState *bs, struct HBitmapIter *hbi);
375
int64_t bdrv_get_dirty_count(BlockDriverState *bs);
Kevin Wolf's avatar
Kevin Wolf committed
376

377 378 379
void bdrv_enable_copy_on_read(BlockDriverState *bs);
void bdrv_disable_copy_on_read(BlockDriverState *bs);

380 381
void bdrv_set_in_use(BlockDriverState *bs, int in_use);
int bdrv_in_use(BlockDriverState *bs);
Kevin Wolf's avatar
Kevin Wolf committed
382

383 384 385 386 387 388 389 390 391
#ifdef CONFIG_LINUX_AIO
int raw_get_aio_fd(BlockDriverState *bs);
#else
static inline int raw_get_aio_fd(BlockDriverState *bs)
{
    return -ENOTSUP;
}
#endif

392 393 394 395 396 397 398 399 400
enum BlockAcctType {
    BDRV_ACCT_READ,
    BDRV_ACCT_WRITE,
    BDRV_ACCT_FLUSH,
    BDRV_MAX_IOTYPE,
};

typedef struct BlockAcctCookie {
    int64_t bytes;
Christoph Hellwig's avatar
Christoph Hellwig committed
401
    int64_t start_time_ns;
402 403 404 405 406 407 408
    enum BlockAcctType type;
} BlockAcctCookie;

void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
        int64_t bytes, enum BlockAcctType type);
void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);

Kevin Wolf's avatar
Kevin Wolf committed
409
typedef enum {
Kevin Wolf's avatar
Kevin Wolf committed
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
    BLKDBG_L1_UPDATE,

    BLKDBG_L1_GROW_ALLOC_TABLE,
    BLKDBG_L1_GROW_WRITE_TABLE,
    BLKDBG_L1_GROW_ACTIVATE_TABLE,

    BLKDBG_L2_LOAD,
    BLKDBG_L2_UPDATE,
    BLKDBG_L2_UPDATE_COMPRESSED,
    BLKDBG_L2_ALLOC_COW_READ,
    BLKDBG_L2_ALLOC_WRITE,

    BLKDBG_READ_AIO,
    BLKDBG_READ_BACKING_AIO,
    BLKDBG_READ_COMPRESSED,

    BLKDBG_WRITE_AIO,
    BLKDBG_WRITE_COMPRESSED,

    BLKDBG_VMSTATE_LOAD,
    BLKDBG_VMSTATE_SAVE,

    BLKDBG_COW_READ,
    BLKDBG_COW_WRITE,

    BLKDBG_REFTABLE_LOAD,
    BLKDBG_REFTABLE_GROW,

    BLKDBG_REFBLOCK_LOAD,
    BLKDBG_REFBLOCK_UPDATE,
    BLKDBG_REFBLOCK_UPDATE_PART,
    BLKDBG_REFBLOCK_ALLOC,
    BLKDBG_REFBLOCK_ALLOC_HOOKUP,
    BLKDBG_REFBLOCK_ALLOC_WRITE,
    BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
    BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
    BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,

    BLKDBG_CLUSTER_ALLOC,
    BLKDBG_CLUSTER_ALLOC_BYTES,
    BLKDBG_CLUSTER_FREE,

Kevin Wolf's avatar
Kevin Wolf committed
452 453 454 455 456 457
    BLKDBG_EVENT_MAX,
} BlkDebugEvent;

#define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);

458 459 460 461 462
int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
                           const char *tag);
int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);

463
#endif