block.h 17.7 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 27 28
typedef struct BlockFragInfo {
    uint64_t allocated_clusters;
    uint64_t total_clusters;
    uint64_t fragmented_clusters;
} BlockFragInfo;

pbrook's avatar
pbrook committed
29 30 31 32
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 */
33
    char name[256]; /* user chosen name */
Kevin Wolf's avatar
Kevin Wolf committed
34
    uint64_t vm_state_size; /* VM state info size */
pbrook's avatar
pbrook committed
35 36 37 38 39
    uint32_t date_sec; /* UTC date of the snapshot */
    uint32_t date_nsec;
    uint64_t vm_clock_nsec; /* VM clock relative to boot */
} QEMUSnapshotInfo;

40
/* Callbacks for block device models */
41
typedef struct BlockDevOps {
42 43
    /*
     * Runs when virtual media changed (monitor commands eject, change)
44
     * Argument load is true on load and false on eject.
45 46
     * Beware: doesn't run when a host device's physical media
     * changes.  Sure would be useful if it did.
47
     * Device models with removable media must implement this callback.
48
     */
49
    void (*change_media_cb)(void *opaque, bool load);
50 51 52 53 54 55 56 57 58
    /*
     * 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);
59 60 61 62 63
    /*
     * Is the virtual tray open?
     * Device models implement this only when the device has a tray.
     */
    bool (*is_tray_open)(void *opaque);
64 65 66 67 68
    /*
     * 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);
69 70 71 72
    /*
     * Runs when the size changed (e.g. monitor command block_resize)
     */
    void (*resize_cb)(void *opaque);
73 74
} BlockDevOps;

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

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

89
#define BDRV_SECTOR_BITS   9
90
#define BDRV_SECTOR_SIZE   (1ULL << BDRV_SECTOR_BITS)
91
#define BDRV_SECTOR_MASK   ~(BDRV_SECTOR_SIZE - 1)
92

93 94
typedef enum {
    BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
95
} BlockErrorAction;
96

97 98 99 100 101 102 103 104 105
typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;

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


106 107 108 109 110
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);
111 112
void bdrv_info_print(Monitor *mon, const QObject *data);
void bdrv_info(Monitor *mon, QObject **ret_data);
113 114
void bdrv_stats_print(Monitor *mon, const QObject *data);
void bdrv_info_stats(Monitor *mon, QObject **ret_data);
pbrook's avatar
pbrook committed
115

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

pbrook's avatar
pbrook committed
121
void bdrv_init(void);
122
void bdrv_init_with_whitelist(void);
123
BlockDriver *bdrv_find_protocol(const char *filename);
pbrook's avatar
pbrook committed
124
BlockDriver *bdrv_find_format(const char *format_name);
125
BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
126 127
int bdrv_create(BlockDriver *drv, const char* filename,
    QEMUOptionParameter *options);
128
int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
pbrook's avatar
pbrook committed
129
BlockDriverState *bdrv_new(const char *device_name);
130
void bdrv_make_anon(BlockDriverState *bs);
131
void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
132
void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
pbrook's avatar
pbrook committed
133
void bdrv_delete(BlockDriverState *bs);
134
int bdrv_parse_cache_flags(const char *mode, int *flags);
pbrook's avatar
pbrook committed
135
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
136
int bdrv_open_backing_file(BlockDriverState *bs);
Kevin Wolf's avatar
Kevin Wolf committed
137 138
int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
              BlockDriver *drv);
139 140 141 142 143 144 145 146
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
147
void bdrv_close(BlockDriverState *bs);
Paolo Bonzini's avatar
Paolo Bonzini committed
148
void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify);
149 150 151 152
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);
153 154
void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
                      void *opaque);
155
void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
156
bool bdrv_dev_has_removable_media(BlockDriverState *bs);
157
bool bdrv_dev_is_tray_open(BlockDriverState *bs);
158
bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
pbrook's avatar
pbrook committed
159 160
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
              uint8_t *buf, int nb_sectors);
