Statistics
| Branch: | Revision:

root / include / block / block.h @ 34b5d2c6

History | View | Annotate | Download (18.8 kB)

1
#ifndef BLOCK_H
2
#define BLOCK_H
3

    
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

    
11
/* block.c */
12
typedef struct BlockDriver BlockDriver;
13
typedef struct BlockJob BlockJob;
14

    
15
typedef struct BlockDriverInfo {
16
    /* in bytes, 0 if irrelevant */
17
    int cluster_size;
18
    /* offset at which the VM state can be saved (0 if not possible) */
19
    int64_t vm_state_offset;
20
    bool is_dirty;
21
} BlockDriverInfo;
22

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

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

    
65
#define BDRV_O_RDWR        0x0002
66
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
67
#define BDRV_O_NOCACHE     0x0020 /* do not use the host page cache */
68
#define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */
69
#define BDRV_O_NATIVE_AIO  0x0080 /* use native AIO instead of the thread pool */
70
#define BDRV_O_NO_BACKING  0x0100 /* don't open the backing file */
71
#define BDRV_O_NO_FLUSH    0x0200 /* disable flushing on this disk */
72
#define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
73
#define BDRV_O_INCOMING    0x0800  /* consistency hint for incoming migration */
74
#define BDRV_O_CHECK       0x1000  /* open solely for consistency check */
75
#define BDRV_O_ALLOW_RDWR  0x2000  /* allow reopen to change from r/o to r/w */
76
#define BDRV_O_UNMAP       0x4000  /* execute guest UNMAP/TRIM operations */
77

    
78
#define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
79

    
80
#define BDRV_SECTOR_BITS   9
81
#define BDRV_SECTOR_SIZE   (1ULL << BDRV_SECTOR_BITS)
82
#define BDRV_SECTOR_MASK   ~(BDRV_SECTOR_SIZE - 1)
83

    
84
/* BDRV_BLOCK_DATA: data is read from bs->file or another file
85
 * BDRV_BLOCK_ZERO: sectors read as zero
86
 * BDRV_BLOCK_OFFSET_VALID: sector stored in bs->file as raw data
87
 *
88
 * If BDRV_BLOCK_OFFSET_VALID is set, bits 9-62 represent the offset in
89
 * bs->file where sector data can be read from as raw data.
90
 *
91
 * DATA == 0 && ZERO == 0 means that data is read from backing_hd if present.
92
 *
93
 * DATA ZERO OFFSET_VALID
94
 *  t    t        t       sectors read as zero, bs->file is zero at offset
95
 *  t    f        t       sectors read as valid from bs->file at offset
96
 *  f    t        t       sectors preallocated, read as zero, bs->file not
97
 *                        necessarily zero at offset
98
 *  f    f        t       sectors preallocated but read from backing_hd,
99
 *                        bs->file contains garbage at offset
100
 *  t    t        f       sectors preallocated, read as zero, unknown offset
101
 *  t    f        f       sectors read from unknown file or offset
102
 *  f    t        f       not allocated or unknown offset, read as zero
103
 *  f    f        f       not allocated or unknown offset, read from backing_hd
104
 */
