/* Discard length bytes from channel. Return -errno on failure and 0 on
* success*/
-static int drop_sync(QIOChannel *ioc, size_t size)
+static int drop_sync(QIOChannel *ioc, size_t size, Error **errp)
{
ssize_t ret = 0;
char small[1024];
buffer = sizeof(small) >= size ? small : g_malloc(MIN(65536, size));
while (size > 0) {
ssize_t count = MIN(65536, size);
- ret = read_sync(ioc, buffer, MIN(65536, size));
+ ret = read_sync(ioc, buffer, MIN(65536, size), errp);
if (ret < 0) {
goto cleanup;
stl_be_p(&req.option, opt);
stl_be_p(&req.length, len);
- if (write_sync(ioc, &req, sizeof(req)) < 0) {
- error_setg(errp, "Failed to send option request header");
+ if (write_sync(ioc, &req, sizeof(req), errp) < 0) {
+ error_prepend(errp, "Failed to send option request header");
return -1;
}
- if (len && write_sync(ioc, (char *) data, len) < 0) {
- error_setg(errp, "Failed to send option request data");
+ if (len && write_sync(ioc, (char *) data, len, errp) < 0) {
+ error_prepend(errp, "Failed to send option request data");
return -1;
}
nbd_opt_reply *reply, Error **errp)
{
QEMU_BUILD_BUG_ON(sizeof(*reply) != 20);
- if (read_sync(ioc, reply, sizeof(*reply)) < 0) {
- error_setg(errp, "failed to read option reply");
+ if (read_sync(ioc, reply, sizeof(*reply), errp) < 0) {
+ error_prepend(errp, "failed to read option reply");
nbd_send_opt_abort(ioc);
return -1;
}
goto cleanup;
}
msg = g_malloc(reply->length + 1);
- if (read_sync(ioc, msg, reply->length) < 0) {
- error_setg(errp, "failed to read option error message");
+ if (read_sync(ioc, msg, reply->length, errp) < 0) {
+ error_prepend(errp, "failed to read option error message");
goto cleanup;
}
msg[reply->length] = '\0';
nbd_send_opt_abort(ioc);
return -1;
}
- if (read_sync(ioc, &namelen, sizeof(namelen)) < 0) {
- error_setg(errp, "failed to read option name length");
+ if (read_sync(ioc, &namelen, sizeof(namelen), errp) < 0) {
+ error_prepend(errp, "failed to read option name length");
nbd_send_opt_abort(ioc);
return -1;
}
return -1;
}
if (namelen != strlen(want)) {
- if (drop_sync(ioc, len) < 0) {
- error_setg(errp, "failed to skip export name with wrong length");
+ if (drop_sync(ioc, len, errp) < 0) {
+ error_prepend(errp, "failed to skip export name with wrong length");
nbd_send_opt_abort(ioc);
return -1;
}
}
assert(namelen < sizeof(name));
- if (read_sync(ioc, name, namelen) < 0) {
- error_setg(errp, "failed to read export name");
+ if (read_sync(ioc, name, namelen, errp) < 0) {
+ error_prepend(errp, "failed to read export name");
nbd_send_opt_abort(ioc);
return -1;
}
name[namelen] = '\0';
len -= namelen;
- if (drop_sync(ioc, len) < 0) {
- error_setg(errp, "failed to read export description");
+ if (drop_sync(ioc, len, errp) < 0) {
+ error_prepend(errp, "failed to read export description");
nbd_send_opt_abort(ioc);
return -1;
}
goto fail;
}
- if (read_sync(ioc, buf, 8) < 0) {
- error_setg(errp, "Failed to read data");
+ if (read_sync(ioc, buf, 8, errp) < 0) {
+ error_prepend(errp, "Failed to read data");
goto fail;
}
goto fail;
}
- if (read_sync(ioc, &magic, sizeof(magic)) < 0) {
- error_setg(errp, "Failed to read magic");
+ if (read_sync(ioc, &magic, sizeof(magic), errp) < 0) {
+ error_prepend(errp, "Failed to read magic");
goto fail;
}
magic = be64_to_cpu(magic);
uint16_t globalflags;
bool fixedNewStyle = false;
- if (read_sync(ioc, &globalflags, sizeof(globalflags)) < 0) {
- error_setg(errp, "Failed to read server flags");
+ if (read_sync(ioc, &globalflags, sizeof(globalflags), errp) < 0) {
+ error_prepend(errp, "Failed to read server flags");
goto fail;
}
globalflags = be16_to_cpu(globalflags);
}
/* client requested flags */
clientflags = cpu_to_be32(clientflags);
- if (write_sync(ioc, &clientflags, sizeof(clientflags)) < 0) {
- error_setg(errp, "Failed to send clientflags field");
+ if (write_sync(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
+ error_prepend(errp, "Failed to send clientflags field");
goto fail;
}
if (tlscreds) {
}
/* Read the response */
- if (read_sync(ioc, &s, sizeof(s)) < 0) {
- error_setg(errp, "Failed to read export length");
+ if (read_sync(ioc, &s, sizeof(s), errp) < 0) {
+ error_prepend(errp, "Failed to read export length");
goto fail;
}
*size = be64_to_cpu(s);
- if (read_sync(ioc, flags, sizeof(*flags)) < 0) {
- error_setg(errp, "Failed to read export flags");
+ if (read_sync(ioc, flags, sizeof(*flags), errp) < 0) {
+ error_prepend(errp, "Failed to read export flags");
goto fail;
}
be16_to_cpus(flags);
goto fail;
}
- if (read_sync(ioc, &s, sizeof(s)) < 0) {
- error_setg(errp, "Failed to read export length");
+ if (read_sync(ioc, &s, sizeof(s), errp) < 0) {
+ error_prepend(errp, "Failed to read export length");
goto fail;
}
*size = be64_to_cpu(s);
TRACE("Size is %" PRIu64, *size);
- if (read_sync(ioc, &oldflags, sizeof(oldflags)) < 0) {
- error_setg(errp, "Failed to read export flags");
+ if (read_sync(ioc, &oldflags, sizeof(oldflags), errp) < 0) {
+ error_prepend(errp, "Failed to read export flags");
goto fail;
}
be32_to_cpus(&oldflags);
}
TRACE("Size is %" PRIu64 ", export flags %" PRIx16, *size, *flags);
- if (zeroes && drop_sync(ioc, 124) < 0) {
- error_setg(errp, "Failed to read reserved block");
+ if (zeroes && drop_sync(ioc, 124, errp) < 0) {
+ error_prepend(errp, "Failed to read reserved block");
goto fail;
}
rc = 0;
stq_be_p(buf + 16, request->from);
stl_be_p(buf + 24, request->len);
- return write_sync(ioc, buf, sizeof(buf));
+ return write_sync(ioc, buf, sizeof(buf), NULL);
}
ssize_t nbd_receive_reply(QIOChannel *ioc, NBDReply *reply)
uint32_t magic;
ssize_t ret;
- ret = read_sync_eof(ioc, buf, sizeof(buf));
+ ret = read_sync_eof(ioc, buf, sizeof(buf), NULL);
if (ret <= 0) {
return ret;
}
* qio_channel_readv() returns 0. So, there are no needs to call read_sync_eof
* iteratively.
*/
-static inline ssize_t read_sync_eof(QIOChannel *ioc, void *buffer, size_t size)
+static inline ssize_t read_sync_eof(QIOChannel *ioc, void *buffer, size_t size,
+ Error **errp)
{
struct iovec iov = { .iov_base = buffer, .iov_len = size };
/* Sockets are kept in blocking mode in the negotiation phase. After
* our request/reply. Synchronization is done with recv_coroutine, so
* that this is coroutine-safe.
*/
- return nbd_wr_syncv(ioc, &iov, 1, size, true, NULL);
+ return nbd_wr_syncv(ioc, &iov, 1, size, true, errp);
}
/* read_sync
* Reads @size bytes from @ioc. Returns 0 on success.
*/
-static inline int read_sync(QIOChannel *ioc, void *buffer, size_t size)
+static inline int read_sync(QIOChannel *ioc, void *buffer, size_t size,
+ Error **errp)
{
- ssize_t ret = read_sync_eof(ioc, buffer, size);
+ ssize_t ret = read_sync_eof(ioc, buffer, size, errp);
if (ret >= 0 && ret != size) {
ret = -EINVAL;
+ error_setg(errp, "End of file");
}
return ret < 0 ? ret : 0;
/* write_sync
* Writes @size bytes to @ioc. Returns 0 on success.
*/
-static inline int write_sync(QIOChannel *ioc, const void *buffer, size_t size)
+static inline int write_sync(QIOChannel *ioc, const void *buffer, size_t size,
+ Error **errp)
{
struct iovec iov = { .iov_base = (void *) buffer, .iov_len = size };
- ssize_t ret = nbd_wr_syncv(ioc, &iov, 1, size, false, NULL);
+ ssize_t ret = nbd_wr_syncv(ioc, &iov, 1, size, false, errp);
assert(ret < 0 || ret == size);
nbd_negotiate_continue,
qemu_coroutine_self(),
NULL);
- ret = read_sync(ioc, buffer, size);
+ ret = read_sync(ioc, buffer, size, NULL);
g_source_remove(watch);
return ret;
nbd_negotiate_continue,
qemu_coroutine_self(),
NULL);
- ret = write_sync(ioc, buffer, size);
+ ret = write_sync(ioc, buffer, size, NULL);
g_source_remove(watch);
return ret;
}
uint32_t magic;
ssize_t ret;
- ret = read_sync(ioc, buf, sizeof(buf));
+ ret = read_sync(ioc, buf, sizeof(buf), NULL);
if (ret < 0) {
return ret;
}
stl_be_p(buf + 4, reply->error);
stq_be_p(buf + 8, reply->handle);
- return write_sync(ioc, buf, sizeof(buf));
+ return write_sync(ioc, buf, sizeof(buf), NULL);
}
#define MAX_NBD_REQUESTS 16
qio_channel_set_cork(client->ioc, true);
rc = nbd_send_reply(client->ioc, reply);
if (rc >= 0) {
- ret = write_sync(client->ioc, req->data, len);
+ ret = write_sync(client->ioc, req->data, len, NULL);
if (ret < 0) {
rc = -EIO;
}
if (request->type == NBD_CMD_WRITE) {
TRACE("Reading %" PRIu32 " byte(s)", request->len);
- if (read_sync(client->ioc, req->data, request->len) < 0) {
+ if (read_sync(client->ioc, req->data, request->len, NULL) < 0) {
LOG("reading from socket failed");
rc = -EIO;
goto out;