Revision 7267c094 block/qcow2-snapshot.c
| b/block/qcow2-snapshot.c | ||
|---|---|---|
| 52 | 52 |
int i; |
| 53 | 53 |
|
| 54 | 54 |
for(i = 0; i < s->nb_snapshots; i++) {
|
| 55 |
qemu_free(s->snapshots[i].name);
|
|
| 56 |
qemu_free(s->snapshots[i].id_str);
|
|
| 55 |
g_free(s->snapshots[i].name);
|
|
| 56 |
g_free(s->snapshots[i].id_str);
|
|
| 57 | 57 |
} |
| 58 |
qemu_free(s->snapshots);
|
|
| 58 |
g_free(s->snapshots);
|
|
| 59 | 59 |
s->snapshots = NULL; |
| 60 | 60 |
s->nb_snapshots = 0; |
| 61 | 61 |
} |
| ... | ... | |
| 76 | 76 |
} |
| 77 | 77 |
|
| 78 | 78 |
offset = s->snapshots_offset; |
| 79 |
s->snapshots = qemu_mallocz(s->nb_snapshots * sizeof(QCowSnapshot));
|
|
| 79 |
s->snapshots = g_malloc0(s->nb_snapshots * sizeof(QCowSnapshot));
|
|
| 80 | 80 |
for(i = 0; i < s->nb_snapshots; i++) {
|
| 81 | 81 |
offset = align_offset(offset, 8); |
| 82 | 82 |
if (bdrv_pread(bs->file, offset, &h, sizeof(h)) != sizeof(h)) |
| ... | ... | |
| 96 | 96 |
|
| 97 | 97 |
offset += extra_data_size; |
| 98 | 98 |
|
| 99 |
sn->id_str = qemu_malloc(id_str_size + 1);
|
|
| 99 |
sn->id_str = g_malloc(id_str_size + 1);
|
|
| 100 | 100 |
if (bdrv_pread(bs->file, offset, sn->id_str, id_str_size) != id_str_size) |
| 101 | 101 |
goto fail; |
| 102 | 102 |
offset += id_str_size; |
| 103 | 103 |
sn->id_str[id_str_size] = '\0'; |
| 104 | 104 |
|
| 105 |
sn->name = qemu_malloc(name_size + 1);
|
|
| 105 |
sn->name = g_malloc(name_size + 1);
|
|
| 106 | 106 |
if (bdrv_pread(bs->file, offset, sn->name, name_size) != name_size) |
| 107 | 107 |
goto fail; |
| 108 | 108 |
offset += name_size; |
| ... | ... | |
| 252 | 252 |
if (find_snapshot_by_id(bs, sn_info->id_str) >= 0) |
| 253 | 253 |
return -ENOENT; |
| 254 | 254 |
|
| 255 |
sn->id_str = qemu_strdup(sn_info->id_str);
|
|
| 255 |
sn->id_str = g_strdup(sn_info->id_str);
|
|
| 256 | 256 |
if (!sn->id_str) |
| 257 | 257 |
goto fail; |
| 258 |
sn->name = qemu_strdup(sn_info->name);
|
|
| 258 |
sn->name = g_strdup(sn_info->name);
|
|
| 259 | 259 |
if (!sn->name) |
| 260 | 260 |
goto fail; |
| 261 | 261 |
sn->vm_state_size = sn_info->vm_state_size; |
| ... | ... | |
| 278 | 278 |
sn->l1_size = s->l1_size; |
| 279 | 279 |
|
| 280 | 280 |
if (s->l1_size != 0) {
|
| 281 |
l1_table = qemu_malloc(s->l1_size * sizeof(uint64_t));
|
|
| 281 |
l1_table = g_malloc(s->l1_size * sizeof(uint64_t));
|
|
| 282 | 282 |
} else {
|
| 283 | 283 |
l1_table = NULL; |
| 284 | 284 |
} |
| ... | ... | |
| 289 | 289 |
if (bdrv_pwrite_sync(bs->file, sn->l1_table_offset, |
| 290 | 290 |
l1_table, s->l1_size * sizeof(uint64_t)) < 0) |
| 291 | 291 |
goto fail; |
| 292 |
qemu_free(l1_table);
|
|
| 292 |
g_free(l1_table);
|
|
| 293 | 293 |
l1_table = NULL; |
| 294 | 294 |
|
| 295 |
snapshots1 = qemu_malloc((s->nb_snapshots + 1) * sizeof(QCowSnapshot));
|
|
| 295 |
snapshots1 = g_malloc((s->nb_snapshots + 1) * sizeof(QCowSnapshot));
|
|
| 296 | 296 |
if (s->snapshots) {
|
| 297 | 297 |
memcpy(snapshots1, s->snapshots, s->nb_snapshots * sizeof(QCowSnapshot)); |
| 298 |
qemu_free(s->snapshots);
|
|
| 298 |
g_free(s->snapshots);
|
|
| 299 | 299 |
} |
| 300 | 300 |
s->snapshots = snapshots1; |
| 301 | 301 |
s->snapshots[s->nb_snapshots++] = *sn; |
| ... | ... | |
| 307 | 307 |
#endif |
| 308 | 308 |
return 0; |
| 309 | 309 |
fail: |
| 310 |
qemu_free(sn->name);
|
|
| 311 |
qemu_free(l1_table);
|
|
| 310 |
g_free(sn->name);
|
|
| 311 |
g_free(l1_table);
|
|
| 312 | 312 |
return -1; |
| 313 | 313 |
} |
| 314 | 314 |
|
| ... | ... | |
| 380 | 380 |
return ret; |
| 381 | 381 |
qcow2_free_clusters(bs, sn->l1_table_offset, sn->l1_size * sizeof(uint64_t)); |
| 382 | 382 |
|
| 383 |
qemu_free(sn->id_str);
|
|
| 384 |
qemu_free(sn->name);
|
|
| 383 |
g_free(sn->id_str);
|
|
| 384 |
g_free(sn->name);
|
|
| 385 | 385 |
memmove(sn, sn + 1, (s->nb_snapshots - snapshot_index - 1) * sizeof(*sn)); |
| 386 | 386 |
s->nb_snapshots--; |
| 387 | 387 |
ret = qcow2_write_snapshots(bs); |
| ... | ... | |
| 407 | 407 |
return s->nb_snapshots; |
| 408 | 408 |
} |
| 409 | 409 |
|
| 410 |
sn_tab = qemu_mallocz(s->nb_snapshots * sizeof(QEMUSnapshotInfo));
|
|
| 410 |
sn_tab = g_malloc0(s->nb_snapshots * sizeof(QEMUSnapshotInfo));
|
|
| 411 | 411 |
for(i = 0; i < s->nb_snapshots; i++) {
|
| 412 | 412 |
sn_info = sn_tab + i; |
| 413 | 413 |
sn = s->snapshots + i; |
| ... | ... | |
| 439 | 439 |
s->l1_size = sn->l1_size; |
| 440 | 440 |
l1_size2 = s->l1_size * sizeof(uint64_t); |
| 441 | 441 |
if (s->l1_table != NULL) {
|
| 442 |
qemu_free(s->l1_table);
|
|
| 442 |
g_free(s->l1_table);
|
|
| 443 | 443 |
} |
| 444 | 444 |
|
| 445 | 445 |
s->l1_table_offset = sn->l1_table_offset; |
| 446 |
s->l1_table = qemu_mallocz(align_offset(l1_size2, 512));
|
|
| 446 |
s->l1_table = g_malloc0(align_offset(l1_size2, 512));
|
|
| 447 | 447 |
|
| 448 | 448 |
if (bdrv_pread(bs->file, sn->l1_table_offset, |
| 449 | 449 |
s->l1_table, l1_size2) != l1_size2) {
|
Also available in: Unified diff