]>
Commit | Line | Data |
---|---|---|
ea2384d3 FB |
1 | /* |
2 | * Block driver for the COW format | |
5fafdf24 | 3 | * |
ea2384d3 | 4 | * Copyright (c) 2004 Fabrice Bellard |
5fafdf24 | 5 | * |
ea2384d3 FB |
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 | */ | |
faf07963 | 24 | #include "qemu-common.h" |
ea2384d3 | 25 | #include "block_int.h" |
5efa9d5a | 26 | #include "module.h" |
ea2384d3 FB |
27 | |
28 | /**************************************************************/ | |
29 | /* COW block driver using file system holes */ | |
30 | ||
31 | /* user mode linux compatible COW file */ | |
32 | #define COW_MAGIC 0x4f4f4f4d /* MOOO */ | |
33 | #define COW_VERSION 2 | |
34 | ||
35 | struct cow_header_v2 { | |
36 | uint32_t magic; | |
37 | uint32_t version; | |
38 | char backing_file[1024]; | |
39 | int32_t mtime; | |
40 | uint64_t size; | |
41 | uint32_t sectorsize; | |
42 | }; | |
43 | ||
44 | typedef struct BDRVCowState { | |
ea2384d3 FB |
45 | int64_t cow_sectors_offset; |
46 | } BDRVCowState; | |
47 | ||
48 | static int cow_probe(const uint8_t *buf, int buf_size, const char *filename) | |
49 | { | |
50 | const struct cow_header_v2 *cow_header = (const void *)buf; | |
51 | ||
712e7874 FB |
52 | if (buf_size >= sizeof(struct cow_header_v2) && |
53 | be32_to_cpu(cow_header->magic) == COW_MAGIC && | |
5fafdf24 | 54 | be32_to_cpu(cow_header->version) == COW_VERSION) |
ea2384d3 FB |
55 | return 100; |
56 | else | |
57 | return 0; | |
58 | } | |
59 | ||
2063392a | 60 | static int cow_open(BlockDriverState *bs, int flags) |
ea2384d3 FB |
61 | { |
62 | BDRVCowState *s = bs->opaque; | |
ea2384d3 | 63 | struct cow_header_v2 cow_header; |
893a9cb4 | 64 | int bitmap_size; |
ea2384d3 FB |
65 | int64_t size; |
66 | ||
ea2384d3 | 67 | /* see if it is a cow image */ |
2063392a CH |
68 | if (bdrv_pread(bs->file, 0, &cow_header, sizeof(cow_header)) != |
69 | sizeof(cow_header)) { | |
ea2384d3 FB |
70 | goto fail; |
71 | } | |
72 | ||
73 | if (be32_to_cpu(cow_header.magic) != COW_MAGIC || | |
74 | be32_to_cpu(cow_header.version) != COW_VERSION) { | |
75 | goto fail; | |
76 | } | |
3b46e624 | 77 | |
ea2384d3 FB |
78 | /* cow image found */ |
79 | size = be64_to_cpu(cow_header.size); | |
80 | bs->total_sectors = size / 512; | |
81 | ||
5fafdf24 | 82 | pstrcpy(bs->backing_file, sizeof(bs->backing_file), |
ea2384d3 | 83 | cow_header.backing_file); |
3b46e624 | 84 | |
893a9cb4 CH |
85 | bitmap_size = ((bs->total_sectors + 7) >> 3) + sizeof(cow_header); |
86 | s->cow_sectors_offset = (bitmap_size + 511) & ~511; | |
ea2384d3 FB |
87 | return 0; |
88 | fail: | |
ea2384d3 FB |
89 | return -1; |
90 | } | |
91 | ||
893a9cb4 CH |
92 | /* |
93 | * XXX(hch): right now these functions are extremly ineffcient. | |
94 | * We should just read the whole bitmap we'll need in one go instead. | |
95 | */ | |
96 | static inline int cow_set_bit(BlockDriverState *bs, int64_t bitnum) | |
ea2384d3 | 97 | { |
893a9cb4 CH |
98 | uint64_t offset = sizeof(struct cow_header_v2) + bitnum / 8; |
99 | uint8_t bitmap; | |
100 | ||
2063392a | 101 | if (bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap)) != |
893a9cb4 CH |
102 | sizeof(bitmap)) { |
103 | return -errno; | |
104 | } | |
105 | ||
106 | bitmap |= (1 << (bitnum % 8)); | |
107 | ||
2063392a | 108 | if (bdrv_pwrite(bs->file, offset, &bitmap, sizeof(bitmap)) != |
893a9cb4 CH |
109 | sizeof(bitmap)) { |
110 | return -errno; | |
111 | } | |
112 | return 0; | |
ea2384d3 FB |
113 | } |
114 | ||
893a9cb4 | 115 | static inline int is_bit_set(BlockDriverState *bs, int64_t bitnum) |
ea2384d3 | 116 | { |
893a9cb4 CH |
117 | uint64_t offset = sizeof(struct cow_header_v2) + bitnum / 8; |
118 | uint8_t bitmap; | |
ea2384d3 | 119 | |
2063392a | 120 | if (bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap)) != |
893a9cb4 CH |
121 | sizeof(bitmap)) { |
122 | return -errno; | |
123 | } | |
124 | ||
125 | return !!(bitmap & (1 << (bitnum % 8))); | |
126 | } | |
ea2384d3 FB |
127 | |
128 | /* Return true if first block has been changed (ie. current version is | |
129 | * in COW file). Set the number of continuous blocks for which that | |
130 | * is true. */ | |
893a9cb4 CH |
131 | static int cow_is_allocated(BlockDriverState *bs, int64_t sector_num, |
132 | int nb_sectors, int *num_same) | |
ea2384d3 FB |
133 | { |
134 | int changed; | |
135 | ||
893a9cb4 | 136 | if (nb_sectors == 0) { |
ea2384d3 FB |
137 | *num_same = nb_sectors; |
138 | return 0; | |
139 | } | |
140 | ||
893a9cb4 CH |
141 | changed = is_bit_set(bs, sector_num); |
142 | if (changed < 0) { | |
143 | return 0; /* XXX: how to return I/O errors? */ | |
144 | } | |
145 | ||
ea2384d3 | 146 | for (*num_same = 1; *num_same < nb_sectors; (*num_same)++) { |
893a9cb4 | 147 | if (is_bit_set(bs, sector_num + *num_same) != changed) |
ea2384d3 FB |
148 | break; |
149 | } | |
150 | ||
151 | return changed; | |
152 | } | |
153 | ||
893a9cb4 CH |
154 | static int cow_update_bitmap(BlockDriverState *bs, int64_t sector_num, |
155 | int nb_sectors) | |
ea2384d3 | 156 | { |
893a9cb4 CH |
157 | int error = 0; |
158 | int i; | |
159 | ||
160 | for (i = 0; i < nb_sectors; i++) { | |
161 | error = cow_set_bit(bs, sector_num + i); | |
162 | if (error) { | |
163 | break; | |
164 | } | |
165 | } | |
166 | ||
167 | return error; | |
ea2384d3 FB |
168 | } |
169 | ||
5fafdf24 | 170 | static int cow_read(BlockDriverState *bs, int64_t sector_num, |
ea2384d3 FB |
171 | uint8_t *buf, int nb_sectors) |
172 | { | |
173 | BDRVCowState *s = bs->opaque; | |
174 | int ret, n; | |
3b46e624 | 175 | |
ea2384d3 | 176 | while (nb_sectors > 0) { |
893a9cb4 | 177 | if (cow_is_allocated(bs, sector_num, nb_sectors, &n)) { |
2063392a CH |
178 | ret = bdrv_pread(bs->file, |
179 | s->cow_sectors_offset + sector_num * 512, | |
180 | buf, n * 512); | |
5fafdf24 | 181 | if (ret != n * 512) |
ea2384d3 FB |
182 | return -1; |
183 | } else { | |
83f64091 FB |
184 | if (bs->backing_hd) { |
185 | /* read from the base image */ | |
186 | ret = bdrv_read(bs->backing_hd, sector_num, buf, n); | |
187 | if (ret < 0) | |
188 | return -1; | |
189 | } else { | |
ea2384d3 FB |
190 | memset(buf, 0, n * 512); |
191 | } | |
83f64091 | 192 | } |
ea2384d3 FB |
193 | nb_sectors -= n; |
194 | sector_num += n; | |
195 | buf += n * 512; | |
196 | } | |
197 | return 0; | |
198 | } | |
199 | ||
5fafdf24 | 200 | static int cow_write(BlockDriverState *bs, int64_t sector_num, |
ea2384d3 FB |
201 | const uint8_t *buf, int nb_sectors) |
202 | { | |
203 | BDRVCowState *s = bs->opaque; | |
893a9cb4 | 204 | int ret; |
3b46e624 | 205 | |
2063392a CH |
206 | ret = bdrv_pwrite(bs->file, s->cow_sectors_offset + sector_num * 512, |
207 | buf, nb_sectors * 512); | |
5fafdf24 | 208 | if (ret != nb_sectors * 512) |
ea2384d3 | 209 | return -1; |
893a9cb4 CH |
210 | |
211 | return cow_update_bitmap(bs, sector_num, nb_sectors); | |
ea2384d3 FB |
212 | } |
213 | ||
e2731add | 214 | static void cow_close(BlockDriverState *bs) |
ea2384d3 | 215 | { |
ea2384d3 FB |
216 | } |
217 | ||
0e7e1989 | 218 | static int cow_create(const char *filename, QEMUOptionParameter *options) |
ea2384d3 FB |
219 | { |
220 | int fd, cow_fd; | |
221 | struct cow_header_v2 cow_header; | |
222 | struct stat st; | |
0e7e1989 KW |
223 | int64_t image_sectors = 0; |
224 | const char *image_filename = NULL; | |
31f38120 | 225 | int ret; |
0e7e1989 KW |
226 | |
227 | /* Read out options */ | |
228 | while (options && options->name) { | |
229 | if (!strcmp(options->name, BLOCK_OPT_SIZE)) { | |
230 | image_sectors = options->value.n / 512; | |
231 | } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { | |
232 | image_filename = options->value.s; | |
233 | } | |
234 | options++; | |
235 | } | |
ea2384d3 | 236 | |
5fafdf24 | 237 | cow_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, |
ea2384d3 FB |
238 | 0644); |
239 | if (cow_fd < 0) | |
48b66db9 | 240 | return -errno; |
ea2384d3 FB |
241 | memset(&cow_header, 0, sizeof(cow_header)); |
242 | cow_header.magic = cpu_to_be32(COW_MAGIC); | |
243 | cow_header.version = cpu_to_be32(COW_VERSION); | |
244 | if (image_filename) { | |
83f64091 FB |
245 | /* Note: if no file, we put a dummy mtime */ |
246 | cow_header.mtime = cpu_to_be32(0); | |
247 | ||
ea2384d3 FB |
248 | fd = open(image_filename, O_RDONLY | O_BINARY); |
249 | if (fd < 0) { | |
250 | close(cow_fd); | |
83f64091 | 251 | goto mtime_fail; |
ea2384d3 FB |
252 | } |
253 | if (fstat(fd, &st) != 0) { | |
254 | close(fd); | |
83f64091 | 255 | goto mtime_fail; |
ea2384d3 FB |
256 | } |
257 | close(fd); | |
258 | cow_header.mtime = cpu_to_be32(st.st_mtime); | |
83f64091 FB |
259 | mtime_fail: |
260 | pstrcpy(cow_header.backing_file, sizeof(cow_header.backing_file), | |
261 | image_filename); | |
ea2384d3 FB |
262 | } |
263 | cow_header.sectorsize = cpu_to_be32(512); | |
264 | cow_header.size = cpu_to_be64(image_sectors * 512); | |
31f38120 KS |
265 | ret = qemu_write_full(cow_fd, &cow_header, sizeof(cow_header)); |
266 | if (ret != sizeof(cow_header)) { | |
48b66db9 | 267 | ret = -errno; |
31f38120 KS |
268 | goto exit; |
269 | } | |
270 | ||
ea2384d3 | 271 | /* resize to include at least all the bitmap */ |
31f38120 KS |
272 | ret = ftruncate(cow_fd, sizeof(cow_header) + ((image_sectors + 7) >> 3)); |
273 | if (ret) { | |
274 | ret = -errno; | |
275 | goto exit; | |
276 | } | |
277 | ||
31f38120 | 278 | exit: |
ea2384d3 | 279 | close(cow_fd); |
31f38120 | 280 | return ret; |
ea2384d3 FB |
281 | } |
282 | ||
7a6cba61 PB |
283 | static void cow_flush(BlockDriverState *bs) |
284 | { | |
2063392a | 285 | bdrv_flush(bs->file); |
7a6cba61 PB |
286 | } |
287 | ||
0e7e1989 | 288 | static QEMUOptionParameter cow_create_options[] = { |
db08adf5 KW |
289 | { |
290 | .name = BLOCK_OPT_SIZE, | |
291 | .type = OPT_SIZE, | |
292 | .help = "Virtual disk size" | |
293 | }, | |
294 | { | |
295 | .name = BLOCK_OPT_BACKING_FILE, | |
296 | .type = OPT_STRING, | |
297 | .help = "File name of a base image" | |
298 | }, | |
0e7e1989 KW |
299 | { NULL } |
300 | }; | |
301 | ||
5efa9d5a | 302 | static BlockDriver bdrv_cow = { |
e60f469c AJ |
303 | .format_name = "cow", |
304 | .instance_size = sizeof(BDRVCowState), | |
305 | .bdrv_probe = cow_probe, | |
2063392a | 306 | .bdrv_open = cow_open, |
e60f469c AJ |
307 | .bdrv_read = cow_read, |
308 | .bdrv_write = cow_write, | |
309 | .bdrv_close = cow_close, | |
310 | .bdrv_create = cow_create, | |
311 | .bdrv_flush = cow_flush, | |
312 | .bdrv_is_allocated = cow_is_allocated, | |
0e7e1989 KW |
313 | |
314 | .create_options = cow_create_options, | |
ea2384d3 | 315 | }; |
5efa9d5a AL |
316 | |
317 | static void bdrv_cow_init(void) | |
318 | { | |
319 | bdrv_register(&bdrv_cow); | |
320 | } | |
321 | ||
322 | block_init(bdrv_cow_init); |