]>
Commit | Line | Data |
---|---|---|
a2c4c3b1 EGE |
1 | /* |
2 | * QEMU Block backends | |
3 | * | |
4 | * Copyright (C) 2014-2016 Red Hat, Inc. | |
5 | * | |
6 | * Authors: | |
7 | * Markus Armbruster <armbru@redhat.com>, | |
8 | * | |
9 | * This work is licensed under the terms of the GNU LGPL, version 2.1 | |
10 | * or later. See the COPYING.LIB file in the top-level directory. | |
11 | */ | |
12 | ||
13 | #ifndef BLOCK_BACKEND_IO_H | |
14 | #define BLOCK_BACKEND_IO_H | |
15 | ||
16 | #include "block-backend-common.h" | |
17 | ||
18 | /* | |
19 | * I/O API functions. These functions are thread-safe. | |
20 | * | |
21 | * See include/block/block-io.h for more information about | |
22 | * the I/O API. | |
23 | */ | |
24 | ||
25 | const char *blk_name(const BlockBackend *blk); | |
26 | ||
27 | BlockDriverState *blk_bs(BlockBackend *blk); | |
28 | ||
29 | void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow); | |
30 | void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow); | |
31 | void blk_set_disable_request_queuing(BlockBackend *blk, bool disable); | |
32 | bool blk_iostatus_is_enabled(const BlockBackend *blk); | |
33 | ||
34 | char *blk_get_attached_dev_id(BlockBackend *blk); | |
35 | ||
36 | BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset, | |
37 | int64_t bytes, BdrvRequestFlags flags, | |
38 | BlockCompletionFunc *cb, void *opaque); | |
39 | ||
40 | BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset, | |
41 | QEMUIOVector *qiov, BdrvRequestFlags flags, | |
42 | BlockCompletionFunc *cb, void *opaque); | |
43 | BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset, | |
44 | QEMUIOVector *qiov, BdrvRequestFlags flags, | |
45 | BlockCompletionFunc *cb, void *opaque); | |
46 | BlockAIOCB *blk_aio_flush(BlockBackend *blk, | |
47 | BlockCompletionFunc *cb, void *opaque); | |
48 | BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes, | |
49 | BlockCompletionFunc *cb, void *opaque); | |
50 | void blk_aio_cancel_async(BlockAIOCB *acb); | |
51 | BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf, | |
52 | BlockCompletionFunc *cb, void *opaque); | |
53 | ||
54 | void blk_inc_in_flight(BlockBackend *blk); | |
55 | void blk_dec_in_flight(BlockBackend *blk); | |
56 | bool blk_is_inserted(BlockBackend *blk); | |
57 | bool blk_is_available(BlockBackend *blk); | |
58 | void blk_lock_medium(BlockBackend *blk, bool locked); | |
59 | void blk_eject(BlockBackend *blk, bool eject_flag); | |
60 | int64_t blk_getlength(BlockBackend *blk); | |
61 | void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr); | |
62 | int64_t blk_nb_sectors(BlockBackend *blk); | |
63 | void *blk_try_blockalign(BlockBackend *blk, size_t size); | |
64 | void *blk_blockalign(BlockBackend *blk, size_t size); | |
65 | bool blk_is_writable(BlockBackend *blk); | |
66 | bool blk_enable_write_cache(BlockBackend *blk); | |
67 | BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read); | |
68 | BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read, | |
69 | int error); | |
70 | void blk_error_action(BlockBackend *blk, BlockErrorAction action, | |
71 | bool is_read, int error); | |
72 | void blk_iostatus_set_err(BlockBackend *blk, int error); | |
73 | int blk_get_max_iov(BlockBackend *blk); | |
74 | int blk_get_max_hw_iov(BlockBackend *blk); | |
75 | void blk_set_guest_block_size(BlockBackend *blk, int align); | |
76 | ||
77 | void blk_io_plug(BlockBackend *blk); | |
78 | void blk_io_unplug(BlockBackend *blk); | |
79 | AioContext *blk_get_aio_context(BlockBackend *blk); | |
80 | BlockAcctStats *blk_get_stats(BlockBackend *blk); | |
81 | void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk, | |
82 | BlockCompletionFunc *cb, void *opaque); | |
83 | BlockAIOCB *blk_abort_aio_request(BlockBackend *blk, | |
84 | BlockCompletionFunc *cb, | |
85 | void *opaque, int ret); | |
86 | ||
87 | uint32_t blk_get_request_alignment(BlockBackend *blk); | |
88 | uint32_t blk_get_max_transfer(BlockBackend *blk); | |
89 | uint64_t blk_get_max_hw_transfer(BlockBackend *blk); | |
90 | ||
91 | int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in, | |
92 | BlockBackend *blk_out, int64_t off_out, | |
93 | int64_t bytes, BdrvRequestFlags read_flags, | |
94 | BdrvRequestFlags write_flags); | |
95 | ||
96 | ||
97 | /* | |
98 | * "I/O or GS" API functions. These functions can run without | |
99 | * the BQL, but only in one specific iothread/main loop. | |
100 | * | |
101 | * See include/block/block-io.h for more information about | |
102 | * the "I/O or GS" API. | |
103 | */ | |
104 | ||
105 | int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes); | |
106 | int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes, | |
107 | BdrvRequestFlags flags); | |
108 | int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset, | |
109 | int64_t bytes, QEMUIOVector *qiov, | |
110 | BdrvRequestFlags flags); | |
111 | int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset, | |
112 | int64_t bytes, | |
113 | QEMUIOVector *qiov, size_t qiov_offset, | |
114 | BdrvRequestFlags flags); | |
115 | int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset, | |
116 | int64_t bytes, QEMUIOVector *qiov, | |
117 | BdrvRequestFlags flags); | |
118 | ||
119 | static inline int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, | |
120 | int64_t bytes, void *buf, | |
121 | BdrvRequestFlags flags) | |
122 | { | |
123 | QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); | |
37868b2a | 124 | IO_OR_GS_CODE(); |
a2c4c3b1 EGE |
125 | |
126 | assert(bytes <= SIZE_MAX); | |
127 | ||
128 | return blk_co_preadv(blk, offset, bytes, &qiov, flags); | |
129 | } | |
130 | ||
131 | static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, | |
132 | int64_t bytes, void *buf, | |
133 | BdrvRequestFlags flags) | |
134 | { | |
135 | QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); | |
37868b2a | 136 | IO_OR_GS_CODE(); |
a2c4c3b1 EGE |
137 | |
138 | assert(bytes <= SIZE_MAX); | |
139 | ||
140 | return blk_co_pwritev(blk, offset, bytes, &qiov, flags); | |
141 | } | |
142 | ||
143 | int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset, | |
144 | int64_t bytes); | |
145 | ||
146 | int coroutine_fn blk_co_flush(BlockBackend *blk); | |
147 | int blk_flush(BlockBackend *blk); | |
148 | ||
149 | int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf); | |
150 | ||
151 | int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf, | |
152 | int64_t bytes); | |
153 | int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes); | |
154 | int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset, | |
155 | int64_t bytes, BdrvRequestFlags flags); | |
156 | int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, | |
157 | int64_t bytes, BdrvRequestFlags flags); | |
158 | int blk_truncate(BlockBackend *blk, int64_t offset, bool exact, | |
159 | PreallocMode prealloc, BdrvRequestFlags flags, Error **errp); | |
160 | ||
161 | #endif /* BLOCK_BACKEND_IO_H */ |