1/*
2 * QEMU Block driver for  NBD
3 *
4 * Copyright (C) 2008 Bull S.A.S.
5 *     Author: Laurent Vivier <Laurent.Vivier@bull.net>
6 *
7 * Some parts:
8 *    Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 * THE SOFTWARE.
27 */
28
29#include "qemu-common.h"
30#include "nbd.h"
31#include "module.h"
32
33#include <sys/types.h>
34#include <unistd.h>
35
36typedef struct BDRVNBDState {
37    int sock;
38    off_t size;
39    size_t blocksize;
40} BDRVNBDState;
41
42static int nbd_open(BlockDriverState *bs, const char* filename, int flags)
43{
44    BDRVNBDState *s = bs->opaque;
45    const char *host;
46    const char *unixpath;
47    int sock;
48    off_t size;
49    size_t blocksize;
50    int ret;
51
52    if (!strstart(filename, "nbd:", &host))
53        return -EINVAL;
54
55    if (strstart(host, "unix:", &unixpath)) {
56
57        if (unixpath[0] != '/')
58            return -EINVAL;
59
60        sock = unix_socket_outgoing(unixpath);
61
62    } else {
63        uint16_t port;
64        char *p, *r;
65        char hostname[128];
66
67        pstrcpy(hostname, 128, host);
68
69        p = strchr(hostname, ':');
70        if (p == NULL)
71            return -EINVAL;
72
73        *p = '\0';
74        p++;
75
76        port = strtol(p, &r, 0);
77        if (r == p)
78            return -EINVAL;
79        sock = tcp_socket_outgoing(hostname, port);
80    }
81
82    if (sock == -1)
83        return -errno;
84
85    ret = nbd_receive_negotiate(sock, &size, &blocksize);
86    if (ret == -1)
87        return -errno;
88
89    s->sock = sock;
90    s->size = size;
91    s->blocksize = blocksize;
92
93    return 0;
94}
95
96static int nbd_read(BlockDriverState *bs, int64_t sector_num,
97                    uint8_t *buf, int nb_sectors)
98{
99    BDRVNBDState *s = bs->opaque;
100    struct nbd_request request;
101    struct nbd_reply reply;
102
103    request.type = NBD_CMD_READ;
104    request.handle = (uint64_t)(intptr_t)bs;
105    request.from = sector_num * 512;;
106    request.len = nb_sectors * 512;
107
108    if (nbd_send_request(s->sock, &request) == -1)
109        return -errno;
110
111    if (nbd_receive_reply(s->sock, &reply) == -1)
112        return -errno;
113
114    if (reply.error !=0)
115        return -reply.error;
116
117    if (reply.handle != request.handle)
118        return -EIO;
119
120    if (nbd_wr_sync(s->sock, buf, request.len, 1) != request.len)
121        return -EIO;
122
123    return 0;
124}
125
126static int nbd_write(BlockDriverState *bs, int64_t sector_num,
127                     const uint8_t *buf, int nb_sectors)
128{
129    BDRVNBDState *s = bs->opaque;
130    struct nbd_request request;
131    struct nbd_reply reply;
132
133    request.type = NBD_CMD_WRITE;
134    request.handle = (uint64_t)(intptr_t)bs;
135    request.from = sector_num * 512;;
136    request.len = nb_sectors * 512;
137
138    if (nbd_send_request(s->sock, &request) == -1)
139        return -errno;
140
141    if (nbd_wr_sync(s->sock, (uint8_t*)buf, request.len, 0) != request.len)
142        return -EIO;
143
144    if (nbd_receive_reply(s->sock, &reply) == -1)
145        return -errno;
146
147    if (reply.error !=0)
148        return -reply.error;
149
150    if (reply.handle != request.handle)
151        return -EIO;
152
153    return 0;
154}
155
156static void nbd_close(BlockDriverState *bs)
157{
158    BDRVNBDState *s = bs->opaque;
159    struct nbd_request request;
160
161    request.type = NBD_CMD_DISC;
162    request.handle = (uint64_t)(intptr_t)bs;
163    request.from = 0;
164    request.len = 0;
165    nbd_send_request(s->sock, &request);
166
167    close(s->sock);
168}
169
170static int64_t nbd_getlength(BlockDriverState *bs)
171{
172    BDRVNBDState *s = bs->opaque;
173
174    return s->size;
175}
176
177static BlockDriver bdrv_nbd = {
178    .format_name	= "nbd",
179    .instance_size	= sizeof(BDRVNBDState),
180    .bdrv_file_open	= nbd_open,
181    .bdrv_read		= nbd_read,
182    .bdrv_write		= nbd_write,
183    .bdrv_close		= nbd_close,
184    .bdrv_getlength	= nbd_getlength,
185    .protocol_name	= "nbd",
186};
187
188static void bdrv_nbd_init(void)
189{
190    bdrv_register(&bdrv_nbd);
191}
192
193block_init(bdrv_nbd_init);
194