mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

io: get rid of bounce buffering in websock write path

Browse Source 
Currently most outbound I/O on the websock channel gets copied into the
rawoutput buffer, and then immediately copied again into the encoutput
buffer, with a header prepended. Now that qio_channel_websock_encode
accepts a struct iovec, we can trivially remove this bounce buffering
and write directly to encoutput.

In doing so, we also now correctly validate the encoutput size against
the QIO_CHANNEL_WEBSOCK_MAX_BUFFER limit.

Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrange 2017-10-09 16:54:07 +01:00
parent fb74e59039
commit 8dfd5f9651
2 changed files with 28 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/io/channel-websock.h
View File

@ -59,7 +59,6 @@ struct QIOChannelWebsock {
Buffer encinput; Buffer encinput;
Buffer encoutput; Buffer encoutput;
Buffer rawinput; Buffer rawinput;
Buffer rawoutput;
size_t payload_remain; size_t payload_remain;
size_t pong_remain; size_t pong_remain;
QIOChannelWebsockMask mask; QIOChannelWebsockMask mask;

64
io/channel-websock.c
View File

@ -24,6 +24,7 @@
#include "io/channel-websock.h" #include "io/channel-websock.h"
#include "crypto/hash.h" #include "crypto/hash.h"
#include "trace.h" #include "trace.h"
#include "qemu/iov.h"
#include <time.h> #include <time.h>
@ -633,19 +634,22 @@ static ssize_t qio_channel_websock_write_wire(QIOChannelWebsock *, Error **);
static void qio_channel_websock_write_close(QIOChannelWebsock *ioc, static void qio_channel_websock_write_close(QIOChannelWebsock *ioc,
uint16_t code, const char *reason) uint16_t code, const char *reason)
{ {
struct iovec iov; struct iovec iov[2] = {
buffer_reserve(&ioc->rawoutput, 2 + (reason ? strlen(reason) : 0)); { .iov_base = &code, .iov_len = sizeof(code) },
*(uint16_t *)(ioc->rawoutput.buffer + ioc->rawoutput.offset) = };
cpu_to_be16(code); size_t niov = 1;
ioc->rawoutput.offset += 2; size_t size = iov[0].iov_len;
cpu_to_be16s(&code);
if (reason) { if (reason) {
buffer_append(&ioc->rawoutput, reason, strlen(reason)); iov[1].iov_base = (void *)reason;
iov[1].iov_len = strlen(reason);
size += iov[1].iov_len;
niov++;
} }
iov.iov_base = ioc->rawoutput.buffer;
iov.iov_len = ioc->rawoutput.offset;
qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE, qio_channel_websock_encode(ioc, QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE,
&iov, 1, iov.iov_len); iov, niov, size);
buffer_reset(&ioc->rawoutput);
qio_channel_websock_write_wire(ioc, NULL); qio_channel_websock_write_wire(ioc, NULL);
qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL); qio_channel_shutdown(ioc->master, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
} }
@ -893,7 +897,6 @@ static void qio_channel_websock_finalize(Object *obj)
buffer_free(&ioc->encinput); buffer_free(&ioc->encinput);
buffer_free(&ioc->encoutput); buffer_free(&ioc->encoutput);
buffer_free(&ioc->rawinput); buffer_free(&ioc->rawinput);
buffer_free(&ioc->rawoutput);
object_unref(OBJECT(ioc->master)); object_unref(OBJECT(ioc->master));
if (ioc->io_tag) { if (ioc->io_tag) {
g_source_remove(ioc->io_tag); g_source_remove(ioc->io_tag);
@ -1103,8 +1106,8 @@ static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
Error **errp) Error **errp)
{ {
QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc); QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK(ioc);
size_t i; ssize_t want = iov_size(iov, niov);
ssize_t done = 0; ssize_t avail;
ssize_t ret; ssize_t ret;
if (wioc->io_err) { if (wioc->io_err) {
@ -1117,32 +1120,21 @@ static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
return -1; return -1;
} }
for (i = 0; i < niov; i++) { avail = wioc->encoutput.offset >= QIO_CHANNEL_WEBSOCK_MAX_BUFFER ?
size_t want = iov[i].iov_len; 0 : (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->encoutput.offset);
if ((want + wioc->rawoutput.offset) > QIO_CHANNEL_WEBSOCK_MAX_BUFFER) { if (want > avail) {
want = (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->rawoutput.offset); want = avail;
}
if (want == 0) {
goto done;
} }
buffer_reserve(&wioc->rawoutput, want); if (want) {
buffer_append(&wioc->rawoutput, iov[i].iov_base, want);
done += want;
if (want < iov[i].iov_len) {
break;
}
}
done:
if (wioc->rawoutput.offset) {
struct iovec iov = { .iov_base = wioc->rawoutput.buffer,
.iov_len = wioc->rawoutput.offset };
qio_channel_websock_encode(wioc, qio_channel_websock_encode(wioc,
QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME, QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME,
&iov, 1, iov.iov_len); iov, niov, want);
buffer_reset(&wioc->rawoutput);
} }
/* Even if want == 0, we'll try write_wire in case there's
* pending data we could usefully flush out
*/
ret = qio_channel_websock_write_wire(wioc, errp); ret = qio_channel_websock_write_wire(wioc, errp);
if (ret < 0 && if (ret < 0 &&
ret != QIO_CHANNEL_ERR_BLOCK) { ret != QIO_CHANNEL_ERR_BLOCK) {
@ -1152,11 +1144,11 @@ static ssize_t qio_channel_websock_writev(QIOChannel *ioc,
qio_channel_websock_set_watch(wioc); qio_channel_websock_set_watch(wioc);
if (done == 0) { if (want == 0) {
return QIO_CHANNEL_ERR_BLOCK; return QIO_CHANNEL_ERR_BLOCK;
} }
return done; return want;
} }
static int qio_channel_websock_set_blocking(QIOChannel *ioc, static int qio_channel_websock_set_blocking(QIOChannel *ioc,