161 162
int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
                          uint8_t *buf, int nb_sectors);
pbrook's avatar
pbrook committed
163 164 165 166 167 168
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
               const uint8_t *buf, int nb_sectors);
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);
Kevin Wolf's avatar
Kevin Wolf committed
169 170
int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
    const void *buf, int count);
Kevin Wolf's avatar
Kevin Wolf committed
171 172
int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, QEMUIOVector *qiov);
173 174
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
175 176
int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, QEMUIOVector *qiov);
177 178 179 180 181 182 183 184
/*
 * 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);
185 186
int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, int *pnum);
187 188 189 190
int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
                                            BlockDriverState *base,
                                            int64_t sector_num,
                                            int nb_sectors, int *pnum);
191 192
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
    const char *backing_file);
193
int bdrv_get_backing_file_depth(BlockDriverState *bs);
pbrook's avatar
pbrook committed
194 195
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
int64_t bdrv_getlength(BlockDriverState *bs);
196
int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
197
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
pbrook's avatar
pbrook committed
198
int bdrv_commit(BlockDriverState *bs);
199
int bdrv_commit_all(void);
200 201
int bdrv_change_backing_file(BlockDriverState *bs,
    const char *backing_file, const char *backing_fmt);
202
void bdrv_register(BlockDriver *bdrv);
203 204 205 206
int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
                           BlockDriverState *base);
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
                                    BlockDriverState *bs);
207
BlockDriverState *bdrv_find_base(BlockDriverState *bs);
208

209 210 211 212 213

typedef struct BdrvCheckResult {
    int corruptions;
    int leaks;
    int check_errors;
214 215
    int corruptions_fixed;
    int leaks_fixed;
216
    BlockFragInfo bfi;
217 218
} BdrvCheckResult;

219 220 221 222 223 224
typedef enum {
    BDRV_FIX_LEAKS    = 1,
    BDRV_FIX_ERRORS   = 2,
} BdrvCheckMode;

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

pbrook's avatar
pbrook committed
226
/* async block I/O */
227
typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
228
                                     int sector_num);
229 230 231 232 233 234
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);
235
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
236
                                 BlockDriverCompletionFunc *cb, void *opaque);
237 238 239
BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
                                   int64_t sector_num, int nb_sectors,
                                   BlockDriverCompletionFunc *cb, void *opaque);
pbrook's avatar
pbrook committed
240 241
void bdrv_aio_cancel(BlockDriverAIOCB *acb);

Kevin Wolf's avatar
Kevin Wolf committed
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
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);

257
/* sg packet commands */
258 259 260 261
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);
262

263 264 265 266
/* Invalidate any cached metadata used by image formats */
void bdrv_invalidate_cache(BlockDriverState *bs);
void bdrv_invalidate_cache_all(void);

267 268
void bdrv_clear_incoming_migration_all(void);

pbrook's avatar
pbrook committed
269
/* Ensure contents are flushed to disk.  */
270
int bdrv_flush(BlockDriverState *bs);
271
int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
aliguori's avatar
aliguori committed
272
void bdrv_flush_all(void);
273
void bdrv_close_all(void);
274
void bdrv_drain_all(void);
aliguori's avatar
aliguori committed
275

Christoph Hellwig's avatar
Christoph Hellwig committed
276
int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
277
int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
Kevin Wolf's avatar
Kevin Wolf committed
278
int bdrv_has_zero_init(BlockDriverState *bs);
279
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
280
                      int *pnum);
pbrook's avatar
pbrook committed
281

282 283
void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
                       BlockdevOnError on_write_error);
