hw/arm/virt-acpi-build: don't save VirtGuestInfo on AcpiBuildState
[qemu.git] / migration / xbzrle.c
1 /*
2 * Xor Based Zero Run Length Encoding
3 *
4 * Copyright 2013 Red Hat, Inc. and/or its affiliates
5 *
6 * Authors:
7 * Orit Wasserman <owasserm@redhat.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 *
12 */
13 #include "qemu/osdep.h"
14 #include "qemu/cutils.h"
15 #include "include/migration/migration.h"
16
17 /*
18 page = zrun nzrun
19 | zrun nzrun page
20
21 zrun = length
22
23 nzrun = length byte...
24
25 length = uleb128 encoded integer
26 */
27 int xbzrle_encode_buffer(uint8_t *old_buf, uint8_t *new_buf, int slen,
28 uint8_t *dst, int dlen)
29 {
30 uint32_t zrun_len = 0, nzrun_len = 0;
31 int d = 0, i = 0;
32 long res;
33 uint8_t *nzrun_start = NULL;
34
35 g_assert(!(((uintptr_t)old_buf | (uintptr_t)new_buf | slen) %
36 sizeof(long)));
37
38 while (i < slen) {
39 /* overflow */
40 if (d + 2 > dlen) {
41 return -1;
42 }
43
44 /* not aligned to sizeof(long) */
45 res = (slen - i) % sizeof(long);
46 while (res && old_buf[i] == new_buf[i]) {
47 zrun_len++;
48 i++;
49 res--;
50 }
51
52 /* word at a time for speed */
53 if (!res) {
54 while (i < slen &&
55 (*(long *)(old_buf + i)) == (*(long *)(new_buf + i))) {
56 i += sizeof(long);
57 zrun_len += sizeof(long);
58 }
59
60 /* go over the rest */
61 while (i < slen && old_buf[i] == new_buf[i]) {
62 zrun_len++;
63 i++;
64 }
65 }
66
67 /* buffer unchanged */
68 if (zrun_len == slen) {
69 return 0;
70 }
71
72 /* skip last zero run */
73 if (i == slen) {
74 return d;
75 }
76
77 d += uleb128_encode_small(dst + d, zrun_len);
78
79 zrun_len = 0;
80 nzrun_start = new_buf + i;
81
82 /* overflow */
83 if (d + 2 > dlen) {
84 return -1;
85 }
86 /* not aligned to sizeof(long) */
87 res = (slen - i) % sizeof(long);
88 while (res && old_buf[i] != new_buf[i]) {
89 i++;
90 nzrun_len++;
91 res--;
92 }
93
94 /* word at a time for speed, use of 32-bit long okay */
95 if (!res) {
96 /* truncation to 32-bit long okay */
97 unsigned long mask = (unsigned long)0x0101010101010101ULL;
98 while (i < slen) {
99 unsigned long xor;
100 xor = *(unsigned long *)(old_buf + i)
101 ^ *(unsigned long *)(new_buf + i);
102 if ((xor - mask) & ~xor & (mask << 7)) {
103 /* found the end of an nzrun within the current long */
104 while (old_buf[i] != new_buf[i]) {
105 nzrun_len++;
106 i++;
107 }
108 break;
109 } else {
110 i += sizeof(long);
111 nzrun_len += sizeof(long);
112 }
113 }
114 }
115
116 d += uleb128_encode_small(dst + d, nzrun_len);
117 /* overflow */
118 if (d + nzrun_len > dlen) {
119 return -1;
120 }
121 memcpy(dst + d, nzrun_start, nzrun_len);
122 d += nzrun_len;
123 nzrun_len = 0;
124 }
125
126 return d;
127 }
128
129 int xbzrle_decode_buffer(uint8_t *src, int slen, uint8_t *dst, int dlen)
130 {
131 int i = 0, d = 0;
132 int ret;
133 uint32_t count = 0;
134
135 while (i < slen) {
136
137 /* zrun */
138 if ((slen - i) < 2) {
139 return -1;
140 }
141
142 ret = uleb128_decode_small(src + i, &count);
143 if (ret < 0 || (i && !count)) {
144 return -1;
145 }
146 i += ret;
147 d += count;
148
149 /* overflow */
150 if (d > dlen) {
151 return -1;
152 }
153
154 /* nzrun */
155 if ((slen - i) < 2) {
156 return -1;
157 }
158
159 ret = uleb128_decode_small(src + i, &count);
160 if (ret < 0 || !count) {
161 return -1;
162 }
163 i += ret;
164
165 /* overflow */
166 if (d + count > dlen || i + count > slen) {
167 return -1;
168 }
169
170 memcpy(dst + d, src + i, count);
171 d += count;
172 i += count;
173 }
174
175 return d;
176 }