105
#define BDRV_BLOCK_DATA         1
106
#define BDRV_BLOCK_ZERO         2
107
#define BDRV_BLOCK_OFFSET_VALID 4
108
#define BDRV_BLOCK_OFFSET_MASK  BDRV_SECTOR_MASK
109

    
110
typedef enum {
111
    BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
112
} BlockErrorAction;
113

    
114
typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
115

    
116
typedef struct BDRVReopenState {
117
    BlockDriverState *bs;
118
    int flags;
119
    void *opaque;
120
} BDRVReopenState;
121

    
122

    
123
void bdrv_iostatus_enable(BlockDriverState *bs);
124
void bdrv_iostatus_reset(BlockDriverState *bs);
125
void bdrv_iostatus_disable(BlockDriverState *bs);
126
bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
127
void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
128
void bdrv_info_print(Monitor *mon, const QObject *data);
129
void bdrv_info(Monitor *mon, QObject **ret_data);
130
void bdrv_stats_print(Monitor *mon, const QObject *data);
131
void bdrv_info_stats(Monitor *mon, QObject **ret_data);
132

    
133
/* disk I/O throttling */
134
void bdrv_io_limits_enable(BlockDriverState *bs);
135
void bdrv_io_limits_disable(BlockDriverState *bs);
136

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

    
226

    
227
typedef struct BdrvCheckResult {
228
    int corruptions;
229
    int leaks;
230
    int check_errors;
231
    int corruptions_fixed;
232
    int leaks_fixed;
233
    int64_t image_end_offset;
234
    BlockFragInfo bfi;
235
} BdrvCheckResult;
236

    
237
typedef enum {
238
    BDRV_FIX_LEAKS    = 1,
239
    BDRV_FIX_ERRORS   = 2,
240
} BdrvCheckMode;
241

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

    
244
int bdrv_amend_options(BlockDriverState *bs_new, QEMUOptionParameter *options);
245

    
246
/* async block I/O */
247
typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
248
                                     int sector_num);
249
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
250
                                 QEMUIOVector *iov, int nb_sectors,
251
                                 BlockDriverCompletionFunc *cb, void *opaque);
252
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
253
                                  QEMUIOVector *iov, int nb_sectors,
254
                                  BlockDriverCompletionFunc *cb, void *opaque);
255
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
256
                                 BlockDriverCompletionFunc *cb, void *opaque);
257
BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
258
                                   int64_t sector_num, int nb_sectors,
259
                                   BlockDriverCompletionFunc *cb, void *opaque);
260
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
261

    
262
typedef struct BlockRequest {
263
    /* Fields to be filled by multiwrite caller */
264
    int64_t sector;
265
    int nb_sectors;
266
    QEMUIOVector *qiov;
267
    BlockDriverCompletionFunc *cb;
268
    void *opaque;
269

    
270
    /* Filled by multiwrite implementation */
271
    int error;
272
} BlockRequest;
273

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

    
277
/* sg packet commands */
278
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
279
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
280
        unsigned long int req, void *buf,
281
        BlockDriverCompletionFunc *cb, void *opaque);
282

    
283
/* Invalidate any cached metadata used by image formats */
284
void bdrv_invalidate_cache(BlockDriverState *bs);
285
void bdrv_invalidate_cache_all(void);
286

    
287
void bdrv_clear_incoming_migration_all(void);
288

    
289
/* Ensure contents are flushed to disk.  */
290
int bdrv_flush(BlockDriverState *bs);
291
int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
292
int bdrv_flush_all(void);
293
void bdrv_close_all(void);
294
void bdrv_drain_all(void);
295

    
296
int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
297
int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
298
int bdrv_has_zero_init_1(BlockDriverState *bs);
299
int bdrv_has_zero_init(BlockDriverState *bs);
300
int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
301
                              int nb_sectors, int *pnum);
302
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
303
                      int *pnum);
304
int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
305
                            int64_t sector_num, int nb_sectors, int *pnum);
306

    
307
void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
308
                       BlockdevOnError on_write_error);
309
BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read);
310
BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error);
311
void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
312
                       bool is_read, int error);
313
int bdrv_is_read_only(BlockDriverState *bs);
314
int bdrv_is_sg(BlockDriverState *bs);
315
int bdrv_enable_write_cache(BlockDriverState *bs);
316
void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce);
317
int bdrv_is_inserted(BlockDriverState *bs);
318
int bdrv_media_changed(BlockDriverState *bs);
319
void bdrv_lock_medium(BlockDriverState *bs, bool locked);
320
void bdrv_eject(BlockDriverState *bs, bool eject_flag);
321
const char *bdrv_get_format_name(BlockDriverState *bs);
322
BlockDriverState *bdrv_find(const char *name);
323
BlockDriverState *bdrv_next(BlockDriverState *bs);
324
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
325
                  void *opaque);
326
int bdrv_is_encrypted(BlockDriverState *bs);
327
int bdrv_key_required(BlockDriverState *bs);
328
int bdrv_set_key(BlockDriverState *bs, const char *key);
329
int bdrv_query_missing_keys(void);
330
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
331
                         void *opaque);
