]>
Commit | Line | Data |
---|---|---|
83f64091 | 1 | /* |
223d4670 | 2 | * Block driver for RAW files (posix) |
5fafdf24 | 3 | * |
83f64091 | 4 | * Copyright (c) 2006 Fabrice Bellard |
5fafdf24 | 5 | * |
83f64091 FB |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
faf07963 | 24 | #include "qemu-common.h" |
87ecb68b | 25 | #include "qemu-timer.h" |
baf35cb9 | 26 | #include "qemu-char.h" |
0bf9e31a | 27 | #include "qemu-log.h" |
83f64091 | 28 | #include "block_int.h" |
5efa9d5a | 29 | #include "module.h" |
9ef91a67 | 30 | #include "block/raw-posix-aio.h" |
83f64091 | 31 | |
83affaa6 | 32 | #if defined(__APPLE__) && (__MACH__) |
83f64091 FB |
33 | #include <paths.h> |
34 | #include <sys/param.h> | |
35 | #include <IOKit/IOKitLib.h> | |
36 | #include <IOKit/IOBSD.h> | |
37 | #include <IOKit/storage/IOMediaBSDClient.h> | |
38 | #include <IOKit/storage/IOMedia.h> | |
39 | #include <IOKit/storage/IOCDMedia.h> | |
40 | //#include <IOKit/storage/IOCDTypes.h> | |
41 | #include <CoreFoundation/CoreFoundation.h> | |
42 | #endif | |
43 | ||
44 | #ifdef __sun__ | |
2e9671da | 45 | #define _POSIX_PTHREAD_SEMANTICS 1 |
83f64091 FB |
46 | #include <sys/dkio.h> |
47 | #endif | |
19cb3738 | 48 | #ifdef __linux__ |
343f8568 JS |
49 | #include <sys/types.h> |
50 | #include <sys/stat.h> | |
19cb3738 | 51 | #include <sys/ioctl.h> |
05acda4d | 52 | #include <sys/param.h> |
19cb3738 FB |
53 | #include <linux/cdrom.h> |
54 | #include <linux/fd.h> | |
5500316d PB |
55 | #include <linux/fs.h> |
56 | #endif | |
57 | #ifdef CONFIG_FIEMAP | |
58 | #include <linux/fiemap.h> | |
19cb3738 | 59 | #endif |
a167ba50 | 60 | #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) |
1cb6c3fd | 61 | #include <sys/disk.h> |
9f23011a | 62 | #include <sys/cdio.h> |
1cb6c3fd | 63 | #endif |
83f64091 | 64 | |
128ab2ff BS |
65 | #ifdef __OpenBSD__ |
66 | #include <sys/ioctl.h> | |
67 | #include <sys/disklabel.h> | |
68 | #include <sys/dkio.h> | |
69 | #endif | |
70 | ||
d1f6fd8d CE |
71 | #ifdef __NetBSD__ |
72 | #include <sys/ioctl.h> | |
73 | #include <sys/disklabel.h> | |
74 | #include <sys/dkio.h> | |
75 | #include <sys/disk.h> | |
76 | #endif | |
77 | ||
c5e97233 BS |
78 | #ifdef __DragonFly__ |
79 | #include <sys/ioctl.h> | |
80 | #include <sys/diskslice.h> | |
81 | #endif | |
82 | ||
dce512de CH |
83 | #ifdef CONFIG_XFS |
84 | #include <xfs/xfs.h> | |
85 | #endif | |
86 | ||
19cb3738 | 87 | //#define DEBUG_FLOPPY |
83f64091 | 88 | |
faf07963 | 89 | //#define DEBUG_BLOCK |
03ff3ca3 | 90 | #if defined(DEBUG_BLOCK) |
001faf32 BS |
91 | #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \ |
92 | { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0) | |
8c05dbf9 | 93 | #else |
001faf32 | 94 | #define DEBUG_BLOCK_PRINT(formatCstr, ...) |
8c05dbf9 TS |
95 | #endif |
96 | ||
f6465578 AL |
97 | /* OS X does not have O_DSYNC */ |
98 | #ifndef O_DSYNC | |
1c27a8b3 | 99 | #ifdef O_SYNC |
7ab064d2 | 100 | #define O_DSYNC O_SYNC |
1c27a8b3 JA |
101 | #elif defined(O_FSYNC) |
102 | #define O_DSYNC O_FSYNC | |
103 | #endif | |
f6465578 AL |
104 | #endif |
105 | ||
9f7965c7 AL |
106 | /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */ |
107 | #ifndef O_DIRECT | |
108 | #define O_DIRECT O_DSYNC | |
109 | #endif | |
110 | ||
19cb3738 FB |
111 | #define FTYPE_FILE 0 |
112 | #define FTYPE_CD 1 | |
113 | #define FTYPE_FD 2 | |
83f64091 | 114 | |
c57c846a | 115 | /* if the FD is not accessed during that time (in ns), we try to |
19cb3738 | 116 | reopen it to see if the disk has been changed */ |
c57c846a | 117 | #define FD_OPEN_TIMEOUT (1000000000) |
83f64091 | 118 | |
581b9e29 CH |
119 | #define MAX_BLOCKSIZE 4096 |
120 | ||
19cb3738 FB |
121 | typedef struct BDRVRawState { |
122 | int fd; | |
123 | int type; | |
0e1d8f4c | 124 | int open_flags; |
19cb3738 FB |
125 | #if defined(__linux__) |
126 | /* linux floppy specific */ | |
19cb3738 FB |
127 | int64_t fd_open_time; |
128 | int64_t fd_error_time; | |
129 | int fd_got_error; | |
130 | int fd_media_changed; | |
83f64091 | 131 | #endif |
e44bd6fc | 132 | #ifdef CONFIG_LINUX_AIO |
5c6c3a6c | 133 | int use_aio; |
1e5b9d2f | 134 | void *aio_ctx; |
e44bd6fc | 135 | #endif |
581b9e29 CH |
136 | uint8_t *aligned_buf; |
137 | unsigned aligned_buf_size; | |
dce512de CH |
138 | #ifdef CONFIG_XFS |
139 | bool is_xfs : 1; | |
140 | #endif | |
19cb3738 FB |
141 | } BDRVRawState; |
142 | ||
143 | static int fd_open(BlockDriverState *bs); | |
22afa7b5 | 144 | static int64_t raw_getlength(BlockDriverState *bs); |
83f64091 | 145 | |
a167ba50 | 146 | #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) |
f3a5d3f8 | 147 | static int cdrom_reopen(BlockDriverState *bs); |
9f23011a BS |
148 | #endif |
149 | ||
1de1ae0a CE |
150 | #if defined(__NetBSD__) |
151 | static int raw_normalize_devicepath(const char **filename) | |
152 | { | |
153 | static char namebuf[PATH_MAX]; | |
154 | const char *dp, *fname; | |
155 | struct stat sb; | |
156 | ||
157 | fname = *filename; | |
158 | dp = strrchr(fname, '/'); | |
159 | if (lstat(fname, &sb) < 0) { | |
160 | fprintf(stderr, "%s: stat failed: %s\n", | |
161 | fname, strerror(errno)); | |
162 | return -errno; | |
163 | } | |
164 | ||
165 | if (!S_ISBLK(sb.st_mode)) { | |
166 | return 0; | |
167 | } | |
168 | ||
169 | if (dp == NULL) { | |
170 | snprintf(namebuf, PATH_MAX, "r%s", fname); | |
171 | } else { | |
172 | snprintf(namebuf, PATH_MAX, "%.*s/r%s", | |
173 | (int)(dp - fname), fname, dp + 1); | |
174 | } | |
175 | fprintf(stderr, "%s is a block device", fname); | |
176 | *filename = namebuf; | |
177 | fprintf(stderr, ", using %s\n", *filename); | |
178 | ||
179 | return 0; | |
180 | } | |
181 | #else | |
182 | static int raw_normalize_devicepath(const char **filename) | |
183 | { | |
184 | return 0; | |
185 | } | |
186 | #endif | |
187 | ||
90babde0 | 188 | static int raw_open_common(BlockDriverState *bs, const char *filename, |
19a3da7f | 189 | int bdrv_flags, int open_flags) |
83f64091 FB |
190 | { |
191 | BDRVRawState *s = bs->opaque; | |
0e1d8f4c | 192 | int fd, ret; |
83f64091 | 193 | |
1de1ae0a CE |
194 | ret = raw_normalize_devicepath(&filename); |
195 | if (ret != 0) { | |
196 | return ret; | |
197 | } | |
198 | ||
19a3da7f | 199 | s->open_flags = open_flags | O_BINARY; |
11a1feb6 | 200 | s->open_flags &= ~O_ACCMODE; |
f5edb014 | 201 | if (bdrv_flags & BDRV_O_RDWR) { |
0e1d8f4c | 202 | s->open_flags |= O_RDWR; |
83f64091 | 203 | } else { |
0e1d8f4c | 204 | s->open_flags |= O_RDONLY; |
83f64091 | 205 | } |
9f7965c7 AL |
206 | |
207 | /* Use O_DSYNC for write-through caching, no flags for write-back caching, | |
208 | * and O_DIRECT for no caching. */ | |
19a3da7f | 209 | if ((bdrv_flags & BDRV_O_NOCACHE)) |
0e1d8f4c | 210 | s->open_flags |= O_DIRECT; |
a6599793 | 211 | if (!(bdrv_flags & BDRV_O_CACHE_WB)) |
0e1d8f4c | 212 | s->open_flags |= O_DSYNC; |
83f64091 | 213 | |
90babde0 | 214 | s->fd = -1; |
40ff6d7e | 215 | fd = qemu_open(filename, s->open_flags, 0644); |
19cb3738 FB |
216 | if (fd < 0) { |
217 | ret = -errno; | |
218 | if (ret == -EROFS) | |
219 | ret = -EACCES; | |
220 | return ret; | |
221 | } | |
83f64091 | 222 | s->fd = fd; |
bed5cc52 | 223 | s->aligned_buf = NULL; |
5c6c3a6c | 224 | |
19a3da7f | 225 | if ((bdrv_flags & BDRV_O_NOCACHE)) { |
581b9e29 CH |
226 | /* |
227 | * Allocate a buffer for read/modify/write cycles. Chose the size | |
228 | * pessimistically as we don't know the block size yet. | |
229 | */ | |
230 | s->aligned_buf_size = 32 * MAX_BLOCKSIZE; | |
231 | s->aligned_buf = qemu_memalign(MAX_BLOCKSIZE, s->aligned_buf_size); | |
bed5cc52 | 232 | if (s->aligned_buf == NULL) { |
9ef91a67 | 233 | goto out_close; |
bed5cc52 FB |
234 | } |
235 | } | |
9ef91a67 | 236 | |
f6e8ffc2 FZ |
237 | /* We're falling back to POSIX AIO in some cases so init always */ |
238 | if (paio_init() < 0) { | |
239 | goto out_free_buf; | |
240 | } | |
241 | ||
5c6c3a6c | 242 | #ifdef CONFIG_LINUX_AIO |
c30e624d FZ |
243 | /* |
244 | * Currently Linux do AIO only for files opened with O_DIRECT | |
245 | * specified so check NOCACHE flag too | |
246 | */ | |
5c6c3a6c CH |
247 | if ((bdrv_flags & (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) == |
248 | (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) { | |
d2e46345 | 249 | |
5c6c3a6c CH |
250 | s->aio_ctx = laio_init(); |
251 | if (!s->aio_ctx) { | |
252 | goto out_free_buf; | |
253 | } | |
254 | s->use_aio = 1; | |
255 | } else | |
256 | #endif | |
257 | { | |
e44bd6fc | 258 | #ifdef CONFIG_LINUX_AIO |
5c6c3a6c | 259 | s->use_aio = 0; |
e44bd6fc | 260 | #endif |
9ef91a67 CH |
261 | } |
262 | ||
dce512de CH |
263 | #ifdef CONFIG_XFS |
264 | if (platform_test_xfs_fd(s->fd)) { | |
265 | s->is_xfs = 1; | |
266 | } | |
267 | #endif | |
268 | ||
83f64091 | 269 | return 0; |
9ef91a67 CH |
270 | |
271 | out_free_buf: | |
272 | qemu_vfree(s->aligned_buf); | |
273 | out_close: | |
274 | close(fd); | |
275 | return -errno; | |
83f64091 FB |
276 | } |
277 | ||
90babde0 CH |
278 | static int raw_open(BlockDriverState *bs, const char *filename, int flags) |
279 | { | |
280 | BDRVRawState *s = bs->opaque; | |
281 | ||
282 | s->type = FTYPE_FILE; | |
9a2d77ad | 283 | return raw_open_common(bs, filename, flags, 0); |
90babde0 CH |
284 | } |
285 | ||
83f64091 FB |
286 | /* XXX: use host sector size if necessary with: |
287 | #ifdef DIOCGSECTORSIZE | |
288 | { | |
289 | unsigned int sectorsize = 512; | |
290 | if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) && | |
291 | sectorsize > bufsize) | |
292 | bufsize = sectorsize; | |
293 | } | |
294 | #endif | |
295 | #ifdef CONFIG_COCOA | |
2ee9fb48 | 296 | uint32_t blockSize = 512; |
83f64091 FB |
297 | if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) { |
298 | bufsize = blockSize; | |
299 | } | |
300 | #endif | |
301 | */ | |
302 | ||
9ef91a67 CH |
303 | /* |
304 | * Check if all memory in this vector is sector aligned. | |
305 | */ | |
581b9e29 | 306 | static int qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov) |
a76bab49 | 307 | { |
9ef91a67 | 308 | int i; |
83f64091 | 309 | |
9ef91a67 | 310 | for (i = 0; i < qiov->niov; i++) { |
581b9e29 | 311 | if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) { |
9ef91a67 | 312 | return 0; |
c16b5a2c | 313 | } |
c16b5a2c | 314 | } |
c16b5a2c | 315 | |
9ef91a67 | 316 | return 1; |
c16b5a2c CH |
317 | } |
318 | ||
9ef91a67 CH |
319 | static BlockDriverAIOCB *raw_aio_submit(BlockDriverState *bs, |
320 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
321 | BlockDriverCompletionFunc *cb, void *opaque, int type) | |
83f64091 | 322 | { |
ce1a14dc | 323 | BDRVRawState *s = bs->opaque; |
ce1a14dc | 324 | |
19cb3738 FB |
325 | if (fd_open(bs) < 0) |
326 | return NULL; | |
327 | ||
f141eafe AL |
328 | /* |
329 | * If O_DIRECT is used the buffer needs to be aligned on a sector | |
c1ee7d56 | 330 | * boundary. Check if this is the case or tell the low-level |
9ef91a67 | 331 | * driver that it needs to copy the buffer. |
f141eafe | 332 | */ |
5c6c3a6c | 333 | if (s->aligned_buf) { |
581b9e29 | 334 | if (!qiov_is_aligned(bs, qiov)) { |
5c6c3a6c | 335 | type |= QEMU_AIO_MISALIGNED; |
e44bd6fc | 336 | #ifdef CONFIG_LINUX_AIO |
5c6c3a6c CH |
337 | } else if (s->use_aio) { |
338 | return laio_submit(bs, s->aio_ctx, s->fd, sector_num, qiov, | |
e44bd6fc SW |
339 | nb_sectors, cb, opaque, type); |
340 | #endif | |
5c6c3a6c | 341 | } |
9ef91a67 | 342 | } |
f141eafe | 343 | |
1e5b9d2f | 344 | return paio_submit(bs, s->fd, sector_num, qiov, nb_sectors, |
9ef91a67 | 345 | cb, opaque, type); |
83f64091 FB |
346 | } |
347 | ||
f141eafe AL |
348 | static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, |
349 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
ce1a14dc | 350 | BlockDriverCompletionFunc *cb, void *opaque) |
83f64091 | 351 | { |
9ef91a67 CH |
352 | return raw_aio_submit(bs, sector_num, qiov, nb_sectors, |
353 | cb, opaque, QEMU_AIO_READ); | |
83f64091 FB |
354 | } |
355 | ||
f141eafe AL |
356 | static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, |
357 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
ce1a14dc | 358 | BlockDriverCompletionFunc *cb, void *opaque) |
83f64091 | 359 | { |
9ef91a67 CH |
360 | return raw_aio_submit(bs, sector_num, qiov, nb_sectors, |
361 | cb, opaque, QEMU_AIO_WRITE); | |
83f64091 | 362 | } |
53538725 | 363 | |
b2e12bc6 CH |
364 | static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs, |
365 | BlockDriverCompletionFunc *cb, void *opaque) | |
366 | { | |
367 | BDRVRawState *s = bs->opaque; | |
368 | ||
369 | if (fd_open(bs) < 0) | |
370 | return NULL; | |
371 | ||
1e5b9d2f | 372 | return paio_submit(bs, s->fd, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH); |
b2e12bc6 CH |
373 | } |
374 | ||
83f64091 FB |
375 | static void raw_close(BlockDriverState *bs) |
376 | { | |
377 | BDRVRawState *s = bs->opaque; | |
19cb3738 FB |
378 | if (s->fd >= 0) { |
379 | close(s->fd); | |
380 | s->fd = -1; | |
bed5cc52 | 381 | if (s->aligned_buf != NULL) |
f8a83245 | 382 | qemu_vfree(s->aligned_buf); |
19cb3738 | 383 | } |
83f64091 FB |
384 | } |
385 | ||
386 | static int raw_truncate(BlockDriverState *bs, int64_t offset) | |
387 | { | |
388 | BDRVRawState *s = bs->opaque; | |
55b949c8 CH |
389 | struct stat st; |
390 | ||
391 | if (fstat(s->fd, &st)) { | |
83f64091 | 392 | return -errno; |
55b949c8 CH |
393 | } |
394 | ||
395 | if (S_ISREG(st.st_mode)) { | |
396 | if (ftruncate(s->fd, offset) < 0) { | |
397 | return -errno; | |
398 | } | |
399 | } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { | |
400 | if (offset > raw_getlength(bs)) { | |
401 | return -EINVAL; | |
402 | } | |
403 | } else { | |
404 | return -ENOTSUP; | |
405 | } | |
406 | ||
83f64091 FB |
407 | return 0; |
408 | } | |
409 | ||
128ab2ff BS |
410 | #ifdef __OpenBSD__ |
411 | static int64_t raw_getlength(BlockDriverState *bs) | |
412 | { | |
413 | BDRVRawState *s = bs->opaque; | |
414 | int fd = s->fd; | |
415 | struct stat st; | |
416 | ||
417 | if (fstat(fd, &st)) | |
418 | return -1; | |
419 | if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { | |
420 | struct disklabel dl; | |
421 | ||
422 | if (ioctl(fd, DIOCGDINFO, &dl)) | |
423 | return -1; | |
424 | return (uint64_t)dl.d_secsize * | |
425 | dl.d_partitions[DISKPART(st.st_rdev)].p_size; | |
426 | } else | |
427 | return st.st_size; | |
428 | } | |
d1f6fd8d CE |
429 | #elif defined(__NetBSD__) |
430 | static int64_t raw_getlength(BlockDriverState *bs) | |
431 | { | |
432 | BDRVRawState *s = bs->opaque; | |
433 | int fd = s->fd; | |
434 | struct stat st; | |
435 | ||
436 | if (fstat(fd, &st)) | |
437 | return -1; | |
438 | if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { | |
439 | struct dkwedge_info dkw; | |
440 | ||
441 | if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) { | |
442 | return dkw.dkw_size * 512; | |
443 | } else { | |
444 | struct disklabel dl; | |
445 | ||
446 | if (ioctl(fd, DIOCGDINFO, &dl)) | |
447 | return -1; | |
448 | return (uint64_t)dl.d_secsize * | |
449 | dl.d_partitions[DISKPART(st.st_rdev)].p_size; | |
450 | } | |
451 | } else | |
452 | return st.st_size; | |
453 | } | |
50779cc2 CH |
454 | #elif defined(__sun__) |
455 | static int64_t raw_getlength(BlockDriverState *bs) | |
456 | { | |
457 | BDRVRawState *s = bs->opaque; | |
458 | struct dk_minfo minfo; | |
459 | int ret; | |
460 | ||
461 | ret = fd_open(bs); | |
462 | if (ret < 0) { | |
463 | return ret; | |
464 | } | |
465 | ||
466 | /* | |
467 | * Use the DKIOCGMEDIAINFO ioctl to read the size. | |
468 | */ | |
469 | ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo); | |
470 | if (ret != -1) { | |
471 | return minfo.dki_lbsize * minfo.dki_capacity; | |
472 | } | |
473 | ||
474 | /* | |
475 | * There are reports that lseek on some devices fails, but | |
476 | * irc discussion said that contingency on contingency was overkill. | |
477 | */ | |
478 | return lseek(s->fd, 0, SEEK_END); | |
479 | } | |
480 | #elif defined(CONFIG_BSD) | |
481 | static int64_t raw_getlength(BlockDriverState *bs) | |
83f64091 FB |
482 | { |
483 | BDRVRawState *s = bs->opaque; | |
484 | int fd = s->fd; | |
485 | int64_t size; | |
83f64091 | 486 | struct stat sb; |
a167ba50 | 487 | #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) |
9f23011a | 488 | int reopened = 0; |
83f64091 | 489 | #endif |
19cb3738 FB |
490 | int ret; |
491 | ||
492 | ret = fd_open(bs); | |
493 | if (ret < 0) | |
494 | return ret; | |
83f64091 | 495 | |
a167ba50 | 496 | #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) |
9f23011a BS |
497 | again: |
498 | #endif | |
83f64091 FB |
499 | if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) { |
500 | #ifdef DIOCGMEDIASIZE | |
501 | if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size)) | |
c5e97233 BS |
502 | #elif defined(DIOCGPART) |
503 | { | |
504 | struct partinfo pi; | |
505 | if (ioctl(fd, DIOCGPART, &pi) == 0) | |
506 | size = pi.media_size; | |
507 | else | |
508 | size = 0; | |
509 | } | |
510 | if (size == 0) | |
83f64091 | 511 | #endif |
83affaa6 | 512 | #if defined(__APPLE__) && defined(__MACH__) |
83f64091 FB |
513 | size = LONG_LONG_MAX; |
514 | #else | |
515 | size = lseek(fd, 0LL, SEEK_END); | |
9f23011a | 516 | #endif |
a167ba50 | 517 | #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) |
9f23011a BS |
518 | switch(s->type) { |
519 | case FTYPE_CD: | |
520 | /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */ | |
521 | if (size == 2048LL * (unsigned)-1) | |
522 | size = 0; | |
523 | /* XXX no disc? maybe we need to reopen... */ | |
f3a5d3f8 | 524 | if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) { |
9f23011a BS |
525 | reopened = 1; |
526 | goto again; | |
527 | } | |
528 | } | |
83f64091 | 529 | #endif |
50779cc2 | 530 | } else { |
83f64091 FB |
531 | size = lseek(fd, 0, SEEK_END); |
532 | } | |
83f64091 FB |
533 | return size; |
534 | } | |
50779cc2 CH |
535 | #else |
536 | static int64_t raw_getlength(BlockDriverState *bs) | |
537 | { | |
538 | BDRVRawState *s = bs->opaque; | |
539 | int ret; | |
540 | ||
541 | ret = fd_open(bs); | |
542 | if (ret < 0) { | |
543 | return ret; | |
544 | } | |
545 | ||
546 | return lseek(s->fd, 0, SEEK_END); | |
547 | } | |
128ab2ff | 548 | #endif |
83f64091 | 549 | |
4a1d5e1f FZ |
550 | static int64_t raw_get_allocated_file_size(BlockDriverState *bs) |
551 | { | |
552 | struct stat st; | |
553 | BDRVRawState *s = bs->opaque; | |
554 | ||
555 | if (fstat(s->fd, &st) < 0) { | |
556 | return -errno; | |
557 | } | |
558 | return (int64_t)st.st_blocks * 512; | |
559 | } | |
560 | ||
0e7e1989 | 561 | static int raw_create(const char *filename, QEMUOptionParameter *options) |
83f64091 FB |
562 | { |
563 | int fd; | |
1e37d059 | 564 | int result = 0; |
0e7e1989 | 565 | int64_t total_size = 0; |
83f64091 | 566 | |
0e7e1989 KW |
567 | /* Read out options */ |
568 | while (options && options->name) { | |
569 | if (!strcmp(options->name, BLOCK_OPT_SIZE)) { | |
9040385d | 570 | total_size = options->value.n / BDRV_SECTOR_SIZE; |
0e7e1989 KW |
571 | } |
572 | options++; | |
573 | } | |
83f64091 | 574 | |
5fafdf24 | 575 | fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, |
83f64091 | 576 | 0644); |
1e37d059 SW |
577 | if (fd < 0) { |
578 | result = -errno; | |
579 | } else { | |
9040385d | 580 | if (ftruncate(fd, total_size * BDRV_SECTOR_SIZE) != 0) { |
1e37d059 SW |
581 | result = -errno; |
582 | } | |
583 | if (close(fd) != 0) { | |
584 | result = -errno; | |
585 | } | |
586 | } | |
587 | return result; | |
83f64091 FB |
588 | } |
589 | ||
5500316d PB |
590 | /* |
591 | * Returns true iff the specified sector is present in the disk image. Drivers | |
592 | * not implementing the functionality are assumed to not support backing files, | |
593 | * hence all their sectors are reported as allocated. | |
594 | * | |
595 | * If 'sector_num' is beyond the end of the disk image the return value is 0 | |
596 | * and 'pnum' is set to 0. | |
597 | * | |
598 | * 'pnum' is set to the number of sectors (including and immediately following | |
599 | * the specified sector) that are known to be in the same | |
600 | * allocated/unallocated state. | |
601 | * | |
602 | * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes | |
603 | * beyond the end of the disk image it will be clamped. | |
604 | */ | |
605 | static int coroutine_fn raw_co_is_allocated(BlockDriverState *bs, | |
606 | int64_t sector_num, | |
607 | int nb_sectors, int *pnum) | |
608 | { | |
609 | BDRVRawState *s = bs->opaque; | |
610 | off_t start, data, hole; | |
611 | int ret; | |
612 | ||
613 | ret = fd_open(bs); | |
614 | if (ret < 0) { | |
615 | return ret; | |
616 | } | |
617 | ||
618 | start = sector_num * BDRV_SECTOR_SIZE; | |
619 | #ifdef CONFIG_FIEMAP | |
620 | struct { | |
621 | struct fiemap fm; | |
622 | struct fiemap_extent fe; | |
623 | } f; | |
624 | f.fm.fm_start = start; | |
625 | f.fm.fm_length = (int64_t)nb_sectors * BDRV_SECTOR_SIZE; | |
626 | f.fm.fm_flags = 0; | |
627 | f.fm.fm_extent_count = 1; | |
628 | f.fm.fm_reserved = 0; | |
629 | if (ioctl(s->fd, FS_IOC_FIEMAP, &f) == -1) { | |
630 | /* Assume everything is allocated. */ | |
631 | *pnum = nb_sectors; | |
632 | return 1; | |
633 | } | |
634 | ||
635 | if (f.fm.fm_mapped_extents == 0) { | |
636 | /* No extents found, data is beyond f.fm.fm_start + f.fm.fm_length. | |
637 | * f.fm.fm_start + f.fm.fm_length must be clamped to the file size! | |
638 | */ | |
639 | off_t length = lseek(s->fd, 0, SEEK_END); | |
640 | hole = f.fm.fm_start; | |
641 | data = MIN(f.fm.fm_start + f.fm.fm_length, length); | |
642 | } else { | |
643 | data = f.fe.fe_logical; | |
644 | hole = f.fe.fe_logical + f.fe.fe_length; | |
645 | } | |
646 | #elif defined SEEK_HOLE && defined SEEK_DATA | |
647 | hole = lseek(s->fd, start, SEEK_HOLE); | |
648 | if (hole == -1) { | |
649 | /* -ENXIO indicates that sector_num was past the end of the file. | |
650 | * There is a virtual hole there. */ | |
651 | assert(errno != -ENXIO); | |
652 | ||
653 | /* Most likely EINVAL. Assume everything is allocated. */ | |
654 | *pnum = nb_sectors; | |
655 | return 1; | |
656 | } | |
657 | ||
658 | if (hole > start) { | |
659 | data = start; | |
660 | } else { | |
661 | /* On a hole. We need another syscall to find its end. */ | |
662 | data = lseek(s->fd, start, SEEK_DATA); | |
663 | if (data == -1) { | |
664 | data = lseek(s->fd, 0, SEEK_END); | |
665 | } | |
666 | } | |
667 | #else | |
668 | *pnum = nb_sectors; | |
669 | return 1; | |
670 | #endif | |
671 | ||
672 | if (data <= start) { | |
673 | /* On a data extent, compute sectors to the end of the extent. */ | |
674 | *pnum = MIN(nb_sectors, (hole - start) / BDRV_SECTOR_SIZE); | |
675 | return 1; | |
676 | } else { | |
677 | /* On a hole, compute sectors to the beginning of the next extent. */ | |
678 | *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE); | |
679 | return 0; | |
680 | } | |
681 | } | |
682 | ||
dce512de CH |
683 | #ifdef CONFIG_XFS |
684 | static int xfs_discard(BDRVRawState *s, int64_t sector_num, int nb_sectors) | |
685 | { | |
686 | struct xfs_flock64 fl; | |
687 | ||
688 | memset(&fl, 0, sizeof(fl)); | |
689 | fl.l_whence = SEEK_SET; | |
690 | fl.l_start = sector_num << 9; | |
691 | fl.l_len = (int64_t)nb_sectors << 9; | |
692 | ||
693 | if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) { | |
694 | DEBUG_BLOCK_PRINT("cannot punch hole (%s)\n", strerror(errno)); | |
695 | return -errno; | |
696 | } | |
697 | ||
698 | return 0; | |
699 | } | |
700 | #endif | |
701 | ||
6db39ae2 PB |
702 | static coroutine_fn int raw_co_discard(BlockDriverState *bs, |
703 | int64_t sector_num, int nb_sectors) | |
dce512de CH |
704 | { |
705 | #ifdef CONFIG_XFS | |
706 | BDRVRawState *s = bs->opaque; | |
707 | ||
708 | if (s->is_xfs) { | |
709 | return xfs_discard(s, sector_num, nb_sectors); | |
710 | } | |
711 | #endif | |
712 | ||
713 | return 0; | |
714 | } | |
0e7e1989 KW |
715 | |
716 | static QEMUOptionParameter raw_create_options[] = { | |
db08adf5 KW |
717 | { |
718 | .name = BLOCK_OPT_SIZE, | |
719 | .type = OPT_SIZE, | |
720 | .help = "Virtual disk size" | |
721 | }, | |
0e7e1989 KW |
722 | { NULL } |
723 | }; | |
724 | ||
84a12e66 CH |
725 | static BlockDriver bdrv_file = { |
726 | .format_name = "file", | |
727 | .protocol_name = "file", | |
856ae5c3 BS |
728 | .instance_size = sizeof(BDRVRawState), |
729 | .bdrv_probe = NULL, /* no probe for protocols */ | |
66f82cee | 730 | .bdrv_file_open = raw_open, |
856ae5c3 BS |
731 | .bdrv_close = raw_close, |
732 | .bdrv_create = raw_create, | |
6db39ae2 | 733 | .bdrv_co_discard = raw_co_discard, |
5500316d | 734 | .bdrv_co_is_allocated = raw_co_is_allocated, |
3b46e624 | 735 | |
f141eafe AL |
736 | .bdrv_aio_readv = raw_aio_readv, |
737 | .bdrv_aio_writev = raw_aio_writev, | |
b2e12bc6 | 738 | .bdrv_aio_flush = raw_aio_flush, |
3c529d93 | 739 | |
83f64091 FB |
740 | .bdrv_truncate = raw_truncate, |
741 | .bdrv_getlength = raw_getlength, | |
4a1d5e1f FZ |
742 | .bdrv_get_allocated_file_size |
743 | = raw_get_allocated_file_size, | |
0e7e1989 KW |
744 | |
745 | .create_options = raw_create_options, | |
83f64091 FB |
746 | }; |
747 | ||
19cb3738 FB |
748 | /***********************************************/ |
749 | /* host device */ | |
750 | ||
83affaa6 | 751 | #if defined(__APPLE__) && defined(__MACH__) |
19cb3738 FB |
752 | static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator ); |
753 | static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize ); | |
754 | ||
755 | kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator ) | |
756 | { | |
5fafdf24 | 757 | kern_return_t kernResult; |
19cb3738 FB |
758 | mach_port_t masterPort; |
759 | CFMutableDictionaryRef classesToMatch; | |
760 | ||
761 | kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort ); | |
762 | if ( KERN_SUCCESS != kernResult ) { | |
763 | printf( "IOMasterPort returned %d\n", kernResult ); | |
764 | } | |
3b46e624 | 765 | |
5fafdf24 | 766 | classesToMatch = IOServiceMatching( kIOCDMediaClass ); |
19cb3738 FB |
767 | if ( classesToMatch == NULL ) { |
768 | printf( "IOServiceMatching returned a NULL dictionary.\n" ); | |
769 | } else { | |
770 | CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue ); | |
771 | } | |
772 | kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator ); | |
773 | if ( KERN_SUCCESS != kernResult ) | |
774 | { | |
775 | printf( "IOServiceGetMatchingServices returned %d\n", kernResult ); | |
776 | } | |
3b46e624 | 777 | |
19cb3738 FB |
778 | return kernResult; |
779 | } | |
780 | ||
781 | kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize ) | |
782 | { | |
783 | io_object_t nextMedia; | |
784 | kern_return_t kernResult = KERN_FAILURE; | |
785 | *bsdPath = '\0'; | |
786 | nextMedia = IOIteratorNext( mediaIterator ); | |
787 | if ( nextMedia ) | |
788 | { | |
789 | CFTypeRef bsdPathAsCFString; | |
790 | bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 ); | |
791 | if ( bsdPathAsCFString ) { | |
792 | size_t devPathLength; | |
793 | strcpy( bsdPath, _PATH_DEV ); | |
794 | strcat( bsdPath, "r" ); | |
795 | devPathLength = strlen( bsdPath ); | |
796 | if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) { | |
797 | kernResult = KERN_SUCCESS; | |
798 | } | |
799 | CFRelease( bsdPathAsCFString ); | |
800 | } | |
801 | IOObjectRelease( nextMedia ); | |
802 | } | |
3b46e624 | 803 | |
19cb3738 FB |
804 | return kernResult; |
805 | } | |
806 | ||
807 | #endif | |
808 | ||
508c7cb3 CH |
809 | static int hdev_probe_device(const char *filename) |
810 | { | |
811 | struct stat st; | |
812 | ||
813 | /* allow a dedicated CD-ROM driver to match with a higher priority */ | |
814 | if (strstart(filename, "/dev/cdrom", NULL)) | |
815 | return 50; | |
816 | ||
817 | if (stat(filename, &st) >= 0 && | |
818 | (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) { | |
819 | return 100; | |
820 | } | |
821 | ||
822 | return 0; | |
823 | } | |
824 | ||
19cb3738 FB |
825 | static int hdev_open(BlockDriverState *bs, const char *filename, int flags) |
826 | { | |
827 | BDRVRawState *s = bs->opaque; | |
a76bab49 | 828 | |
83affaa6 | 829 | #if defined(__APPLE__) && defined(__MACH__) |
19cb3738 FB |
830 | if (strstart(filename, "/dev/cdrom", NULL)) { |
831 | kern_return_t kernResult; | |
832 | io_iterator_t mediaIterator; | |
833 | char bsdPath[ MAXPATHLEN ]; | |
834 | int fd; | |
5fafdf24 | 835 | |
19cb3738 FB |
836 | kernResult = FindEjectableCDMedia( &mediaIterator ); |
837 | kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) ); | |
3b46e624 | 838 | |
19cb3738 FB |
839 | if ( bsdPath[ 0 ] != '\0' ) { |
840 | strcat(bsdPath,"s0"); | |
841 | /* some CDs don't have a partition 0 */ | |
842 | fd = open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE); | |
843 | if (fd < 0) { | |
844 | bsdPath[strlen(bsdPath)-1] = '1'; | |
845 | } else { | |
846 | close(fd); | |
847 | } | |
848 | filename = bsdPath; | |
849 | } | |
3b46e624 | 850 | |
19cb3738 FB |
851 | if ( mediaIterator ) |
852 | IOObjectRelease( mediaIterator ); | |
853 | } | |
854 | #endif | |
19cb3738 FB |
855 | |
856 | s->type = FTYPE_FILE; | |
4dd75c70 | 857 | #if defined(__linux__) |
05acda4d BK |
858 | { |
859 | char resolved_path[ MAXPATHLEN ], *temp; | |
860 | ||
861 | temp = realpath(filename, resolved_path); | |
862 | if (temp && strstart(temp, "/dev/sg", NULL)) { | |
863 | bs->sg = 1; | |
864 | } | |
19cb3738 FB |
865 | } |
866 | #endif | |
90babde0 | 867 | |
19a3da7f | 868 | return raw_open_common(bs, filename, flags, 0); |
19cb3738 FB |
869 | } |
870 | ||
03ff3ca3 | 871 | #if defined(__linux__) |
19cb3738 FB |
872 | /* Note: we do not have a reliable method to detect if the floppy is |
873 | present. The current method is to try to open the floppy at every | |
874 | I/O and to keep it opened during a few hundreds of ms. */ | |
875 | static int fd_open(BlockDriverState *bs) | |
876 | { | |
877 | BDRVRawState *s = bs->opaque; | |
878 | int last_media_present; | |
879 | ||
880 | if (s->type != FTYPE_FD) | |
881 | return 0; | |
882 | last_media_present = (s->fd >= 0); | |
5fafdf24 | 883 | if (s->fd >= 0 && |
c57c846a | 884 | (get_clock() - s->fd_open_time) >= FD_OPEN_TIMEOUT) { |
19cb3738 FB |
885 | close(s->fd); |
886 | s->fd = -1; | |
887 | #ifdef DEBUG_FLOPPY | |
888 | printf("Floppy closed\n"); | |
889 | #endif | |
890 | } | |
891 | if (s->fd < 0) { | |
5fafdf24 | 892 | if (s->fd_got_error && |
c57c846a | 893 | (get_clock() - s->fd_error_time) < FD_OPEN_TIMEOUT) { |
19cb3738 FB |
894 | #ifdef DEBUG_FLOPPY |
895 | printf("No floppy (open delayed)\n"); | |
896 | #endif | |
897 | return -EIO; | |
898 | } | |
0e1d8f4c | 899 | s->fd = open(bs->filename, s->open_flags & ~O_NONBLOCK); |
19cb3738 | 900 | if (s->fd < 0) { |
c57c846a | 901 | s->fd_error_time = get_clock(); |
19cb3738 FB |
902 | s->fd_got_error = 1; |
903 | if (last_media_present) | |
904 | s->fd_media_changed = 1; | |
905 | #ifdef DEBUG_FLOPPY | |
906 | printf("No floppy\n"); | |
907 | #endif | |
908 | return -EIO; | |
909 | } | |
910 | #ifdef DEBUG_FLOPPY | |
911 | printf("Floppy opened\n"); | |
912 | #endif | |
913 | } | |
914 | if (!last_media_present) | |
915 | s->fd_media_changed = 1; | |
c57c846a | 916 | s->fd_open_time = get_clock(); |
19cb3738 FB |
917 | s->fd_got_error = 0; |
918 | return 0; | |
919 | } | |
19cb3738 | 920 | |
63ec93db | 921 | static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) |
985a03b0 TS |
922 | { |
923 | BDRVRawState *s = bs->opaque; | |
924 | ||
925 | return ioctl(s->fd, req, buf); | |
926 | } | |
221f715d | 927 | |
63ec93db | 928 | static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs, |
221f715d AL |
929 | unsigned long int req, void *buf, |
930 | BlockDriverCompletionFunc *cb, void *opaque) | |
931 | { | |
f141eafe | 932 | BDRVRawState *s = bs->opaque; |
221f715d | 933 | |
f141eafe AL |
934 | if (fd_open(bs) < 0) |
935 | return NULL; | |
9ef91a67 | 936 | return paio_ioctl(bs, s->fd, req, buf, cb, opaque); |
221f715d AL |
937 | } |
938 | ||
a167ba50 | 939 | #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) |
9f23011a BS |
940 | static int fd_open(BlockDriverState *bs) |
941 | { | |
942 | BDRVRawState *s = bs->opaque; | |
943 | ||
944 | /* this is just to ensure s->fd is sane (its called by io ops) */ | |
945 | if (s->fd >= 0) | |
946 | return 0; | |
947 | return -EIO; | |
948 | } | |
9f23011a | 949 | #else /* !linux && !FreeBSD */ |
19cb3738 | 950 | |
08af02e2 AL |
951 | static int fd_open(BlockDriverState *bs) |
952 | { | |
953 | return 0; | |
954 | } | |
955 | ||
221f715d | 956 | #endif /* !linux && !FreeBSD */ |
04eeb8b6 | 957 | |
0e7e1989 | 958 | static int hdev_create(const char *filename, QEMUOptionParameter *options) |
93c65b47 AL |
959 | { |
960 | int fd; | |
961 | int ret = 0; | |
962 | struct stat stat_buf; | |
0e7e1989 | 963 | int64_t total_size = 0; |
93c65b47 | 964 | |
0e7e1989 KW |
965 | /* Read out options */ |
966 | while (options && options->name) { | |
967 | if (!strcmp(options->name, "size")) { | |
9040385d | 968 | total_size = options->value.n / BDRV_SECTOR_SIZE; |
0e7e1989 KW |
969 | } |
970 | options++; | |
971 | } | |
93c65b47 AL |
972 | |
973 | fd = open(filename, O_WRONLY | O_BINARY); | |
974 | if (fd < 0) | |
57e69b7d | 975 | return -errno; |
93c65b47 AL |
976 | |
977 | if (fstat(fd, &stat_buf) < 0) | |
57e69b7d | 978 | ret = -errno; |
4099df58 | 979 | else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) |
57e69b7d | 980 | ret = -ENODEV; |
9040385d | 981 | else if (lseek(fd, 0, SEEK_END) < total_size * BDRV_SECTOR_SIZE) |
93c65b47 AL |
982 | ret = -ENOSPC; |
983 | ||
984 | close(fd); | |
985 | return ret; | |
986 | } | |
987 | ||
336c1c12 KW |
988 | static int hdev_has_zero_init(BlockDriverState *bs) |
989 | { | |
990 | return 0; | |
991 | } | |
992 | ||
5efa9d5a | 993 | static BlockDriver bdrv_host_device = { |
0b4ce02e | 994 | .format_name = "host_device", |
84a12e66 | 995 | .protocol_name = "host_device", |
0b4ce02e KW |
996 | .instance_size = sizeof(BDRVRawState), |
997 | .bdrv_probe_device = hdev_probe_device, | |
66f82cee | 998 | .bdrv_file_open = hdev_open, |
0b4ce02e | 999 | .bdrv_close = raw_close, |
93c65b47 | 1000 | .bdrv_create = hdev_create, |
0b4ce02e | 1001 | .create_options = raw_create_options, |
336c1c12 | 1002 | .bdrv_has_zero_init = hdev_has_zero_init, |
3b46e624 | 1003 | |
f141eafe AL |
1004 | .bdrv_aio_readv = raw_aio_readv, |
1005 | .bdrv_aio_writev = raw_aio_writev, | |
b2e12bc6 | 1006 | .bdrv_aio_flush = raw_aio_flush, |
3c529d93 | 1007 | |
55b949c8 | 1008 | .bdrv_truncate = raw_truncate, |
e60f469c | 1009 | .bdrv_getlength = raw_getlength, |
4a1d5e1f FZ |
1010 | .bdrv_get_allocated_file_size |
1011 | = raw_get_allocated_file_size, | |
19cb3738 | 1012 | |
f3a5d3f8 | 1013 | /* generic scsi device */ |
63ec93db CH |
1014 | #ifdef __linux__ |
1015 | .bdrv_ioctl = hdev_ioctl, | |
63ec93db CH |
1016 | .bdrv_aio_ioctl = hdev_aio_ioctl, |
1017 | #endif | |
f3a5d3f8 CH |
1018 | }; |
1019 | ||
1020 | #ifdef __linux__ | |
1021 | static int floppy_open(BlockDriverState *bs, const char *filename, int flags) | |
1022 | { | |
1023 | BDRVRawState *s = bs->opaque; | |
1024 | int ret; | |
1025 | ||
f3a5d3f8 | 1026 | s->type = FTYPE_FD; |
f3a5d3f8 | 1027 | |
19a3da7f BS |
1028 | /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */ |
1029 | ret = raw_open_common(bs, filename, flags, O_NONBLOCK); | |
f3a5d3f8 CH |
1030 | if (ret) |
1031 | return ret; | |
1032 | ||
1033 | /* close fd so that we can reopen it as needed */ | |
1034 | close(s->fd); | |
1035 | s->fd = -1; | |
1036 | s->fd_media_changed = 1; | |
1037 | ||
1038 | return 0; | |
1039 | } | |
1040 | ||
508c7cb3 CH |
1041 | static int floppy_probe_device(const char *filename) |
1042 | { | |
2ebf7c4b CR |
1043 | int fd, ret; |
1044 | int prio = 0; | |
1045 | struct floppy_struct fdparam; | |
343f8568 | 1046 | struct stat st; |
2ebf7c4b | 1047 | |
508c7cb3 | 1048 | if (strstart(filename, "/dev/fd", NULL)) |
2ebf7c4b CR |
1049 | prio = 50; |
1050 | ||
1051 | fd = open(filename, O_RDONLY | O_NONBLOCK); | |
1052 | if (fd < 0) { | |
1053 | goto out; | |
1054 | } | |
343f8568 JS |
1055 | ret = fstat(fd, &st); |
1056 | if (ret == -1 || !S_ISBLK(st.st_mode)) { | |
1057 | goto outc; | |
1058 | } | |
2ebf7c4b CR |
1059 | |
1060 | /* Attempt to detect via a floppy specific ioctl */ | |
1061 | ret = ioctl(fd, FDGETPRM, &fdparam); | |
1062 | if (ret >= 0) | |
1063 | prio = 100; | |
1064 | ||
343f8568 | 1065 | outc: |
2ebf7c4b CR |
1066 | close(fd); |
1067 | out: | |
1068 | return prio; | |
508c7cb3 CH |
1069 | } |
1070 | ||
1071 | ||
f3a5d3f8 CH |
1072 | static int floppy_is_inserted(BlockDriverState *bs) |
1073 | { | |
1074 | return fd_open(bs) >= 0; | |
1075 | } | |
1076 | ||
1077 | static int floppy_media_changed(BlockDriverState *bs) | |
1078 | { | |
1079 | BDRVRawState *s = bs->opaque; | |
1080 | int ret; | |
1081 | ||
1082 | /* | |
1083 | * XXX: we do not have a true media changed indication. | |
1084 | * It does not work if the floppy is changed without trying to read it. | |
1085 | */ | |
1086 | fd_open(bs); | |
1087 | ret = s->fd_media_changed; | |
1088 | s->fd_media_changed = 0; | |
1089 | #ifdef DEBUG_FLOPPY | |
1090 | printf("Floppy changed=%d\n", ret); | |
1091 | #endif | |
1092 | return ret; | |
1093 | } | |
1094 | ||
f36f3949 | 1095 | static void floppy_eject(BlockDriverState *bs, bool eject_flag) |
f3a5d3f8 CH |
1096 | { |
1097 | BDRVRawState *s = bs->opaque; | |
1098 | int fd; | |
1099 | ||
1100 | if (s->fd >= 0) { | |
1101 | close(s->fd); | |
1102 | s->fd = -1; | |
1103 | } | |
1104 | fd = open(bs->filename, s->open_flags | O_NONBLOCK); | |
1105 | if (fd >= 0) { | |
1106 | if (ioctl(fd, FDEJECT, 0) < 0) | |
1107 | perror("FDEJECT"); | |
1108 | close(fd); | |
1109 | } | |
f3a5d3f8 CH |
1110 | } |
1111 | ||
1112 | static BlockDriver bdrv_host_floppy = { | |
1113 | .format_name = "host_floppy", | |
84a12e66 | 1114 | .protocol_name = "host_floppy", |
f3a5d3f8 | 1115 | .instance_size = sizeof(BDRVRawState), |
508c7cb3 | 1116 | .bdrv_probe_device = floppy_probe_device, |
66f82cee | 1117 | .bdrv_file_open = floppy_open, |
f3a5d3f8 CH |
1118 | .bdrv_close = raw_close, |
1119 | .bdrv_create = hdev_create, | |
0b4ce02e | 1120 | .create_options = raw_create_options, |
336c1c12 | 1121 | .bdrv_has_zero_init = hdev_has_zero_init, |
f3a5d3f8 | 1122 | |
f3a5d3f8 CH |
1123 | .bdrv_aio_readv = raw_aio_readv, |
1124 | .bdrv_aio_writev = raw_aio_writev, | |
b2e12bc6 | 1125 | .bdrv_aio_flush = raw_aio_flush, |
f3a5d3f8 | 1126 | |
55b949c8 | 1127 | .bdrv_truncate = raw_truncate, |
f3a5d3f8 | 1128 | .bdrv_getlength = raw_getlength, |
4a1d5e1f FZ |
1129 | .bdrv_get_allocated_file_size |
1130 | = raw_get_allocated_file_size, | |
f3a5d3f8 CH |
1131 | |
1132 | /* removable device support */ | |
1133 | .bdrv_is_inserted = floppy_is_inserted, | |
1134 | .bdrv_media_changed = floppy_media_changed, | |
1135 | .bdrv_eject = floppy_eject, | |
f3a5d3f8 CH |
1136 | }; |
1137 | ||
1138 | static int cdrom_open(BlockDriverState *bs, const char *filename, int flags) | |
1139 | { | |
1140 | BDRVRawState *s = bs->opaque; | |
1141 | ||
f3a5d3f8 CH |
1142 | s->type = FTYPE_CD; |
1143 | ||
19a3da7f BS |
1144 | /* open will not fail even if no CD is inserted, so add O_NONBLOCK */ |
1145 | return raw_open_common(bs, filename, flags, O_NONBLOCK); | |
f3a5d3f8 CH |
1146 | } |
1147 | ||
508c7cb3 CH |
1148 | static int cdrom_probe_device(const char *filename) |
1149 | { | |
3baf720e CR |
1150 | int fd, ret; |
1151 | int prio = 0; | |
343f8568 | 1152 | struct stat st; |
3baf720e | 1153 | |
3baf720e CR |
1154 | fd = open(filename, O_RDONLY | O_NONBLOCK); |
1155 | if (fd < 0) { | |
1156 | goto out; | |
1157 | } | |
343f8568 JS |
1158 | ret = fstat(fd, &st); |
1159 | if (ret == -1 || !S_ISBLK(st.st_mode)) { | |
1160 | goto outc; | |
1161 | } | |
3baf720e CR |
1162 | |
1163 | /* Attempt to detect via a CDROM specific ioctl */ | |
1164 | ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT); | |
1165 | if (ret >= 0) | |
1166 | prio = 100; | |
1167 | ||
343f8568 | 1168 | outc: |
3baf720e CR |
1169 | close(fd); |
1170 | out: | |
1171 | return prio; | |
508c7cb3 CH |
1172 | } |
1173 | ||
f3a5d3f8 CH |
1174 | static int cdrom_is_inserted(BlockDriverState *bs) |
1175 | { | |
1176 | BDRVRawState *s = bs->opaque; | |
1177 | int ret; | |
1178 | ||
1179 | ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT); | |
1180 | if (ret == CDS_DISC_OK) | |
1181 | return 1; | |
1182 | return 0; | |
1183 | } | |
1184 | ||
f36f3949 | 1185 | static void cdrom_eject(BlockDriverState *bs, bool eject_flag) |
f3a5d3f8 CH |
1186 | { |
1187 | BDRVRawState *s = bs->opaque; | |
1188 | ||
1189 | if (eject_flag) { | |
1190 | if (ioctl(s->fd, CDROMEJECT, NULL) < 0) | |
1191 | perror("CDROMEJECT"); | |
1192 | } else { | |
1193 | if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0) | |
1194 | perror("CDROMEJECT"); | |
1195 | } | |
f3a5d3f8 CH |
1196 | } |
1197 | ||
025e849a | 1198 | static void cdrom_lock_medium(BlockDriverState *bs, bool locked) |
f3a5d3f8 CH |
1199 | { |
1200 | BDRVRawState *s = bs->opaque; | |
1201 | ||
1202 | if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) { | |
1203 | /* | |
1204 | * Note: an error can happen if the distribution automatically | |
1205 | * mounts the CD-ROM | |
1206 | */ | |
1207 | /* perror("CDROM_LOCKDOOR"); */ | |
1208 | } | |
f3a5d3f8 CH |
1209 | } |
1210 | ||
1211 | static BlockDriver bdrv_host_cdrom = { | |
1212 | .format_name = "host_cdrom", | |
84a12e66 | 1213 | .protocol_name = "host_cdrom", |
f3a5d3f8 | 1214 | .instance_size = sizeof(BDRVRawState), |
508c7cb3 | 1215 | .bdrv_probe_device = cdrom_probe_device, |
66f82cee | 1216 | .bdrv_file_open = cdrom_open, |
f3a5d3f8 CH |
1217 | .bdrv_close = raw_close, |
1218 | .bdrv_create = hdev_create, | |
0b4ce02e | 1219 | .create_options = raw_create_options, |
336c1c12 | 1220 | .bdrv_has_zero_init = hdev_has_zero_init, |
f3a5d3f8 | 1221 | |
f3a5d3f8 CH |
1222 | .bdrv_aio_readv = raw_aio_readv, |
1223 | .bdrv_aio_writev = raw_aio_writev, | |
b2e12bc6 | 1224 | .bdrv_aio_flush = raw_aio_flush, |
f3a5d3f8 | 1225 | |
55b949c8 | 1226 | .bdrv_truncate = raw_truncate, |
f3a5d3f8 | 1227 | .bdrv_getlength = raw_getlength, |
4a1d5e1f FZ |
1228 | .bdrv_get_allocated_file_size |
1229 | = raw_get_allocated_file_size, | |
f3a5d3f8 CH |
1230 | |
1231 | /* removable device support */ | |
1232 | .bdrv_is_inserted = cdrom_is_inserted, | |
1233 | .bdrv_eject = cdrom_eject, | |
025e849a | 1234 | .bdrv_lock_medium = cdrom_lock_medium, |
f3a5d3f8 CH |
1235 | |
1236 | /* generic scsi device */ | |
63ec93db | 1237 | .bdrv_ioctl = hdev_ioctl, |
63ec93db | 1238 | .bdrv_aio_ioctl = hdev_aio_ioctl, |
f3a5d3f8 CH |
1239 | }; |
1240 | #endif /* __linux__ */ | |
1241 | ||
a167ba50 | 1242 | #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) |
f3a5d3f8 CH |
1243 | static int cdrom_open(BlockDriverState *bs, const char *filename, int flags) |
1244 | { | |
1245 | BDRVRawState *s = bs->opaque; | |
1246 | int ret; | |
1247 | ||
1248 | s->type = FTYPE_CD; | |
1249 | ||
19a3da7f | 1250 | ret = raw_open_common(bs, filename, flags, 0); |
f3a5d3f8 CH |
1251 | if (ret) |
1252 | return ret; | |
1253 | ||
9b2260cb | 1254 | /* make sure the door isn't locked at this time */ |
f3a5d3f8 CH |
1255 | ioctl(s->fd, CDIOCALLOW); |
1256 | return 0; | |
1257 | } | |
1258 | ||
508c7cb3 CH |
1259 | static int cdrom_probe_device(const char *filename) |
1260 | { | |
1261 | if (strstart(filename, "/dev/cd", NULL) || | |
1262 | strstart(filename, "/dev/acd", NULL)) | |
1263 | return 100; | |
1264 | return 0; | |
1265 | } | |
1266 | ||
f3a5d3f8 CH |
1267 | static int cdrom_reopen(BlockDriverState *bs) |
1268 | { | |
1269 | BDRVRawState *s = bs->opaque; | |
1270 | int fd; | |
1271 | ||
1272 | /* | |
1273 | * Force reread of possibly changed/newly loaded disc, | |
1274 | * FreeBSD seems to not notice sometimes... | |
1275 | */ | |
1276 | if (s->fd >= 0) | |
1277 | close(s->fd); | |
1278 | fd = open(bs->filename, s->open_flags, 0644); | |
1279 | if (fd < 0) { | |
1280 | s->fd = -1; | |
1281 | return -EIO; | |
1282 | } | |
1283 | s->fd = fd; | |
1284 | ||
9b2260cb | 1285 | /* make sure the door isn't locked at this time */ |
f3a5d3f8 CH |
1286 | ioctl(s->fd, CDIOCALLOW); |
1287 | return 0; | |
1288 | } | |
1289 | ||
1290 | static int cdrom_is_inserted(BlockDriverState *bs) | |
1291 | { | |
1292 | return raw_getlength(bs) > 0; | |
1293 | } | |
1294 | ||
f36f3949 | 1295 | static void cdrom_eject(BlockDriverState *bs, bool eject_flag) |
f3a5d3f8 CH |
1296 | { |
1297 | BDRVRawState *s = bs->opaque; | |
1298 | ||
1299 | if (s->fd < 0) | |
822e1cd1 | 1300 | return; |
f3a5d3f8 CH |
1301 | |
1302 | (void) ioctl(s->fd, CDIOCALLOW); | |
1303 | ||
1304 | if (eject_flag) { | |
1305 | if (ioctl(s->fd, CDIOCEJECT) < 0) | |
1306 | perror("CDIOCEJECT"); | |
1307 | } else { | |
1308 | if (ioctl(s->fd, CDIOCCLOSE) < 0) | |
1309 | perror("CDIOCCLOSE"); | |
1310 | } | |
1311 | ||
822e1cd1 | 1312 | cdrom_reopen(bs); |
f3a5d3f8 CH |
1313 | } |
1314 | ||
025e849a | 1315 | static void cdrom_lock_medium(BlockDriverState *bs, bool locked) |
f3a5d3f8 CH |
1316 | { |
1317 | BDRVRawState *s = bs->opaque; | |
1318 | ||
1319 | if (s->fd < 0) | |
7bf37fed | 1320 | return; |
f3a5d3f8 CH |
1321 | if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) { |
1322 | /* | |
1323 | * Note: an error can happen if the distribution automatically | |
1324 | * mounts the CD-ROM | |
1325 | */ | |
1326 | /* perror("CDROM_LOCKDOOR"); */ | |
1327 | } | |
f3a5d3f8 CH |
1328 | } |
1329 | ||
1330 | static BlockDriver bdrv_host_cdrom = { | |
1331 | .format_name = "host_cdrom", | |
84a12e66 | 1332 | .protocol_name = "host_cdrom", |
f3a5d3f8 | 1333 | .instance_size = sizeof(BDRVRawState), |
508c7cb3 | 1334 | .bdrv_probe_device = cdrom_probe_device, |
66f82cee | 1335 | .bdrv_file_open = cdrom_open, |
f3a5d3f8 CH |
1336 | .bdrv_close = raw_close, |
1337 | .bdrv_create = hdev_create, | |
0b4ce02e | 1338 | .create_options = raw_create_options, |
336c1c12 | 1339 | .bdrv_has_zero_init = hdev_has_zero_init, |
f3a5d3f8 | 1340 | |
f3a5d3f8 CH |
1341 | .bdrv_aio_readv = raw_aio_readv, |
1342 | .bdrv_aio_writev = raw_aio_writev, | |
b2e12bc6 | 1343 | .bdrv_aio_flush = raw_aio_flush, |
f3a5d3f8 | 1344 | |
55b949c8 | 1345 | .bdrv_truncate = raw_truncate, |
f3a5d3f8 | 1346 | .bdrv_getlength = raw_getlength, |
4a1d5e1f FZ |
1347 | .bdrv_get_allocated_file_size |
1348 | = raw_get_allocated_file_size, | |
f3a5d3f8 | 1349 | |
19cb3738 | 1350 | /* removable device support */ |
f3a5d3f8 CH |
1351 | .bdrv_is_inserted = cdrom_is_inserted, |
1352 | .bdrv_eject = cdrom_eject, | |
025e849a | 1353 | .bdrv_lock_medium = cdrom_lock_medium, |
19cb3738 | 1354 | }; |
f3a5d3f8 | 1355 | #endif /* __FreeBSD__ */ |
5efa9d5a | 1356 | |
84a12e66 | 1357 | static void bdrv_file_init(void) |
5efa9d5a | 1358 | { |
508c7cb3 CH |
1359 | /* |
1360 | * Register all the drivers. Note that order is important, the driver | |
1361 | * registered last will get probed first. | |
1362 | */ | |
84a12e66 | 1363 | bdrv_register(&bdrv_file); |
5efa9d5a | 1364 | bdrv_register(&bdrv_host_device); |
f3a5d3f8 CH |
1365 | #ifdef __linux__ |
1366 | bdrv_register(&bdrv_host_floppy); | |
1367 | bdrv_register(&bdrv_host_cdrom); | |
1368 | #endif | |
a167ba50 | 1369 | #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) |
f3a5d3f8 CH |
1370 | bdrv_register(&bdrv_host_cdrom); |
1371 | #endif | |
5efa9d5a AL |
1372 | } |
1373 | ||
84a12e66 | 1374 | block_init(bdrv_file_init); |