1 /* 2 * QEMU I/O channels memory buffer driver 3 * 4 * Copyright (c) 2015 Red Hat, Inc. 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 18 * 19 */ 20 21 #include "qemu/osdep.h" 22 #include "io/channel-buffer.h" 23 #include "io/channel-watch.h" 24 #include "qemu/module.h" 25 #include "qemu/sockets.h" 26 #include "trace.h" 27 28 QIOChannelBuffer * 29 qio_channel_buffer_new(size_t capacity) 30 { 31 QIOChannelBuffer *ioc; 32 33 ioc = QIO_CHANNEL_BUFFER(object_new(TYPE_QIO_CHANNEL_BUFFER)); 34 35 if (capacity) { 36 ioc->data = g_new0(uint8_t, capacity); 37 ioc->capacity = capacity; 38 } 39 40 return ioc; 41 } 42 43 44 static void qio_channel_buffer_finalize(Object *obj) 45 { 46 QIOChannelBuffer *ioc = QIO_CHANNEL_BUFFER(obj); 47 g_free(ioc->data); 48 ioc->capacity = ioc->usage = ioc->offset = 0; 49 } 50 51 52 static ssize_t qio_channel_buffer_readv(QIOChannel *ioc, 53 const struct iovec *iov, 54 size_t niov, 55 int **fds, 56 size_t *nfds, 57 int flags, 58 Error **errp) 59 { 60 QIOChannelBuffer *bioc = QIO_CHANNEL_BUFFER(ioc); 61 ssize_t ret = 0; 62 size_t i; 63 64 for (i = 0; i < niov; i++) { 65 size_t want = iov[i].iov_len; 66 if (bioc->offset >= bioc->usage) { 67 break; 68 } 69 if ((bioc->offset + want) > bioc->usage) { 70 want = bioc->usage - bioc->offset; 71 } 72 memcpy(iov[i].iov_base, bioc->data + bioc->offset, want); 73 ret += want; 74 bioc->offset += want; 75 } 76 77 return ret; 78 } 79 80 static ssize_t qio_channel_buffer_writev(QIOChannel *ioc, 81 const struct iovec *iov, 82 size_t niov, 83 int *fds, 84 size_t nfds, 85 int flags, 86 Error **errp) 87 { 88 QIOChannelBuffer *bioc = QIO_CHANNEL_BUFFER(ioc); 89 ssize_t ret = 0; 90 size_t i; 91 size_t towrite = 0; 92 93 for (i = 0; i < niov; i++) { 94 towrite += iov[i].iov_len; 95 } 96 97 if ((bioc->offset + towrite) > bioc->capacity) { 98 bioc->capacity = bioc->offset + towrite; 99 bioc->data = g_realloc(bioc->data, bioc->capacity); 100 } 101 102 if (bioc->offset > bioc->usage) { 103 memset(bioc->data, 0, bioc->offset - bioc->usage); 104 bioc->usage = bioc->offset; 105 } 106 107 for (i = 0; i < niov; i++) { 108 memcpy(bioc->data + bioc->usage, 109 iov[i].iov_base, 110 iov[i].iov_len); 111 bioc->usage += iov[i].iov_len; 112 bioc->offset += iov[i].iov_len; 113 ret += iov[i].iov_len; 114 } 115 116 return ret; 117 } 118 119 static int qio_channel_buffer_set_blocking(QIOChannel *ioc G_GNUC_UNUSED, 120 bool enabled G_GNUC_UNUSED, 121 Error **errp G_GNUC_UNUSED) 122 { 123 return 0; 124 } 125 126 127 static off_t qio_channel_buffer_seek(QIOChannel *ioc, 128 off_t offset, 129 int whence, 130 Error **errp) 131 { 132 QIOChannelBuffer *bioc = QIO_CHANNEL_BUFFER(ioc); 133 134 bioc->offset = offset; 135 136 return offset; 137 } 138 139 140 static int qio_channel_buffer_close(QIOChannel *ioc, 141 Error **errp) 142 { 143 QIOChannelBuffer *bioc = QIO_CHANNEL_BUFFER(ioc); 144 145 g_free(bioc->data); 146 bioc->data = NULL; 147 bioc->capacity = bioc->usage = bioc->offset = 0; 148 149 return 0; 150 } 151 152 153 typedef struct QIOChannelBufferSource QIOChannelBufferSource; 154 struct QIOChannelBufferSource { 155 GSource parent; 156 QIOChannelBuffer *bioc; 157 GIOCondition condition; 158 }; 159 160 static gboolean 161 qio_channel_buffer_source_prepare(GSource *source, 162 gint *timeout) 163 { 164 QIOChannelBufferSource *bsource = (QIOChannelBufferSource *)source; 165 166 *timeout = -1; 167 168 return (G_IO_IN | G_IO_OUT) & bsource->condition; 169 } 170 171 static gboolean 172 qio_channel_buffer_source_check(GSource *source) 173 { 174 QIOChannelBufferSource *bsource = (QIOChannelBufferSource *)source; 175 176 return (G_IO_IN | G_IO_OUT) & bsource->condition; 177 } 178 179 static gboolean 180 qio_channel_buffer_source_dispatch(GSource *source, 181 GSourceFunc callback, 182 gpointer user_data) 183 { 184 QIOChannelFunc func = (QIOChannelFunc)callback; 185 QIOChannelBufferSource *bsource = (QIOChannelBufferSource *)source; 186 187 return (*func)(QIO_CHANNEL(bsource->bioc), 188 ((G_IO_IN | G_IO_OUT) & bsource->condition), 189 user_data); 190 } 191 192 static void 193 qio_channel_buffer_source_finalize(GSource *source) 194 { 195 QIOChannelBufferSource *ssource = (QIOChannelBufferSource *)source; 196 197 object_unref(OBJECT(ssource->bioc)); 198 } 199 200 GSourceFuncs qio_channel_buffer_source_funcs = { 201 qio_channel_buffer_source_prepare, 202 qio_channel_buffer_source_check, 203 qio_channel_buffer_source_dispatch, 204 qio_channel_buffer_source_finalize 205 }; 206 207 static GSource *qio_channel_buffer_create_watch(QIOChannel *ioc, 208 GIOCondition condition) 209 { 210 QIOChannelBuffer *bioc = QIO_CHANNEL_BUFFER(ioc); 211 QIOChannelBufferSource *ssource; 212 GSource *source; 213 214 source = g_source_new(&qio_channel_buffer_source_funcs, 215 sizeof(QIOChannelBufferSource)); 216 ssource = (QIOChannelBufferSource *)source; 217 218 ssource->bioc = bioc; 219 object_ref(OBJECT(bioc)); 220 221 ssource->condition = condition; 222 223 return source; 224 } 225 226 227 static void qio_channel_buffer_class_init(ObjectClass *klass, 228 void *class_data G_GNUC_UNUSED) 229 { 230 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass); 231 232 ioc_klass->io_writev = qio_channel_buffer_writev; 233 ioc_klass->io_readv = qio_channel_buffer_readv; 234 ioc_klass->io_set_blocking = qio_channel_buffer_set_blocking; 235 ioc_klass->io_seek = qio_channel_buffer_seek; 236 ioc_klass->io_close = qio_channel_buffer_close; 237 ioc_klass->io_create_watch = qio_channel_buffer_create_watch; 238 } 239 240 static const TypeInfo qio_channel_buffer_info = { 241 .parent = TYPE_QIO_CHANNEL, 242 .name = TYPE_QIO_CHANNEL_BUFFER, 243 .instance_size = sizeof(QIOChannelBuffer), 244 .instance_finalize = qio_channel_buffer_finalize, 245 .class_init = qio_channel_buffer_class_init, 246 }; 247 248 static void qio_channel_buffer_register_types(void) 249 { 250 type_register_static(&qio_channel_buffer_info); 251 } 252 253 type_init(qio_channel_buffer_register_types); 254