trap signals for "-serial mon:stdio"
[qemu.git] / 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-common.h"
14 #include "include/migration/migration.h"
15
16 /*
17 page = zrun nzrun
18 | zrun nzrun page
19
20 zrun = length
21
22 nzrun = length byte...
23
24 length = uleb128 encoded integer
25 */
26 int xbzrle_encode_buffer(uint8_t *old_buf, uint8_t *new_buf, int slen,
27 uint8_t *dst, int dlen)
28 {
29 uint32_t zrun_len = 0, nzrun_len = 0;
30 int d = 0, i = 0;
31 long res, xor;
32 uint8_t *nzrun_start = NULL;
33
34 g_assert(!(((uintptr_t)old_buf | (uintptr_t)new_buf | slen) %
35 sizeof(long)));
36
37 while (i < slen) {
38 /* overflow */
39 if (d + 2 > dlen) {
40 return -1;
41 }
42
43 /* not aligned to sizeof(long) */
44 res = (slen - i) % sizeof(long);
45 while (res && old_buf[i] == new_buf[i]) {
46 zrun_len++;
47 i++;
48 res--;
49 }
50
51 /* word at a time for speed */
52 if (!res) {
53 while (i < slen &&
54 (*(long *)(old_buf + i)) == (*(long *)(new_buf + i))) {
55 i += sizeof(long);
56 zrun_len += sizeof(long);
57 }
58
59 /* go over the rest */
60 while (i < slen && old_buf[i] == new_buf[i]) {
61 zrun_len++;
62 i++;
63 }
64 }
65
66 /* buffer unchanged */
67 if (zrun_len == slen) {
68 return 0;
69 }
70
71 /* skip last zero run */
72 if (i == slen) {
73 return d;
74 }
75
76 d += uleb128_encode_small(dst + d, zrun_len);
77
78 zrun_len = 0;
79 nzrun_start = new_buf + i;
80
81 /* overflow */
82 if (d + 2 > dlen) {
83 return -1;
84 }
85 /* not aligned to sizeof(long) */
86 res = (slen - i) % sizeof(long);
87 while (res && old_buf[i] != new_buf[i]) {
88 i++;
89 nzrun_len++;
90 res--;
91 }
92
93 /* word at a time for speed, use of 32-bit long okay */
94 if (!res) {
95 /* truncation to 32-bit long okay */
96 long mask = (long)0x0101010101010101ULL;
97 while (i < slen) {
98 xor = *(long *)(old_buf + i) ^ *(long *)(new_buf + i);
99 if ((xor - mask) & ~xor & (mask << 7)) {
100 /* found the end of an nzrun within the current long */
101 while (old_buf[i] != new_buf[i]) {
102 nzrun_len++;
103 i++;
104 }
105 break;
106 } else {
107 i += sizeof(long);
108 nzrun_len += sizeof(long);
109 }
110 }
111 }
112
113 d += uleb128_encode_small(dst + d, nzrun_len);
114 /* overflow */
115 if (d + nzrun_len > dlen) {
116 return -1;
117 }
118 memcpy(dst + d, nzrun_start, nzrun_len);
119 d += nzrun_len;
120 nzrun_len = 0;
121 }
122
123 return d;
124 }
125
126 int xbzrle_decode_buffer(uint8_t *src, int slen, uint8_t *dst, int dlen)
127 {
128 int i = 0, d = 0;
129 int ret;
130 uint32_t count = 0;
131
132 while (i < slen) {
133
134 /* zrun */
135 if ((slen - i) < 2) {
136 return -1;
137 }
138
139 ret = uleb128_decode_small(src + i, &count);
140 if (ret < 0 || (i && !count)) {
141 return -1;
142 }
143 i += ret;
144 d += count;
145
146 /* overflow */
147 if (d > dlen) {
148 return -1;
149 }
150
151 /* nzrun */
152 if ((slen - i) < 2) {
153 return -1;
154 }
155
156 ret = uleb128_decode_small(src + i, &count);
157 if (ret < 0 || !count) {
158 return -1;
159 }
160 i += ret;
161
162 /* overflow */
163 if (d + count > dlen || i + count > slen) {
164 return -1;
165 }
166
167 memcpy(dst + d, src + i, count);
168 d += count;
169 i += count;
170 }
171
172 return d;
173 }