284
BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read);
285 286 287
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
288
int bdrv_is_read_only(BlockDriverState *bs);
289
int bdrv_is_sg(BlockDriverState *bs);
290
int bdrv_enable_write_cache(BlockDriverState *bs);
291
void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce);
pbrook's avatar
pbrook committed
292 293
int bdrv_is_inserted(BlockDriverState *bs);
int bdrv_media_changed(BlockDriverState *bs);
294
void bdrv_lock_medium(BlockDriverState *bs, bool locked);
295
void bdrv_eject(BlockDriverState *bs, bool eject_flag);
296
const char *bdrv_get_format_name(BlockDriverState *bs);
pbrook's avatar
pbrook committed
297
BlockDriverState *bdrv_find(const char *name);
Markus Armbruster's avatar
Markus Armbruster committed
298
BlockDriverState *bdrv_next(BlockDriverState *bs);
299 300
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
                  void *opaque);
pbrook's avatar
pbrook committed
301
int bdrv_is_encrypted(BlockDriverState *bs);
302
int bdrv_key_required(BlockDriverState *bs);
pbrook's avatar
pbrook committed
303
int bdrv_set_key(BlockDriverState *bs, const char *key);
304
int bdrv_query_missing_keys(void);
pbrook's avatar
pbrook committed
305 306 307
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
                         void *opaque);
const char *bdrv_get_device_name(BlockDriverState *bs);
308
int bdrv_get_flags(BlockDriverState *bs);
pbrook's avatar
pbrook committed
309 310 311 312
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);

313
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
pbrook's avatar
pbrook committed
314 315
void bdrv_get_backing_filename(BlockDriverState *bs,
                               char *filename, int filename_size);
316 317
void bdrv_get_full_backing_filename(BlockDriverState *bs,
                                    char *dest, size_t sz);
Paolo Bonzini's avatar
Paolo Bonzini committed
318
BlockInfo *bdrv_query_info(BlockDriverState *s);
Paolo Bonzini's avatar
Paolo Bonzini committed
319
BlockStats *bdrv_query_stats(const BlockDriverState *bs);
320
int bdrv_can_snapshot(BlockDriverState *bs);
321
int bdrv_is_snapshot(BlockDriverState *bs);
322
BlockDriverState *bdrv_snapshots(void);
pbrook's avatar
pbrook committed
323 324 325 326 327 328 329
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
330 331
int bdrv_snapshot_load_tmp(BlockDriverState *bs,
                           const char *snapshot_name);
pbrook's avatar
pbrook committed
332 333 334 335 336 337 338 339
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);

340 341
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                      int64_t pos, int size);
342

343 344
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                      int64_t pos, int size);
345

346 347 348
void bdrv_img_create(const char *filename, const char *fmt,
                     const char *base_filename, const char *base_fmt,
                     char *options, uint64_t img_size, int flags, Error **errp);
349

350
void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
351
void *qemu_blockalign(BlockDriverState *bs, size_t size);
352
bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
353

354
#define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
355

356 357
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
358 359 360
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);
int64_t bdrv_get_next_dirty(BlockDriverState *bs, int64_t sector);
361
int64_t bdrv_get_dirty_count(BlockDriverState *bs);
Kevin Wolf's avatar
Kevin Wolf committed
362

363 364 365
void bdrv_enable_copy_on_read(BlockDriverState *bs);
void bdrv_disable_copy_on_read(BlockDriverState *bs);

366 367
void bdrv_set_in_use(BlockDriverState *bs, int in_use);
int bdrv_in_use(BlockDriverState *bs);
Kevin Wolf's avatar
Kevin Wolf committed
368

369 370 371 372 373 374 375 376 377
#ifdef CONFIG_LINUX_AIO
int raw_get_aio_fd(BlockDriverState *bs);
#else
static inline int raw_get_aio_fd(BlockDriverState *bs)
{
    return -ENOTSUP;
}
#endif

378 379 380 381 382 383 384 385 386
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
387
    int64_t start_time_ns;
388 389 390 391 392 393 394
    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
395
typedef enum {
Kevin Wolf's avatar
Kevin Wolf committed
396 397 398 399 400 401 402 403 404 405 406 407 408 409 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
    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
438 439 440 441 442 443
    BLKDBG_EVENT_MAX,
} BlkDebugEvent;

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

444 445 446 447 448
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);

449
#endif