332
const char *bdrv_get_device_name(BlockDriverState *bs);
333
int bdrv_get_flags(BlockDriverState *bs);
334
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
335
                          const uint8_t *buf, int nb_sectors);
336
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
337
void bdrv_round_to_clusters(BlockDriverState *bs,
338
                            int64_t sector_num, int nb_sectors,
339
                            int64_t *cluster_sector_num,
340
                            int *cluster_nb_sectors);
341

    
342
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
343
void bdrv_get_backing_filename(BlockDriverState *bs,
344
                               char *filename, int filename_size);
345
void bdrv_get_full_backing_filename(BlockDriverState *bs,
346
                                    char *dest, size_t sz);
347
int bdrv_is_snapshot(BlockDriverState *bs);
348

    
349
int path_is_absolute(const char *path);
350
void path_combine(char *dest, int dest_size,
351
                  const char *base_path,
352
                  const char *filename);
353

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

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

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

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

    
370
struct HBitmapIter;
371
void bdrv_set_dirty_tracking(BlockDriverState *bs, int granularity);
372
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
373
void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
374
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
375
void bdrv_dirty_iter_init(BlockDriverState *bs, struct HBitmapIter *hbi);
376
int64_t bdrv_get_dirty_count(BlockDriverState *bs);
377

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

    
381
void bdrv_ref(BlockDriverState *bs);
382
void bdrv_unref(BlockDriverState *bs);
383
void bdrv_set_in_use(BlockDriverState *bs, int in_use);
384
int bdrv_in_use(BlockDriverState *bs);
385

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

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

    
402
typedef struct BlockAcctCookie {
403
    int64_t bytes;
404
    int64_t start_time_ns;
405
    enum BlockAcctType type;
406
} BlockAcctCookie;
407

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

    
412
typedef enum {
413
    BLKDBG_L1_UPDATE,
414

    
415
    BLKDBG_L1_GROW_ALLOC_TABLE,
416
    BLKDBG_L1_GROW_WRITE_TABLE,
417
    BLKDBG_L1_GROW_ACTIVATE_TABLE,
418

    
419
    BLKDBG_L2_LOAD,
420
    BLKDBG_L2_UPDATE,
421
    BLKDBG_L2_UPDATE_COMPRESSED,
422
    BLKDBG_L2_ALLOC_COW_READ,
423
    BLKDBG_L2_ALLOC_WRITE,
424

    
425
    BLKDBG_READ_AIO,
426
    BLKDBG_READ_BACKING_AIO,
427
    BLKDBG_READ_COMPRESSED,
428

    
429
    BLKDBG_WRITE_AIO,
430
    BLKDBG_WRITE_COMPRESSED,
431

    
432
    BLKDBG_VMSTATE_LOAD,
433
    BLKDBG_VMSTATE_SAVE,
434

    
435
    BLKDBG_COW_READ,
436
    BLKDBG_COW_WRITE,
437

    
438
    BLKDBG_REFTABLE_LOAD,
439
    BLKDBG_REFTABLE_GROW,
440
    BLKDBG_REFTABLE_UPDATE,
441

    
442
    BLKDBG_REFBLOCK_LOAD,
443
    BLKDBG_REFBLOCK_UPDATE,
444
    BLKDBG_REFBLOCK_UPDATE_PART,
445
    BLKDBG_REFBLOCK_ALLOC,
446
    BLKDBG_REFBLOCK_ALLOC_HOOKUP,
447
    BLKDBG_REFBLOCK_ALLOC_WRITE,
448
    BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
449
    BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
450
    BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
451

    
452
    BLKDBG_CLUSTER_ALLOC,
453
    BLKDBG_CLUSTER_ALLOC_BYTES,
454
    BLKDBG_CLUSTER_FREE,
455

    
456
    BLKDBG_FLUSH_TO_OS,
457
    BLKDBG_FLUSH_TO_DISK,
458

    
459
    BLKDBG_EVENT_MAX,
460
} BlkDebugEvent;
461

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

    
465
int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
466
                           const char *tag);
467
int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
468
bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
469

    
470
#endif