1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
/*
* Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
*
* Network Block Device Common Code
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; under version 2 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include "trace.h"
#include "nbd-internal.h"
/* Discard length bytes from channel. Return -errno on failure and 0 on
* success */
int nbd_drop(QIOChannel *ioc, size_t size, Error **errp)
{
ssize_t ret = 0;
char small[1024];
char *buffer;
buffer = sizeof(small) >= size ? small : g_malloc(MIN(65536, size));
while (size > 0) {
ssize_t count = MIN(65536, size);
ret = nbd_read(ioc, buffer, MIN(65536, size), errp);
if (ret < 0) {
goto cleanup;
}
size -= count;
}
cleanup:
if (buffer != small) {
g_free(buffer);
}
return ret;
}
void nbd_tls_handshake(QIOTask *task,
void *opaque)
{
struct NBDTLSHandshakeData *data = opaque;
qio_task_propagate_error(task, &data->error);
data->complete = true;
g_main_loop_quit(data->loop);
}
const char *nbd_opt_lookup(uint32_t opt)
{
switch (opt) {
case NBD_OPT_EXPORT_NAME:
return "export name";
case NBD_OPT_ABORT:
return "abort";
case NBD_OPT_LIST:
return "list";
case NBD_OPT_STARTTLS:
return "starttls";
case NBD_OPT_INFO:
return "info";
case NBD_OPT_GO:
return "go";
case NBD_OPT_STRUCTURED_REPLY:
return "structured reply";
case NBD_OPT_LIST_META_CONTEXT:
return "list meta context";
case NBD_OPT_SET_META_CONTEXT:
return "set meta context";
default:
return "<unknown>";
}
}
const char *nbd_rep_lookup(uint32_t rep)
{
switch (rep) {
case NBD_REP_ACK:
return "ack";
case NBD_REP_SERVER:
return "server";
case NBD_REP_INFO:
return "info";
case NBD_REP_META_CONTEXT:
return "meta context";
case NBD_REP_ERR_UNSUP:
return "unsupported";
case NBD_REP_ERR_POLICY:
return "denied by policy";
case NBD_REP_ERR_INVALID:
return "invalid";
case NBD_REP_ERR_PLATFORM:
return "platform lacks support";
case NBD_REP_ERR_TLS_REQD:
return "TLS required";
case NBD_REP_ERR_UNKNOWN:
return "export unknown";
case NBD_REP_ERR_SHUTDOWN:
return "server shutting down";
case NBD_REP_ERR_BLOCK_SIZE_REQD:
return "block size required";
default:
return "<unknown>";
}
}
const char *nbd_info_lookup(uint16_t info)
{
switch (info) {
case NBD_INFO_EXPORT:
return "export";
case NBD_INFO_NAME:
return "name";
case NBD_INFO_DESCRIPTION:
return "description";
case NBD_INFO_BLOCK_SIZE:
return "block size";
default:
return "<unknown>";
}
}
const char *nbd_cmd_lookup(uint16_t cmd)
{
switch (cmd) {
case NBD_CMD_READ:
return "read";
case NBD_CMD_WRITE:
return "write";
case NBD_CMD_DISC:
return "disconnect";
case NBD_CMD_FLUSH:
return "flush";
case NBD_CMD_TRIM:
return "trim";
case NBD_CMD_WRITE_ZEROES:
return "write zeroes";
case NBD_CMD_BLOCK_STATUS:
return "block status";
default:
return "<unknown>";
}
}
const char *nbd_reply_type_lookup(uint16_t type)
{
switch (type) {
case NBD_REPLY_TYPE_NONE:
return "none";
case NBD_REPLY_TYPE_OFFSET_DATA:
return "data";
case NBD_REPLY_TYPE_OFFSET_HOLE:
return "hole";
case NBD_REPLY_TYPE_BLOCK_STATUS:
return "block status";
case NBD_REPLY_TYPE_ERROR:
return "generic error";
case NBD_REPLY_TYPE_ERROR_OFFSET:
return "error at offset";
default:
if (type & (1 << 15)) {
return "<unknown error>";
}
return "<unknown>";
}
}
const char *nbd_err_lookup(int err)
{
switch (err) {
case NBD_SUCCESS:
return "success";
case NBD_EPERM:
return "EPERM";
case NBD_EIO:
return "EIO";
case NBD_ENOMEM:
return "ENOMEM";
case NBD_EINVAL:
return "EINVAL";
case NBD_ENOSPC:
return "ENOSPC";
case NBD_EOVERFLOW:
return "EOVERFLOW";
case NBD_ESHUTDOWN:
return "ESHUTDOWN";
default:
return "<unknown>";
}
}
int nbd_errno_to_system_errno(int err)
{
int ret;
switch (err) {
case NBD_SUCCESS:
ret = 0;
break;
case NBD_EPERM:
ret = EPERM;
break;
case NBD_EIO:
ret = EIO;
break;
case NBD_ENOMEM:
ret = ENOMEM;
break;
case NBD_ENOSPC:
ret = ENOSPC;
break;
case NBD_EOVERFLOW:
ret = EOVERFLOW;
break;
case NBD_ESHUTDOWN:
ret = ESHUTDOWN;
break;
default:
trace_nbd_unknown_error(err);
/* fallthrough */
case NBD_EINVAL:
ret = EINVAL;
break;
}
return ret;
}
|
