2016-01-14 09:41:02 +01:00
|
|
|
/*
|
|
|
|
* NBD Internal Declarations
|
|
|
|
*
|
|
|
|
* Copyright (C) 2016 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef NBD_INTERNAL_H
|
|
|
|
#define NBD_INTERNAL_H
|
|
|
|
#include "block/nbd.h"
|
|
|
|
#include "sysemu/block-backend.h"
|
2016-02-10 19:41:11 +01:00
|
|
|
#include "io/channel-tls.h"
|
2016-01-14 09:41:02 +01:00
|
|
|
|
|
|
|
#include "qemu/coroutine.h"
|
2016-02-10 19:41:04 +01:00
|
|
|
#include "qemu/iov.h"
|
2016-01-14 09:41:02 +01:00
|
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#endif
|
|
|
|
#if defined(__sun__) || defined(__HAIKU__)
|
|
|
|
#include <sys/ioccom.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#endif
|
|
|
|
|
2016-03-15 17:22:36 +01:00
|
|
|
#include "qemu/bswap.h"
|
2016-01-14 09:41:02 +01:00
|
|
|
#include "qemu/queue.h"
|
|
|
|
#include "qemu/main-loop.h"
|
|
|
|
|
|
|
|
/* #define DEBUG_NBD */
|
|
|
|
|
|
|
|
#ifdef DEBUG_NBD
|
2016-04-06 05:35:03 +02:00
|
|
|
#define DEBUG_NBD_PRINT 1
|
2016-01-14 09:41:02 +01:00
|
|
|
#else
|
2016-04-06 05:35:03 +02:00
|
|
|
#define DEBUG_NBD_PRINT 0
|
2016-01-14 09:41:02 +01:00
|
|
|
#endif
|
|
|
|
|
2016-04-06 05:35:03 +02:00
|
|
|
#define TRACE(msg, ...) do { \
|
|
|
|
if (DEBUG_NBD_PRINT) { \
|
|
|
|
LOG(msg, ## __VA_ARGS__); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2016-01-14 09:41:02 +01:00
|
|
|
#define LOG(msg, ...) do { \
|
|
|
|
fprintf(stderr, "%s:%s():L%d: " msg "\n", \
|
|
|
|
__FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
|
2016-04-06 05:35:03 +02:00
|
|
|
} while (0)
|
2016-01-14 09:41:02 +01:00
|
|
|
|
|
|
|
/* This is all part of the "official" NBD API.
|
|
|
|
*
|
|
|
|
* The most up-to-date documentation is available at:
|
2016-10-14 20:33:04 +02:00
|
|
|
* https://github.com/yoe/nbd/blob/master/doc/proto.md
|
2016-01-14 09:41:02 +01:00
|
|
|
*/
|
|
|
|
|
2016-10-14 20:33:04 +02:00
|
|
|
#define NBD_REQUEST_SIZE (4 + 2 + 2 + 8 + 8 + 4)
|
2016-01-14 09:41:02 +01:00
|
|
|
#define NBD_REPLY_SIZE (4 + 4 + 8)
|
|
|
|
#define NBD_REQUEST_MAGIC 0x25609513
|
|
|
|
#define NBD_REPLY_MAGIC 0x67446698
|
|
|
|
#define NBD_OPTS_MAGIC 0x49484156454F5054LL
|
|
|
|
#define NBD_CLIENT_MAGIC 0x0000420281861253LL
|
2016-10-14 20:33:10 +02:00
|
|
|
#define NBD_REP_MAGIC 0x0003e889045565a9LL
|
2016-01-14 09:41:02 +01:00
|
|
|
|
|
|
|
#define NBD_SET_SOCK _IO(0xab, 0)
|
|
|
|
#define NBD_SET_BLKSIZE _IO(0xab, 1)
|
|
|
|
#define NBD_SET_SIZE _IO(0xab, 2)
|
|
|
|
#define NBD_DO_IT _IO(0xab, 3)
|
|
|
|
#define NBD_CLEAR_SOCK _IO(0xab, 4)
|
|
|
|
#define NBD_CLEAR_QUE _IO(0xab, 5)
|
|
|
|
#define NBD_PRINT_DEBUG _IO(0xab, 6)
|
|
|
|
#define NBD_SET_SIZE_BLOCKS _IO(0xab, 7)
|
|
|
|
#define NBD_DISCONNECT _IO(0xab, 8)
|
|
|
|
#define NBD_SET_TIMEOUT _IO(0xab, 9)
|
|
|
|
#define NBD_SET_FLAGS _IO(0xab, 10)
|
|
|
|
|
|
|
|
#define NBD_OPT_EXPORT_NAME (1)
|
|
|
|
#define NBD_OPT_ABORT (2)
|
|
|
|
#define NBD_OPT_LIST (3)
|
2016-02-10 19:41:11 +01:00
|
|
|
#define NBD_OPT_PEEK_EXPORT (4)
|
|
|
|
#define NBD_OPT_STARTTLS (5)
|
2016-01-14 09:41:02 +01:00
|
|
|
|
|
|
|
/* NBD errors are based on errno numbers, so there is a 1:1 mapping,
|
|
|
|
* but only a limited set of errno values is specified in the protocol.
|
|
|
|
* Everything else is squashed to EINVAL.
|
|
|
|
*/
|
|
|
|
#define NBD_SUCCESS 0
|
|
|
|
#define NBD_EPERM 1
|
|
|
|
#define NBD_EIO 5
|
|
|
|
#define NBD_ENOMEM 12
|
|
|
|
#define NBD_EINVAL 22
|
|
|
|
#define NBD_ENOSPC 28
|
2016-10-14 20:33:16 +02:00
|
|
|
#define NBD_ESHUTDOWN 108
|
2016-01-14 09:41:02 +01:00
|
|
|
|
2017-06-02 17:01:39 +02:00
|
|
|
/* nbd_read_eof
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
* Tries to read @size bytes from @ioc. Returns number of bytes actually read.
|
|
|
|
* May return a value >= 0 and < size only on EOF, i.e. when iteratively called
|
2017-06-02 17:01:39 +02:00
|
|
|
* qio_channel_readv() returns 0. So, there is no need to call nbd_read_eof
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
* iteratively.
|
|
|
|
*/
|
2017-06-02 17:01:39 +02:00
|
|
|
static inline ssize_t nbd_read_eof(QIOChannel *ioc, void *buffer, size_t size,
|
|
|
|
Error **errp)
|
2016-01-14 09:41:02 +01:00
|
|
|
{
|
2016-02-10 19:41:04 +01:00
|
|
|
struct iovec iov = { .iov_base = buffer, .iov_len = size };
|
2016-01-14 09:41:02 +01:00
|
|
|
/* Sockets are kept in blocking mode in the negotiation phase. After
|
|
|
|
* that, a non-readable socket simply means that another thread stole
|
|
|
|
* our request/reply. Synchronization is done with recv_coroutine, so
|
|
|
|
* that this is coroutine-safe.
|
|
|
|
*/
|
2017-06-02 17:01:39 +02:00
|
|
|
return nbd_rwv(ioc, &iov, 1, size, true, errp);
|
2016-01-14 09:41:02 +01:00
|
|
|
}
|
|
|
|
|
2017-06-02 17:01:39 +02:00
|
|
|
/* nbd_read
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
* Reads @size bytes from @ioc. Returns 0 on success.
|
|
|
|
*/
|
2017-06-02 17:01:39 +02:00
|
|
|
static inline int nbd_read(QIOChannel *ioc, void *buffer, size_t size,
|
|
|
|
Error **errp)
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
{
|
2017-06-02 17:01:39 +02:00
|
|
|
ssize_t ret = nbd_read_eof(ioc, buffer, size, errp);
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
|
|
|
|
if (ret >= 0 && ret != size) {
|
|
|
|
ret = -EINVAL;
|
2017-05-16 11:45:32 +02:00
|
|
|
error_setg(errp, "End of file");
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret < 0 ? ret : 0;
|
|
|
|
}
|
|
|
|
|
2017-06-02 17:01:39 +02:00
|
|
|
/* nbd_write
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
* Writes @size bytes to @ioc. Returns 0 on success.
|
|
|
|
*/
|
2017-06-02 17:01:39 +02:00
|
|
|
static inline int nbd_write(QIOChannel *ioc, const void *buffer, size_t size,
|
|
|
|
Error **errp)
|
2016-01-14 09:41:02 +01:00
|
|
|
{
|
2016-10-14 20:33:03 +02:00
|
|
|
struct iovec iov = { .iov_base = (void *) buffer, .iov_len = size };
|
2016-02-10 19:41:04 +01:00
|
|
|
|
2017-06-02 17:01:39 +02:00
|
|
|
ssize_t ret = nbd_rwv(ioc, &iov, 1, size, false, errp);
|
nbd: read_sync and friends: return 0 on success
functions read_sync, drop_sync, write_sync, and also
nbd_negotiate_write, nbd_negotiate_read, nbd_negotiate_drop_sync
returns number of processed bytes. But what this number can be,
except requested number of bytes?
Actually, underlying nbd_wr_syncv function returns a value >= 0 and
!= requested_bytes only on eof on read operation. So, firstly, it is
impossible on write (let's add an assert) and on read it actually
means, that communication is broken (except nbd_receive_reply, see
below).
Most of callers operate like this:
if (func(..., size) != size) {
/* error path */
}
, i.e.:
1. They are not interested in partial success
2. Extra duplications in code (especially bad are duplications of
magic numbers)
3. User doesn't see actual error message, as return code is lost.
(this patch doesn't fix this point, but it makes fixing easier)
Several callers handles ret >= 0 and != requested-size separately, by
just returning EINVAL in this case. This patch makes read_sync and
friends return EINVAL in this case, so final behavior is the same.
And only one caller - nbd_receive_reply() does something not so
obvious. It returns EINVAL for ret > 0 and != requested-size, like
previous group, but for ret == 0 it returns 0. The only caller of
nbd_receive_reply() - nbd_read_reply_entry() handles ret == 0 in the
same way as ret < 0, so for now it doesn't matter. However, in
following commits error path handling will be improved and we'll need
to distinguish success from fail in this case too. So, this patch adds
separate helper for this case - read_sync_eof.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20170516094533.6160-3-vsementsov@virtuozzo.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-16 11:45:30 +02:00
|
|
|
|
|
|
|
assert(ret < 0 || ret == size);
|
|
|
|
|
|
|
|
return ret < 0 ? ret : 0;
|
2016-01-14 09:41:02 +01:00
|
|
|
}
|
|
|
|
|
2016-02-10 19:41:11 +01:00
|
|
|
struct NBDTLSHandshakeData {
|
|
|
|
GMainLoop *loop;
|
|
|
|
bool complete;
|
|
|
|
Error *error;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2016-08-11 16:20:58 +02:00
|
|
|
void nbd_tls_handshake(QIOTask *task,
|
2016-02-10 19:41:11 +01:00
|
|
|
void *opaque);
|
|
|
|
|
2017-06-02 17:01:40 +02:00
|
|
|
int nbd_drop(QIOChannel *ioc, size_t size, Error **errp);
|
|
|
|
|
2016-01-14 09:41:02 +01:00
|
|
|
#endif
|