]> Git Repo - qemu.git/blob - block/nbd.c
target-ppc: fix SPE evcmp* instructions
[qemu.git] / block / nbd.c
1 /*
2  * QEMU Block driver for  NBD
3  *
4  * Copyright (C) 2008 Bull S.A.S.
5  *     Author: Laurent Vivier <[email protected]>
6  *
7  * Some parts:
8  *    Copyright (C) 2007 Anthony Liguori <[email protected]>
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
36 typedef struct BDRVNBDState {
37     int sock;
38     off_t size;
39     size_t blocksize;
40 } BDRVNBDState;
41
42 static 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
96 static 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
126 static 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
156 static 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
170 static int64_t nbd_getlength(BlockDriverState *bs)
171 {
172     BDRVNBDState *s = bs->opaque;
173
174     return s->size;
175 }
176
177 static BlockDriver bdrv_nbd = {
178     .format_name        = "nbd",
179     .instance_size      = sizeof(BDRVNBDState),
180     .bdrv_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
188 static void bdrv_nbd_init(void)
189 {
190     bdrv_register(&bdrv_nbd);
191 }
192
193 block_init(bdrv_nbd_init);
This page took 0.035203 seconds and 4 git commands to generate.