← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to block-cow.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2008-08-25 04:38:35 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20080825043835-8e3tftavy8bujdch
Tags: 0.9.1-6
http://bugs.debian.org/488339
[ Aurelien Jarno ]
* debian/control: 
  - Update list of supported targets (Closes: bug#488339).
* debian/qemu-make-debian-root:
  - Use mktemp instead of $$ to create temporary directories (Closes: 
    bug#496394).
* debian/links:
  - Add missing links to manpages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
block-cow.c
 
1
/*
 
2
 * Block driver for the COW format
 
3
 *
 
4
 * Copyright (c) 2004 Fabrice Bellard
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 
7
 * of this software and associated documentation files (the "Software"), to deal
 
8
 * in the Software without restriction, including without limitation the rights
 
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
10
 * copies of the Software, and to permit persons to whom the Software is
 
11
 * furnished to do so, subject to the following conditions:
 
12
 *
 
13
 * The above copyright notice and this permission notice shall be included in
 
14
 * all copies or substantial portions of the Software.
 
15
 *
 
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
22
 * THE SOFTWARE.
 
23
 */
 
24
#ifndef _WIN32
 
25
#include "qemu-common.h"
 
26
#include "block_int.h"
 
27
#include <sys/mman.h>
 
28
 
 
29
/**************************************************************/
 
30
/* COW block driver using file system holes */
 
31
 
 
32
/* user mode linux compatible COW file */
 
33
#define COW_MAGIC 0x4f4f4f4d  /* MOOO */
 
34
#define COW_VERSION 2
 
35
 
 
36
struct cow_header_v2 {
 
37
    uint32_t magic;
 
38
    uint32_t version;
 
39
    char backing_file[1024];
 
40
    int32_t mtime;
 
41
    uint64_t size;
 
42
    uint32_t sectorsize;
 
43
};
 
44
 
 
45
typedef struct BDRVCowState {
 
46
    int fd;
 
47
    uint8_t *cow_bitmap; /* if non NULL, COW mappings are used first */
 
48
    uint8_t *cow_bitmap_addr; /* mmap address of cow_bitmap */
 
49
    int cow_bitmap_size;
 
50
    int64_t cow_sectors_offset;
 
51
} BDRVCowState;
 
52
 
 
53
static int cow_probe(const uint8_t *buf, int buf_size, const char *filename)
 
54
{
 
55
    const struct cow_header_v2 *cow_header = (const void *)buf;
 
56
 
 
57
    if (buf_size >= sizeof(struct cow_header_v2) &&
 
58
        be32_to_cpu(cow_header->magic) == COW_MAGIC &&
 
59
        be32_to_cpu(cow_header->version) == COW_VERSION)
 
60
        return 100;
 
61
    else
 
62
        return 0;
 
63
}
 
64
 
 
65
static int cow_open(BlockDriverState *bs, const char *filename, int flags)
 
66
{
 
67
    BDRVCowState *s = bs->opaque;
 
68
    int fd;
 
69
    struct cow_header_v2 cow_header;
 
70
    int64_t size;
 
71
 
 
72
    fd = open(filename, O_RDWR | O_BINARY | O_LARGEFILE);
 
73
    if (fd < 0) {
 
74
        fd = open(filename, O_RDONLY | O_BINARY | O_LARGEFILE);
 
75
        if (fd < 0)
 
76
            return -1;
 
77
    }
 
78
    s->fd = fd;
 
79
    /* see if it is a cow image */
 
80
    if (read(fd, &cow_header, sizeof(cow_header)) != sizeof(cow_header)) {
 
81
        goto fail;
 
82
    }
 
83
 
 
84
    if (be32_to_cpu(cow_header.magic) != COW_MAGIC ||
 
85
        be32_to_cpu(cow_header.version) != COW_VERSION) {
 
86
        goto fail;
 
87
    }
 
88
 
 
89
    /* cow image found */
 
90
    size = be64_to_cpu(cow_header.size);
 
91
    bs->total_sectors = size / 512;
 
92
 
 
93
    pstrcpy(bs->backing_file, sizeof(bs->backing_file),
 
94
            cow_header.backing_file);
 
95
 
 
96
    /* mmap the bitmap */
 
97
    s->cow_bitmap_size = ((bs->total_sectors + 7) >> 3) + sizeof(cow_header);
 
98
    s->cow_bitmap_addr = mmap(get_mmap_addr(s->cow_bitmap_size),
 
99
                              s->cow_bitmap_size,
 
100
                              PROT_READ | PROT_WRITE,
 
101
                              MAP_SHARED, s->fd, 0);
 
102
    if (s->cow_bitmap_addr == MAP_FAILED)
 
103
        goto fail;
 
104
    s->cow_bitmap = s->cow_bitmap_addr + sizeof(cow_header);
 
105
    s->cow_sectors_offset = (s->cow_bitmap_size + 511) & ~511;
 
106
    return 0;
 
107
 fail:
 
108
    close(fd);
 
109
    return -1;
 
110
}
 
111
 
 
112
static inline void cow_set_bit(uint8_t *bitmap, int64_t bitnum)
 
113
{
 
114
    bitmap[bitnum / 8] |= (1 << (bitnum%8));
 
115
}
 
116
 
 
117
static inline int is_bit_set(const uint8_t *bitmap, int64_t bitnum)
 
118
{
 
119
    return !!(bitmap[bitnum / 8] & (1 << (bitnum%8)));
 
120
}
 
121
 
 
122
 
 
123
/* Return true if first block has been changed (ie. current version is
 
124
 * in COW file).  Set the number of continuous blocks for which that
 
125
 * is true. */
 
126
static inline int is_changed(uint8_t *bitmap,
 
127
                             int64_t sector_num, int nb_sectors,
 
128
                             int *num_same)
 
129
{
 
130
    int changed;
 
131
 
 
132
    if (!bitmap || nb_sectors == 0) {
 
133
        *num_same = nb_sectors;
 
134
        return 0;
 
135
    }
 
136
 
 
137
    changed = is_bit_set(bitmap, sector_num);
 
138
    for (*num_same = 1; *num_same < nb_sectors; (*num_same)++) {
 
139
        if (is_bit_set(bitmap, sector_num + *num_same) != changed)
 
140
            break;
 
141
    }
 
142
 
 
143
    return changed;
 
144
}
 
145
 
 
146
static int cow_is_allocated(BlockDriverState *bs, int64_t sector_num,
 
147
                            int nb_sectors, int *pnum)
 
148
{
 
149
    BDRVCowState *s = bs->opaque;
 
150
    return is_changed(s->cow_bitmap, sector_num, nb_sectors, pnum);
 
151
}
 
152
 
 
153
static int cow_read(BlockDriverState *bs, int64_t sector_num,
 
154
                    uint8_t *buf, int nb_sectors)
 
155
{
 
156
    BDRVCowState *s = bs->opaque;
 
157
    int ret, n;
 
158
 
 
159
    while (nb_sectors > 0) {
 
160
        if (is_changed(s->cow_bitmap, sector_num, nb_sectors, &n)) {
 
161
            lseek(s->fd, s->cow_sectors_offset + sector_num * 512, SEEK_SET);
 
162
            ret = read(s->fd, buf, n * 512);
 
163
            if (ret != n * 512)
 
164
                return -1;
 
165
        } else {
 
166
            if (bs->backing_hd) {
 
167
                /* read from the base image */
 
168
                ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
 
169
                if (ret < 0)
 
170
                    return -1;
 
171
            } else {
 
172
            memset(buf, 0, n * 512);
 
173
        }
 
174
        }
 
175
        nb_sectors -= n;
 
176
        sector_num += n;
 
177
        buf += n * 512;
 
178
    }
 
179
    return 0;
 
180
}
 
181
 
 
182
static int cow_write(BlockDriverState *bs, int64_t sector_num,
 
183
                     const uint8_t *buf, int nb_sectors)
 
184
{
 
185
    BDRVCowState *s = bs->opaque;
 
186
    int ret, i;
 
187
 
 
188
    lseek(s->fd, s->cow_sectors_offset + sector_num * 512, SEEK_SET);
 
189
    ret = write(s->fd, buf, nb_sectors * 512);
 
190
    if (ret != nb_sectors * 512)
 
191
        return -1;
 
192
    for (i = 0; i < nb_sectors; i++)
 
193
        cow_set_bit(s->cow_bitmap, sector_num + i);
 
194
    return 0;
 
195
}
 
196
 
 
197
static void cow_close(BlockDriverState *bs)
 
198
{
 
199
    BDRVCowState *s = bs->opaque;
 
200
    munmap(s->cow_bitmap_addr, s->cow_bitmap_size);
 
201
    close(s->fd);
 
202
}
 
203
 
 
204
static int cow_create(const char *filename, int64_t image_sectors,
 
205
                      const char *image_filename, int flags)
 
206
{
 
207
    int fd, cow_fd;
 
208
    struct cow_header_v2 cow_header;
 
209
    struct stat st;
 
210
 
 
211
    if (flags)
 
212
        return -ENOTSUP;
 
213
 
 
214
    cow_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
 
215
              0644);
 
216
    if (cow_fd < 0)
 
217
        return -1;
 
218
    memset(&cow_header, 0, sizeof(cow_header));
 
219
    cow_header.magic = cpu_to_be32(COW_MAGIC);
 
220
    cow_header.version = cpu_to_be32(COW_VERSION);
 
221
    if (image_filename) {
 
222
        /* Note: if no file, we put a dummy mtime */
 
223
        cow_header.mtime = cpu_to_be32(0);
 
224
 
 
225
        fd = open(image_filename, O_RDONLY | O_BINARY);
 
226
        if (fd < 0) {
 
227
            close(cow_fd);
 
228
            goto mtime_fail;
 
229
        }
 
230
        if (fstat(fd, &st) != 0) {
 
231
            close(fd);
 
232
            goto mtime_fail;
 
233
        }
 
234
        close(fd);
 
235
        cow_header.mtime = cpu_to_be32(st.st_mtime);
 
236
    mtime_fail:
 
237
        pstrcpy(cow_header.backing_file, sizeof(cow_header.backing_file),
 
238
                image_filename);
 
239
    }
 
240
    cow_header.sectorsize = cpu_to_be32(512);
 
241
    cow_header.size = cpu_to_be64(image_sectors * 512);
 
242
    write(cow_fd, &cow_header, sizeof(cow_header));
 
243
    /* resize to include at least all the bitmap */
 
244
    ftruncate(cow_fd, sizeof(cow_header) + ((image_sectors + 7) >> 3));
 
245
    close(cow_fd);
 
246
    return 0;
 
247
}
 
248
 
 
249
static void cow_flush(BlockDriverState *bs)
 
250
{
 
251
    BDRVCowState *s = bs->opaque;
 
252
    fsync(s->fd);
 
253
}
 
254
 
 
255
BlockDriver bdrv_cow = {
 
256
    "cow",
 
257
    sizeof(BDRVCowState),
 
258
    cow_probe,
 
259
    cow_open,
 
260
    cow_read,
 
261
    cow_write,
 
262
    cow_close,
 
263
    cow_create,
 
264
    cow_flush,
 
265
    cow_is_allocated,
 
266
};
 
267
#endif