hw/arm/virt-acpi-build: don't save VirtGuestInfo on AcpiBuildState
[qemu.git] / migration / qemu-file-channel.c
1 /*
2 * QEMUFile backend for QIOChannel objects
3 *
4 * Copyright (c) 2015-2016 Red Hat, Inc
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
25 #include "qemu/osdep.h"
26 #include "migration/qemu-file.h"
27 #include "io/channel-socket.h"
28 #include "qemu/iov.h"
29
30
31 static ssize_t channel_writev_buffer(void *opaque,
32 struct iovec *iov,
33 int iovcnt,
34 int64_t pos)
35 {
36 QIOChannel *ioc = QIO_CHANNEL(opaque);
37 ssize_t done = 0;
38 struct iovec *local_iov = g_new(struct iovec, iovcnt);
39 struct iovec *local_iov_head = local_iov;
40 unsigned int nlocal_iov = iovcnt;
41
42 nlocal_iov = iov_copy(local_iov, nlocal_iov,
43 iov, iovcnt,
44 0, iov_size(iov, iovcnt));
45
46 while (nlocal_iov > 0) {
47 ssize_t len;
48 len = qio_channel_writev(ioc, local_iov, nlocal_iov, NULL);
49 if (len == QIO_CHANNEL_ERR_BLOCK) {
50 qio_channel_wait(ioc, G_IO_OUT);
51 continue;
52 }
53 if (len < 0) {
54 /* XXX handle Error objects */
55 done = -EIO;
56 goto cleanup;
57 }
58
59 iov_discard_front(&local_iov, &nlocal_iov, len);
60 done += len;
61 }
62
63 cleanup:
64 g_free(local_iov_head);
65 return done;
66 }
67
68
69 static ssize_t channel_get_buffer(void *opaque,
70 uint8_t *buf,
71 int64_t pos,
72 size_t size)
73 {
74 QIOChannel *ioc = QIO_CHANNEL(opaque);
75 ssize_t ret;
76
77 do {
78 ret = qio_channel_read(ioc, (char *)buf, size, NULL);
79 if (ret < 0) {
80 if (ret == QIO_CHANNEL_ERR_BLOCK) {
81 qio_channel_yield(ioc, G_IO_IN);
82 } else {
83 /* XXX handle Error * object */
84 return -EIO;
85 }
86 }
87 } while (ret == QIO_CHANNEL_ERR_BLOCK);
88
89 return ret;
90 }
91
92
93 static int channel_close(void *opaque)
94 {
95 QIOChannel *ioc = QIO_CHANNEL(opaque);
96 qio_channel_close(ioc, NULL);
97 object_unref(OBJECT(ioc));
98 return 0;
99 }
100
101
102 static int channel_shutdown(void *opaque,
103 bool rd,
104 bool wr)
105 {
106 QIOChannel *ioc = QIO_CHANNEL(opaque);
107
108 if (qio_channel_has_feature(ioc,
109 QIO_CHANNEL_FEATURE_SHUTDOWN)) {
110 QIOChannelShutdown mode;
111 if (rd && wr) {
112 mode = QIO_CHANNEL_SHUTDOWN_BOTH;
113 } else if (rd) {
114 mode = QIO_CHANNEL_SHUTDOWN_READ;
115 } else {
116 mode = QIO_CHANNEL_SHUTDOWN_WRITE;
117 }
118 if (qio_channel_shutdown(ioc, mode, NULL) < 0) {
119 /* XXX handler Error * object */
120 return -EIO;
121 }
122 }
123 return 0;
124 }
125
126
127 static int channel_set_blocking(void *opaque,
128 bool enabled)
129 {
130 QIOChannel *ioc = QIO_CHANNEL(opaque);
131
132 if (qio_channel_set_blocking(ioc, enabled, NULL) < 0) {
133 return -1;
134 }
135 return 0;
136 }
137
138 static QEMUFile *channel_get_input_return_path(void *opaque)
139 {
140 QIOChannel *ioc = QIO_CHANNEL(opaque);
141
142 return qemu_fopen_channel_output(ioc);
143 }
144
145 static QEMUFile *channel_get_output_return_path(void *opaque)
146 {
147 QIOChannel *ioc = QIO_CHANNEL(opaque);
148
149 return qemu_fopen_channel_input(ioc);
150 }
151
152 static const QEMUFileOps channel_input_ops = {
153 .get_buffer = channel_get_buffer,
154 .close = channel_close,
155 .shut_down = channel_shutdown,
156 .set_blocking = channel_set_blocking,
157 .get_return_path = channel_get_input_return_path,
158 };
159
160
161 static const QEMUFileOps channel_output_ops = {
162 .writev_buffer = channel_writev_buffer,
163 .close = channel_close,
164 .shut_down = channel_shutdown,
165 .set_blocking = channel_set_blocking,
166 .get_return_path = channel_get_output_return_path,
167 };
168
169
170 QEMUFile *qemu_fopen_channel_input(QIOChannel *ioc)
171 {
172 object_ref(OBJECT(ioc));
173 return qemu_fopen_ops(ioc, &channel_input_ops);
174 }
175
176 QEMUFile *qemu_fopen_channel_output(QIOChannel *ioc)
177 {
178 object_ref(OBJECT(ioc));
179 return qemu_fopen_ops(ioc, &channel_output_ops);
180 }