ahci: unify sglist preparation
[qemu.git] / qemu-file-unix.c
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
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 #include "qemu-common.h"
25 #include "qemu/iov.h"
26 #include "qemu/sockets.h"
27 #include "block/coroutine.h"
28 #include "migration/qemu-file.h"
29
30 typedef struct QEMUFileSocket {
31 int fd;
32 QEMUFile *file;
33 } QEMUFileSocket;
34
35 static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
36 int64_t pos)
37 {
38 QEMUFileSocket *s = opaque;
39 ssize_t len;
40 ssize_t size = iov_size(iov, iovcnt);
41
42 len = iov_send(s->fd, iov, iovcnt, 0, size);
43 if (len < size) {
44 len = -socket_error();
45 }
46 return len;
47 }
48
49 static int socket_get_fd(void *opaque)
50 {
51 QEMUFileSocket *s = opaque;
52
53 return s->fd;
54 }
55
56 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
57 {
58 QEMUFileSocket *s = opaque;
59 ssize_t len;
60
61 for (;;) {
62 len = qemu_recv(s->fd, buf, size, 0);
63 if (len != -1) {
64 break;
65 }
66 if (socket_error() == EAGAIN) {
67 yield_until_fd_readable(s->fd);
68 } else if (socket_error() != EINTR) {
69 break;
70 }
71 }
72
73 if (len == -1) {
74 len = -socket_error();
75 }
76 return len;
77 }
78
79 static int socket_close(void *opaque)
80 {
81 QEMUFileSocket *s = opaque;
82 closesocket(s->fd);
83 g_free(s);
84 return 0;
85 }
86
87 static ssize_t unix_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
88 int64_t pos)
89 {
90 QEMUFileSocket *s = opaque;
91 ssize_t len, offset;
92 ssize_t size = iov_size(iov, iovcnt);
93 ssize_t total = 0;
94
95 assert(iovcnt > 0);
96 offset = 0;
97 while (size > 0) {
98 /* Find the next start position; skip all full-sized vector elements */
99 while (offset >= iov[0].iov_len) {
100 offset -= iov[0].iov_len;
101 iov++, iovcnt--;
102 }
103
104 /* skip `offset' bytes from the (now) first element, undo it on exit */
105 assert(iovcnt > 0);
106 iov[0].iov_base += offset;
107 iov[0].iov_len -= offset;
108
109 do {
110 len = writev(s->fd, iov, iovcnt);
111 } while (len == -1 && errno == EINTR);
112 if (len == -1) {
113 return -errno;
114 }
115
116 /* Undo the changes above */
117 iov[0].iov_base -= offset;
118 iov[0].iov_len += offset;
119
120 /* Prepare for the next iteration */
121 offset += len;
122 total += len;
123 size -= len;
124 }
125
126 return total;
127 }
128
129 static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
130 {
131 QEMUFileSocket *s = opaque;
132 ssize_t len;
133
134 for (;;) {
135 len = read(s->fd, buf, size);
136 if (len != -1) {
137 break;
138 }
139 if (errno == EAGAIN) {
140 yield_until_fd_readable(s->fd);
141 } else if (errno != EINTR) {
142 break;
143 }
144 }
145
146 if (len == -1) {
147 len = -errno;
148 }
149 return len;
150 }
151
152 static int unix_close(void *opaque)
153 {
154 QEMUFileSocket *s = opaque;
155 close(s->fd);
156 g_free(s);
157 return 0;
158 }
159
160 static const QEMUFileOps unix_read_ops = {
161 .get_fd = socket_get_fd,
162 .get_buffer = unix_get_buffer,
163 .close = unix_close
164 };
165
166 static const QEMUFileOps unix_write_ops = {
167 .get_fd = socket_get_fd,
168 .writev_buffer = unix_writev_buffer,
169 .close = unix_close
170 };
171
172 QEMUFile *qemu_fdopen(int fd, const char *mode)
173 {
174 QEMUFileSocket *s;
175
176 if (mode == NULL ||
177 (mode[0] != 'r' && mode[0] != 'w') ||
178 mode[1] != 'b' || mode[2] != 0) {
179 fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
180 return NULL;
181 }
182
183 s = g_malloc0(sizeof(QEMUFileSocket));
184 s->fd = fd;
185
186 if (mode[0] == 'r') {
187 s->file = qemu_fopen_ops(s, &unix_read_ops);
188 } else {
189 s->file = qemu_fopen_ops(s, &unix_write_ops);
190 }
191 return s->file;
192 }
193
194 static const QEMUFileOps socket_read_ops = {
195 .get_fd = socket_get_fd,
196 .get_buffer = socket_get_buffer,
197 .close = socket_close
198 };
199
200 static const QEMUFileOps socket_write_ops = {
201 .get_fd = socket_get_fd,
202 .writev_buffer = socket_writev_buffer,
203 .close = socket_close
204 };
205
206 QEMUFile *qemu_fopen_socket(int fd, const char *mode)
207 {
208 QEMUFileSocket *s;
209
210 if (qemu_file_mode_is_not_valid(mode)) {
211 return NULL;
212 }
213
214 s = g_malloc0(sizeof(QEMUFileSocket));
215 s->fd = fd;
216 if (mode[0] == 'w') {
217 qemu_set_block(s->fd);
218 s->file = qemu_fopen_ops(s, &socket_write_ops);
219 } else {
220 s->file = qemu_fopen_ops(s, &socket_read_ops);
221 }
222 return s->file;
223 }