qemu

1
/*
2
 * Copy-on-read filter block driver
3
 *
4
 * Copyright (c) 2018 Red Hat, Inc.
5
 *
6
 * Author:
7
 *   Max Reitz <mreitz@redhat.com>
8
 *
9
 * This program is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU General Public License as
11
 * published by the Free Software Foundation; either version 2 or
12
 * (at your option) version 3 of the License.
13
 *
14
 * This program is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 * GNU General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU General Public License
20
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21
 */
22

23
#include "qemu/osdep.h"
24
#include "block/block-io.h"
25
#include "block/block_int.h"
26
#include "qemu/module.h"
27
#include "qapi/error.h"
28
#include "qapi/qmp/qdict.h"
29
#include "block/copy-on-read.h"
30

31

32
typedef struct BDRVStateCOR {
33
    BlockDriverState *bottom_bs;
34
    bool chain_frozen;
35
} BDRVStateCOR;
36

37

38
static int GRAPH_UNLOCKED
39
cor_open(BlockDriverState *bs, QDict *options, int flags, Error **errp)
40
{
41
    BlockDriverState *bottom_bs = NULL;
42
    BDRVStateCOR *state = bs->opaque;
43
    /* Find a bottom node name, if any */
44
    const char *bottom_node = qdict_get_try_str(options, "bottom");
45
    int ret;
46

47
    GLOBAL_STATE_CODE();
48

49
    ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
50
    if (ret < 0) {
51
        return ret;
52
    }
53

54
    GRAPH_RDLOCK_GUARD_MAINLOOP();
55

56
    bs->supported_read_flags = BDRV_REQ_PREFETCH;
57

58
    bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
59
        (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
60

61
    bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
62
        ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
63
            bs->file->bs->supported_zero_flags);
64

65
    if (bottom_node) {
66
        bottom_bs = bdrv_find_node(bottom_node);
67
        if (!bottom_bs) {
68
            error_setg(errp, "Bottom node '%s' not found", bottom_node);
69
            qdict_del(options, "bottom");
70
            return -EINVAL;
71
        }
72
        qdict_del(options, "bottom");
73

74
        if (!bottom_bs->drv) {
75
            error_setg(errp, "Bottom node '%s' not opened", bottom_node);
76
            return -EINVAL;
77
        }
78

79
        if (bottom_bs->drv->is_filter) {
80
            error_setg(errp, "Bottom node '%s' is a filter", bottom_node);
81
            return -EINVAL;
82
        }
83

84
        if (bdrv_freeze_backing_chain(bs, bottom_bs, errp) < 0) {
85
            return -EINVAL;
86
        }
87
        state->chain_frozen = true;
88

89
        /*
90
         * We do freeze the chain, so it shouldn't be removed. Still, storing a
91
         * pointer worth bdrv_ref().
92
         */
93
        bdrv_ref(bottom_bs);
94
    }
95
    state->bottom_bs = bottom_bs;
96

97
    /*
98
     * We don't need to call bdrv_child_refresh_perms() now as the permissions
99
     * will be updated later when the filter node gets its parent.
100
     */
101

102
    return 0;
103
}
104

105

106
#define PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \
107
                          | BLK_PERM_WRITE \
108
                          | BLK_PERM_RESIZE)
109
#define PERM_UNCHANGED (BLK_PERM_ALL & ~PERM_PASSTHROUGH)
110

111
static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,
112
                           BdrvChildRole role,
113
                           BlockReopenQueue *reopen_queue,
114
                           uint64_t perm, uint64_t shared,
115
                           uint64_t *nperm, uint64_t *nshared)
116
{
117
    *nperm = perm & PERM_PASSTHROUGH;
118
    *nshared = (shared & PERM_PASSTHROUGH) | PERM_UNCHANGED;
119

120
    /* We must not request write permissions for an inactive node, the child
121
     * cannot provide it. */
122
    if (!(bs->open_flags & BDRV_O_INACTIVE)) {
123
        *nperm |= BLK_PERM_WRITE_UNCHANGED;
124
    }
125
}
126

127

128
static int64_t coroutine_fn GRAPH_RDLOCK cor_co_getlength(BlockDriverState *bs)
129
{
130
    return bdrv_co_getlength(bs->file->bs);
131
}
132

133

134
static int coroutine_fn GRAPH_RDLOCK
135
cor_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
136
                   QEMUIOVector *qiov, size_t qiov_offset,
137
                   BdrvRequestFlags flags)
138
{
139
    int64_t n;
140
    int local_flags;
141
    int ret;
142
    BDRVStateCOR *state = bs->opaque;
143

144
    if (!state->bottom_bs) {
145
        return bdrv_co_preadv_part(bs->file, offset, bytes, qiov, qiov_offset,
146
                                   flags | BDRV_REQ_COPY_ON_READ);
147
    }
148

149
    while (bytes) {
150
        local_flags = flags;
151

152
        /* In case of failure, try to copy-on-read anyway */
153
        ret = bdrv_co_is_allocated(bs->file->bs, offset, bytes, &n);
154
        if (ret <= 0) {
155
            ret = bdrv_co_is_allocated_above(bdrv_backing_chain_next(bs->file->bs),
156
                                             state->bottom_bs, true, offset,
157
                                             n, &n);
158
            if (ret > 0 || ret < 0) {
159
                local_flags |= BDRV_REQ_COPY_ON_READ;
160
            }
161
            /* Finish earlier if the end of a backing file has been reached */
162
            if (n == 0) {
163
                break;
164
            }
165
        }
166

167
        /* Skip if neither read nor write are needed */
168
        if ((local_flags & (BDRV_REQ_PREFETCH | BDRV_REQ_COPY_ON_READ)) !=
169
            BDRV_REQ_PREFETCH) {
170
            ret = bdrv_co_preadv_part(bs->file, offset, n, qiov, qiov_offset,
171
                                      local_flags);
172
            if (ret < 0) {
173
                return ret;
174
            }
175
        }
176

177
        offset += n;
178
        qiov_offset += n;
179
        bytes -= n;
180
    }
181

182
    return 0;
183
}
184

185

186
static int coroutine_fn GRAPH_RDLOCK
187
cor_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
188
                    QEMUIOVector *qiov, size_t qiov_offset,
189
                    BdrvRequestFlags flags)
190
{
191
    return bdrv_co_pwritev_part(bs->file, offset, bytes, qiov, qiov_offset,
192
                                flags);
193
}
194

195

196
static int coroutine_fn GRAPH_RDLOCK
197
cor_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
198
                     BdrvRequestFlags flags)
199
{
200
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
201
}
202

203

204
static int coroutine_fn GRAPH_RDLOCK
205
cor_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
206
{
207
    return bdrv_co_pdiscard(bs->file, offset, bytes);
208
}
209

210

211
static int coroutine_fn GRAPH_RDLOCK
212
cor_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
213
                          QEMUIOVector *qiov)
214
{
215
    return bdrv_co_pwritev(bs->file, offset, bytes, qiov,
216
                           BDRV_REQ_WRITE_COMPRESSED);
217
}
218

219

220
static void coroutine_fn GRAPH_RDLOCK
221
cor_co_eject(BlockDriverState *bs, bool eject_flag)
222
{
223
    bdrv_co_eject(bs->file->bs, eject_flag);
224
}
225

226

227
static void coroutine_fn GRAPH_RDLOCK
228
cor_co_lock_medium(BlockDriverState *bs, bool locked)
229
{
230
    bdrv_co_lock_medium(bs->file->bs, locked);
231
}
232

233

234
static void GRAPH_UNLOCKED cor_close(BlockDriverState *bs)
235
{
236
    BDRVStateCOR *s = bs->opaque;
237

238
    GLOBAL_STATE_CODE();
239

240
    if (s->chain_frozen) {
241
        bdrv_graph_rdlock_main_loop();
242
        s->chain_frozen = false;
243
        bdrv_unfreeze_backing_chain(bs, s->bottom_bs);
244
        bdrv_graph_rdunlock_main_loop();
245
    }
246

247
    bdrv_unref(s->bottom_bs);
248
}
249

250

251
static BlockDriver bdrv_copy_on_read = {
252
    .format_name                        = "copy-on-read",
253
    .instance_size                      = sizeof(BDRVStateCOR),
254

255
    .bdrv_open                          = cor_open,
256
    .bdrv_close                         = cor_close,
257
    .bdrv_child_perm                    = cor_child_perm,
258

259
    .bdrv_co_getlength                  = cor_co_getlength,
260

261
    .bdrv_co_preadv_part                = cor_co_preadv_part,
262
    .bdrv_co_pwritev_part               = cor_co_pwritev_part,
263
    .bdrv_co_pwrite_zeroes              = cor_co_pwrite_zeroes,
264
    .bdrv_co_pdiscard                   = cor_co_pdiscard,
265
    .bdrv_co_pwritev_compressed         = cor_co_pwritev_compressed,
266

267
    .bdrv_co_eject                      = cor_co_eject,
268
    .bdrv_co_lock_medium                = cor_co_lock_medium,
269

270
    .is_filter                          = true,
271
};
272

273

274
void no_coroutine_fn bdrv_cor_filter_drop(BlockDriverState *cor_filter_bs)
275
{
276
    BDRVStateCOR *s = cor_filter_bs->opaque;
277

278
    GLOBAL_STATE_CODE();
279

280
    /* unfreeze, as otherwise bdrv_replace_node() will fail */
281
    if (s->chain_frozen) {
282
        GRAPH_RDLOCK_GUARD_MAINLOOP();
283
        s->chain_frozen = false;
284
        bdrv_unfreeze_backing_chain(cor_filter_bs, s->bottom_bs);
285
    }
286
    bdrv_drop_filter(cor_filter_bs, &error_abort);
287
    bdrv_unref(cor_filter_bs);
288
}
289

290

291
static void bdrv_copy_on_read_init(void)
292
{
293
    bdrv_register(&bdrv_copy_on_read);
294
}
295

296
block_init(bdrv_copy_on_read_init);
297