blob: 3ab8f5a0fa7720e2ae166cda25a8c423d7abcea8 [file] [log] [blame]
bellard83f64092006-08-01 16:21:11 +00001/*
ths223d4672007-12-15 17:28:36 +00002 * Block driver for RAW files (posix)
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard83f64092006-08-01 16:21:11 +00004 * Copyright (c) 2006 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellard83f64092006-08-01 16:21:11 +00006 * 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 */
Markus Armbruster922a01a2018-02-01 12:18:46 +010024
Peter Maydell80c71a22016-01-18 18:01:42 +000025#include "qemu/osdep.h"
Markus Armbrustera8d25322019-05-23 16:35:08 +020026#include "qemu-common.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010027#include "qapi/error.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020028#include "qemu/cutils.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010029#include "qemu/error-report.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010030#include "block/block_int.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010031#include "qemu/module.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010032#include "qemu/option.h"
Paolo Bonzinide81a162012-05-25 11:46:27 +020033#include "trace.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010034#include "block/thread-pool.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010035#include "qemu/iov.h"
Paolo Bonzini0187f5c2016-07-04 18:33:20 +020036#include "block/raw-aio.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010037#include "qapi/qmp/qdict.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010038#include "qapi/qmp/qstring.h"
bellard83f64092006-08-01 16:21:11 +000039
Paolo Bonzini7c9e5272017-08-21 18:58:56 +020040#include "scsi/pr-manager.h"
41#include "scsi/constants.h"
42
Pavel Borzenkov83affaa2011-11-10 22:40:06 +040043#if defined(__APPLE__) && (__MACH__)
bellard83f64092006-08-01 16:21:11 +000044#include <paths.h>
45#include <sys/param.h>
46#include <IOKit/IOKitLib.h>
47#include <IOKit/IOBSD.h>
48#include <IOKit/storage/IOMediaBSDClient.h>
49#include <IOKit/storage/IOMedia.h>
50#include <IOKit/storage/IOCDMedia.h>
51//#include <IOKit/storage/IOCDTypes.h>
Programmingkidd0855f12016-03-21 11:41:28 -040052#include <IOKit/storage/IODVDMedia.h>
bellard83f64092006-08-01 16:21:11 +000053#include <CoreFoundation/CoreFoundation.h>
54#endif
55
56#ifdef __sun__
ths2e9671d2007-01-05 17:44:41 +000057#define _POSIX_PTHREAD_SEMANTICS 1
bellard83f64092006-08-01 16:21:11 +000058#include <sys/dkio.h>
59#endif
bellard19cb3732006-08-19 11:45:59 +000060#ifdef __linux__
61#include <sys/ioctl.h>
Bernhard Kohl05acda42010-09-06 17:06:02 +020062#include <sys/param.h>
Fam Zheng1efad062018-06-01 17:26:43 +080063#include <sys/syscall.h>
bellard19cb3732006-08-19 11:45:59 +000064#include <linux/cdrom.h>
65#include <linux/fd.h>
Paolo Bonzini55003162012-05-09 16:49:58 +020066#include <linux/fs.h>
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +010067#include <linux/hdreg.h>
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +030068#include <scsi/sg.h>
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +010069#ifdef __s390__
70#include <asm/dasd.h>
71#endif
Chunyan Liu4ab15592014-06-30 14:29:58 +080072#ifndef FS_NOCOW_FL
73#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
74#endif
Paolo Bonzini55003162012-05-09 16:49:58 +020075#endif
Denis V. Lunevb953f072015-01-30 11:42:14 +030076#if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
Kusanagi Kouichi3d4fa432013-01-14 16:26:52 +010077#include <linux/falloc.h>
78#endif
Aurelien Jarnoa167ba52009-11-29 18:00:41 +010079#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
ths1cb6c3f2006-12-21 19:14:11 +000080#include <sys/disk.h>
blueswir19f230112009-03-28 08:37:13 +000081#include <sys/cdio.h>
ths1cb6c3f2006-12-21 19:14:11 +000082#endif
bellard19cb3732006-08-19 11:45:59 +000083
blueswir1128ab2f2008-08-15 18:33:42 +000084#ifdef __OpenBSD__
85#include <sys/ioctl.h>
86#include <sys/disklabel.h>
87#include <sys/dkio.h>
88#endif
89
Christoph Eggerd1f6fd82011-05-23 14:31:17 +020090#ifdef __NetBSD__
91#include <sys/ioctl.h>
92#include <sys/disklabel.h>
93#include <sys/dkio.h>
94#include <sys/disk.h>
95#endif
96
blueswir1c5e97232009-03-07 20:06:23 +000097#ifdef __DragonFly__
98#include <sys/ioctl.h>
99#include <sys/diskslice.h>
100#endif
101
Christoph Hellwigdce512d2010-12-17 11:41:15 +0100102#ifdef CONFIG_XFS
103#include <xfs/xfs.h>
104#endif
105
Laurent Vivier4f7d28d2018-12-13 17:27:26 +0100106#include "trace.h"
ths8c05dbf2007-09-13 12:29:23 +0000107
aliguorif6465572008-10-14 18:00:38 +0000108/* OS X does not have O_DSYNC */
109#ifndef O_DSYNC
G 31c27a8b2009-07-01 13:28:32 -0400110#ifdef O_SYNC
aliguori7ab064d2008-10-14 18:14:47 +0000111#define O_DSYNC O_SYNC
G 31c27a8b2009-07-01 13:28:32 -0400112#elif defined(O_FSYNC)
113#define O_DSYNC O_FSYNC
114#endif
aliguorif6465572008-10-14 18:00:38 +0000115#endif
116
aliguori9f7965c2008-10-14 14:42:54 +0000117/* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
118#ifndef O_DIRECT
119#define O_DIRECT O_DSYNC
120#endif
121
bellard19cb3732006-08-19 11:45:59 +0000122#define FTYPE_FILE 0
123#define FTYPE_CD 1
bellard83f64092006-08-01 16:21:11 +0000124
Christoph Hellwig581b9e22010-09-12 23:43:21 +0200125#define MAX_BLOCKSIZE 4096
126
Fam Zheng244a5662017-05-03 00:35:56 +0800127/* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
128 * leaving a few more bytes for its future use. */
129#define RAW_LOCK_PERM_BASE 100
130#define RAW_LOCK_SHARED_BASE 200
131
bellard83f64092006-08-01 16:21:11 +0000132typedef struct BDRVRawState {
133 int fd;
Fam Zheng244a5662017-05-03 00:35:56 +0800134 bool use_lock;
bellard19cb3732006-08-19 11:45:59 +0000135 int type;
Christoph Hellwig0e1d8f42009-06-15 13:53:26 +0200136 int open_flags;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100137 size_t buf_align;
138
Fam Zheng244a5662017-05-03 00:35:56 +0800139 /* The current permissions. */
140 uint64_t perm;
141 uint64_t shared_perm;
142
Fam Zheng2996ffa2018-10-11 15:21:33 +0800143 /* The perms bits whose corresponding bytes are already locked in
Fam Zhengf2e3af22018-10-11 15:21:34 +0800144 * s->fd. */
Fam Zheng2996ffa2018-10-11 15:21:33 +0800145 uint64_t locked_perm;
146 uint64_t locked_shared_perm;
147
Kevin Wolf6ceabe62019-03-08 15:40:40 +0100148 int perm_change_fd;
Max Reitz094e3632019-05-22 19:03:45 +0200149 int perm_change_flags;
Kevin Wolfe0c9cf32019-03-07 19:07:35 +0100150 BDRVReopenState *reopen_state;
151
Christoph Hellwigdce512d2010-12-17 11:41:15 +0100152#ifdef CONFIG_XFS
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100153 bool is_xfs:1;
Christoph Hellwigdce512d2010-12-17 11:41:15 +0100154#endif
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100155 bool has_discard:1;
Paolo Bonzini97a2ae32013-11-22 13:39:57 +0100156 bool has_write_zeroes:1;
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100157 bool discard_zeroes:1;
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200158 bool use_linux_aio:1;
Aarushi Mehtac6447512020-01-20 14:18:51 +0000159 bool use_linux_io_uring:1;
Kevin Wolfe5bcf962017-03-22 22:00:05 +0100160 bool page_cache_inconsistent:1;
Denis V. Lunevd50d8222015-01-30 11:42:15 +0300161 bool has_fallocate;
Roger Pau Monne3cad8302014-10-21 16:03:03 +0200162 bool needs_alignment;
Stefan Hajnoczif357fcd2019-03-07 16:49:41 +0000163 bool drop_cache;
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +0100164 bool check_cache_dropped;
Anton Nefedov1c450362019-09-23 15:17:36 +0300165 struct {
166 uint64_t discard_nb_ok;
167 uint64_t discard_nb_failed;
168 uint64_t discard_bytes_ok;
169 } stats;
Paolo Bonzini7c9e5272017-08-21 18:58:56 +0200170
171 PRManager *pr_mgr;
bellard83f64092006-08-01 16:21:11 +0000172} BDRVRawState;
173
Jeff Codyeeb6b452012-09-20 15:13:25 -0400174typedef struct BDRVRawReopenState {
175 int fd;
176 int open_flags;
Stefan Hajnoczif357fcd2019-03-07 16:49:41 +0000177 bool drop_cache;
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +0100178 bool check_cache_dropped;
Jeff Codyeeb6b452012-09-20 15:13:25 -0400179} BDRVRawReopenState;
180
bellard19cb3732006-08-19 11:45:59 +0000181static int fd_open(BlockDriverState *bs);
Kevin Wolf22afa7b2009-06-26 19:51:24 +0200182static int64_t raw_getlength(BlockDriverState *bs);
bellard83f64092006-08-01 16:21:11 +0000183
Paolo Bonzinide81a162012-05-25 11:46:27 +0200184typedef struct RawPosixAIOData {
185 BlockDriverState *bs;
Paolo Bonzinide81a162012-05-25 11:46:27 +0200186 int aio_type;
Kevin Wolfd57c44d2018-10-25 16:21:14 +0100187 int aio_fildes;
188
189 off_t aio_offset;
190 uint64_t aio_nbytes;
191
Kevin Wolf93f4e2f2018-06-21 18:23:16 +0200192 union {
193 struct {
Kevin Wolfd57c44d2018-10-25 16:21:14 +0100194 struct iovec *iov;
195 int niov;
196 } io;
197 struct {
198 uint64_t cmd;
199 void *buf;
200 } ioctl;
201 struct {
Kevin Wolf93f4e2f2018-06-21 18:23:16 +0200202 int aio_fd2;
203 off_t aio_offset2;
Kevin Wolfd57c44d2018-10-25 16:21:14 +0100204 } copy_range;
Kevin Wolf93f4e2f2018-06-21 18:23:16 +0200205 struct {
206 PreallocMode prealloc;
207 Error **errp;
Kevin Wolfd57c44d2018-10-25 16:21:14 +0100208 } truncate;
Kevin Wolf93f4e2f2018-06-21 18:23:16 +0200209 };
Paolo Bonzinide81a162012-05-25 11:46:27 +0200210} RawPosixAIOData;
211
Aurelien Jarnoa167ba52009-11-29 18:00:41 +0100212#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200213static int cdrom_reopen(BlockDriverState *bs);
blueswir19f230112009-03-28 08:37:13 +0000214#endif
215
Christoph Egger1de1ae02011-05-24 11:30:29 +0200216#if defined(__NetBSD__)
Fam Zhengdb0754d2018-11-01 14:29:09 +0800217static int raw_normalize_devicepath(const char **filename, Error **errp)
Christoph Egger1de1ae02011-05-24 11:30:29 +0200218{
219 static char namebuf[PATH_MAX];
220 const char *dp, *fname;
221 struct stat sb;
222
223 fname = *filename;
224 dp = strrchr(fname, '/');
225 if (lstat(fname, &sb) < 0) {
Paolo Bonzinif6fc1e32019-07-25 11:59:20 +0200226 error_setg_file_open(errp, errno, fname);
Christoph Egger1de1ae02011-05-24 11:30:29 +0200227 return -errno;
228 }
229
230 if (!S_ISBLK(sb.st_mode)) {
231 return 0;
232 }
233
234 if (dp == NULL) {
235 snprintf(namebuf, PATH_MAX, "r%s", fname);
236 } else {
237 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
238 (int)(dp - fname), fname, dp + 1);
239 }
Christoph Egger1de1ae02011-05-24 11:30:29 +0200240 *filename = namebuf;
Fam Zhengdb0754d2018-11-01 14:29:09 +0800241 warn_report("%s is a block device, using %s", fname, *filename);
Christoph Egger1de1ae02011-05-24 11:30:29 +0200242
243 return 0;
244}
245#else
Fam Zhengdb0754d2018-11-01 14:29:09 +0800246static int raw_normalize_devicepath(const char **filename, Error **errp)
Christoph Egger1de1ae02011-05-24 11:30:29 +0200247{
248 return 0;
249}
250#endif
251
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100252/*
253 * Get logical block size via ioctl. On success store it in @sector_size_p.
254 */
255static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
256{
257 unsigned int sector_size;
258 bool success = false;
Peter Maydell700f9ce2017-03-23 14:36:28 +0000259 int i;
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100260
261 errno = ENOTSUP;
Peter Maydell700f9ce2017-03-23 14:36:28 +0000262 static const unsigned long ioctl_list[] = {
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100263#ifdef BLKSSZGET
Peter Maydell700f9ce2017-03-23 14:36:28 +0000264 BLKSSZGET,
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100265#endif
266#ifdef DKIOCGETBLOCKSIZE
Peter Maydell700f9ce2017-03-23 14:36:28 +0000267 DKIOCGETBLOCKSIZE,
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100268#endif
269#ifdef DIOCGSECTORSIZE
Peter Maydell700f9ce2017-03-23 14:36:28 +0000270 DIOCGSECTORSIZE,
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100271#endif
Peter Maydell700f9ce2017-03-23 14:36:28 +0000272 };
273
274 /* Try a few ioctls to get the right size */
275 for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
276 if (ioctl(fd, ioctl_list[i], &sector_size) >= 0) {
277 *sector_size_p = sector_size;
278 success = true;
279 }
280 }
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100281
282 return success ? 0 : -errno;
283}
284
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +0100285/**
286 * Get physical block size of @fd.
287 * On success, store it in @blk_size and return 0.
288 * On failure, return -errno.
289 */
290static int probe_physical_blocksize(int fd, unsigned int *blk_size)
291{
292#ifdef BLKPBSZGET
293 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
294 return -errno;
295 }
296 return 0;
297#else
298 return -ENOTSUP;
299#endif
300}
301
Stefan Hajnoczi22d182e2015-03-05 15:38:17 -0600302/* Check if read is allowed with given memory buffer and length.
303 *
304 * This function is used to check O_DIRECT memory buffer and request alignment.
305 */
306static bool raw_is_io_aligned(int fd, void *buf, size_t len)
307{
308 ssize_t ret = pread(fd, buf, len, 0);
309
310 if (ret >= 0) {
311 return true;
312 }
313
314#ifdef __linux__
315 /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads. Ignore
316 * other errors (e.g. real I/O error), which could happen on a failed
317 * drive, since we only care about probing alignment.
318 */
319 if (errno != EINVAL) {
320 return true;
321 }
322#endif
323
324 return false;
325}
326
Kevin Wolfdf26a352014-07-16 17:48:17 +0200327static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100328{
329 BDRVRawState *s = bs->opaque;
330 char *buf;
Wei Yang038adc22019-10-13 10:11:45 +0800331 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size);
Nir Soffera6b257a2019-08-13 21:21:03 +0300332 size_t alignments[] = {1, 512, 1024, 2048, 4096};
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100333
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300334 /* For SCSI generic devices the alignment is not really used.
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100335 With buffered I/O, we don't have any restrictions. */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300336 if (bdrv_is_sg(bs) || !s->needs_alignment) {
Eric Blakea5b8dd22016-06-23 16:37:24 -0600337 bs->bl.request_alignment = 1;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100338 s->buf_align = 1;
339 return;
340 }
341
Eric Blakea5b8dd22016-06-23 16:37:24 -0600342 bs->bl.request_alignment = 0;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100343 s->buf_align = 0;
Ekaterina Tumanova8a4ed0d2015-02-16 12:47:55 +0100344 /* Let's try to use the logical blocksize for the alignment. */
Eric Blakea5b8dd22016-06-23 16:37:24 -0600345 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
346 bs->bl.request_alignment = 0;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100347 }
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100348#ifdef CONFIG_XFS
349 if (s->is_xfs) {
350 struct dioattr da;
Kevin Wolfdf26a352014-07-16 17:48:17 +0200351 if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
Eric Blakea5b8dd22016-06-23 16:37:24 -0600352 bs->bl.request_alignment = da.d_miniosz;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100353 /* The kernel returns wrong information for d_mem */
354 /* s->buf_align = da.d_mem; */
355 }
356 }
357#endif
358
Nir Soffera6b257a2019-08-13 21:21:03 +0300359 /*
360 * If we could not get the sizes so far, we can only guess them. First try
361 * to detect request alignment, since it is more likely to succeed. Then
362 * try to detect buf_align, which cannot be detected in some cases (e.g.
363 * Gluster). If buf_align cannot be detected, we fallback to the value of
364 * request_alignment.
365 */
366
367 if (!bs->bl.request_alignment) {
368 int i;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100369 size_t align;
Nir Soffera6b257a2019-08-13 21:21:03 +0300370 buf = qemu_memalign(max_align, max_align);
371 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
372 align = alignments[i];
373 if (raw_is_io_aligned(fd, buf, align)) {
374 /* Fallback to safe value. */
375 bs->bl.request_alignment = (align != 1) ? align : max_align;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100376 break;
377 }
378 }
379 qemu_vfree(buf);
380 }
381
Nir Soffera6b257a2019-08-13 21:21:03 +0300382 if (!s->buf_align) {
383 int i;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100384 size_t align;
Nir Soffera6b257a2019-08-13 21:21:03 +0300385 buf = qemu_memalign(max_align, 2 * max_align);
386 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
387 align = alignments[i];
388 if (raw_is_io_aligned(fd, buf + align, max_align)) {
Stefan Hajnoczi236094c2019-08-27 11:13:28 +0100389 /* Fallback to request_alignment. */
Nir Soffera6b257a2019-08-13 21:21:03 +0300390 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100391 break;
392 }
393 }
394 qemu_vfree(buf);
395 }
Kevin Wolfdf26a352014-07-16 17:48:17 +0200396
Eric Blakea5b8dd22016-06-23 16:37:24 -0600397 if (!s->buf_align || !bs->bl.request_alignment) {
Eric Blake8cc9c6e2016-06-23 16:37:25 -0600398 error_setg(errp, "Could not find working O_DIRECT alignment");
399 error_append_hint(errp, "Try cache.direct=off\n");
Kevin Wolfdf26a352014-07-16 17:48:17 +0200400 }
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100401}
402
Kevin Wolf23dece12019-03-01 22:15:11 +0100403static void raw_parse_flags(int bdrv_flags, int *open_flags, bool has_writers)
Jeff Cody6a8dc042012-09-20 15:13:21 -0400404{
Kevin Wolf23dece12019-03-01 22:15:11 +0100405 bool read_write = false;
Jeff Cody6a8dc042012-09-20 15:13:21 -0400406 assert(open_flags != NULL);
407
408 *open_flags |= O_BINARY;
409 *open_flags &= ~O_ACCMODE;
Kevin Wolf23dece12019-03-01 22:15:11 +0100410
411 if (bdrv_flags & BDRV_O_AUTO_RDONLY) {
412 read_write = has_writers;
413 } else if (bdrv_flags & BDRV_O_RDWR) {
414 read_write = true;
415 }
416
417 if (read_write) {
Jeff Cody6a8dc042012-09-20 15:13:21 -0400418 *open_flags |= O_RDWR;
419 } else {
420 *open_flags |= O_RDONLY;
421 }
422
423 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
424 * and O_DIRECT for no caching. */
425 if ((bdrv_flags & BDRV_O_NOCACHE)) {
426 *open_flags |= O_DIRECT;
427 }
Jeff Cody6a8dc042012-09-20 15:13:21 -0400428}
429
Max Reitz078896a2014-03-05 22:41:37 +0100430static void raw_parse_filename(const char *filename, QDict *options,
431 Error **errp)
432{
Max Reitz03c320d2017-05-22 21:52:16 +0200433 bdrv_parse_filename_strip_prefix(filename, "file:", options);
Max Reitz078896a2014-03-05 22:41:37 +0100434}
435
Kevin Wolfc66a6152013-04-02 10:47:40 +0200436static QemuOptsList raw_runtime_opts = {
437 .name = "raw",
438 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
439 .desc = {
440 {
441 .name = "filename",
442 .type = QEMU_OPT_STRING,
443 .help = "File name of the image",
444 },
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200445 {
446 .name = "aio",
447 .type = QEMU_OPT_STRING,
Aarushi Mehtac6447512020-01-20 14:18:51 +0000448 .help = "host AIO implementation (threads, native, io_uring)",
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200449 },
Fam Zheng16b48d52017-05-03 00:35:50 +0800450 {
451 .name = "locking",
452 .type = QEMU_OPT_STRING,
453 .help = "file locking mode (on/off/auto, default: auto)",
454 },
Paolo Bonzini7c9e5272017-08-21 18:58:56 +0200455 {
456 .name = "pr-manager",
457 .type = QEMU_OPT_STRING,
458 .help = "id of persistent reservation manager object (default: none)",
459 },
Stefan Hajnoczif357fcd2019-03-07 16:49:41 +0000460#if defined(__linux__)
461 {
462 .name = "drop-cache",
463 .type = QEMU_OPT_BOOL,
464 .help = "invalidate page cache during live migration (default: on)",
465 },
466#endif
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +0100467 {
468 .name = "x-check-cache-dropped",
469 .type = QEMU_OPT_BOOL,
470 .help = "check that page cache was dropped on live migration (default: off)"
471 },
Kevin Wolfc66a6152013-04-02 10:47:40 +0200472 { /* end of list */ }
473 },
474};
475
Alberto Garcia8a2ce0b2019-03-12 18:48:48 +0200476static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
477
Kevin Wolfc66a6152013-04-02 10:47:40 +0200478static int raw_open_common(BlockDriverState *bs, QDict *options,
John Snow230ff732018-07-10 13:00:40 -0400479 int bdrv_flags, int open_flags,
480 bool device, Error **errp)
bellard83f64092006-08-01 16:21:11 +0000481{
482 BDRVRawState *s = bs->opaque;
Kevin Wolfc66a6152013-04-02 10:47:40 +0200483 QemuOpts *opts;
484 Error *local_err = NULL;
Kevin Wolf8bfea152014-04-11 19:16:36 +0200485 const char *filename = NULL;
Paolo Bonzini7c9e5272017-08-21 18:58:56 +0200486 const char *str;
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200487 BlockdevAioOptions aio, aio_default;
Christoph Hellwig0e1d8f42009-06-15 13:53:26 +0200488 int fd, ret;
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100489 struct stat st;
Fam Zheng244a5662017-05-03 00:35:56 +0800490 OnOffAuto locking;
bellard83f64092006-08-01 16:21:11 +0000491
Peter Crosthwaite87ea75d2014-01-01 18:49:17 -0800492 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
Kevin Wolfc66a6152013-04-02 10:47:40 +0200493 qemu_opts_absorb_qdict(opts, options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100494 if (local_err) {
Max Reitze428e432013-10-11 11:37:01 +0200495 error_propagate(errp, local_err);
Kevin Wolfc66a6152013-04-02 10:47:40 +0200496 ret = -EINVAL;
497 goto fail;
498 }
499
500 filename = qemu_opt_get(opts, "filename");
501
Fam Zhengdb0754d2018-11-01 14:29:09 +0800502 ret = raw_normalize_devicepath(&filename, errp);
Christoph Egger1de1ae02011-05-24 11:30:29 +0200503 if (ret != 0) {
Kevin Wolfc66a6152013-04-02 10:47:40 +0200504 goto fail;
Christoph Egger1de1ae02011-05-24 11:30:29 +0200505 }
506
Aarushi Mehtac6447512020-01-20 14:18:51 +0000507 if (bdrv_flags & BDRV_O_NATIVE_AIO) {
508 aio_default = BLOCKDEV_AIO_OPTIONS_NATIVE;
509#ifdef CONFIG_LINUX_IO_URING
510 } else if (bdrv_flags & BDRV_O_IO_URING) {
511 aio_default = BLOCKDEV_AIO_OPTIONS_IO_URING;
512#endif
513 } else {
514 aio_default = BLOCKDEV_AIO_OPTIONS_THREADS;
515 }
516
Marc-AndrƩ Lureauf7abe0e2017-08-24 10:46:10 +0200517 aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
518 qemu_opt_get(opts, "aio"),
Markus Armbruster06c60b62017-08-24 10:45:57 +0200519 aio_default, &local_err);
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200520 if (local_err) {
521 error_propagate(errp, local_err);
522 ret = -EINVAL;
523 goto fail;
524 }
Aarushi Mehtac6447512020-01-20 14:18:51 +0000525
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200526 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
Aarushi Mehtac6447512020-01-20 14:18:51 +0000527#ifdef CONFIG_LINUX_IO_URING
528 s->use_linux_io_uring = (aio == BLOCKDEV_AIO_OPTIONS_IO_URING);
529#endif
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200530
Marc-AndrƩ Lureauf7abe0e2017-08-24 10:46:10 +0200531 locking = qapi_enum_parse(&OnOffAuto_lookup,
532 qemu_opt_get(opts, "locking"),
Markus Armbruster06c60b62017-08-24 10:45:57 +0200533 ON_OFF_AUTO_AUTO, &local_err);
Fam Zheng244a5662017-05-03 00:35:56 +0800534 if (local_err) {
535 error_propagate(errp, local_err);
536 ret = -EINVAL;
537 goto fail;
538 }
539 switch (locking) {
540 case ON_OFF_AUTO_ON:
541 s->use_lock = true;
Fam Zheng2b218f52017-08-11 19:44:47 +0800542 if (!qemu_has_ofd_lock()) {
Fam Zhengdb0754d2018-11-01 14:29:09 +0800543 warn_report("File lock requested but OFD locking syscall is "
544 "unavailable, falling back to POSIX file locks");
545 error_printf("Due to the implementation, locks can be lost "
546 "unexpectedly.\n");
Fam Zheng2b218f52017-08-11 19:44:47 +0800547 }
Fam Zheng244a5662017-05-03 00:35:56 +0800548 break;
549 case ON_OFF_AUTO_OFF:
550 s->use_lock = false;
551 break;
552 case ON_OFF_AUTO_AUTO:
Fam Zheng2b218f52017-08-11 19:44:47 +0800553 s->use_lock = qemu_has_ofd_lock();
Fam Zheng244a5662017-05-03 00:35:56 +0800554 break;
555 default:
556 abort();
557 }
558
Paolo Bonzini7c9e5272017-08-21 18:58:56 +0200559 str = qemu_opt_get(opts, "pr-manager");
560 if (str) {
561 s->pr_mgr = pr_manager_lookup(str, &local_err);
562 if (local_err) {
563 error_propagate(errp, local_err);
564 ret = -EINVAL;
565 goto fail;
566 }
567 }
568
Stefan Hajnoczif357fcd2019-03-07 16:49:41 +0000569 s->drop_cache = qemu_opt_get_bool(opts, "drop-cache", true);
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +0100570 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
571 false);
572
Jeff Cody6a8dc042012-09-20 15:13:21 -0400573 s->open_flags = open_flags;
Kevin Wolf23dece12019-03-01 22:15:11 +0100574 raw_parse_flags(bdrv_flags, &s->open_flags, false);
bellard83f64092006-08-01 16:21:11 +0000575
Christoph Hellwig90babde2009-06-15 13:53:38 +0200576 s->fd = -1;
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100577 fd = qemu_open(filename, s->open_flags, 0644);
Kevin Wolf64107dc2018-10-08 17:27:18 +0200578 ret = fd < 0 ? -errno : 0;
579
Kevin Wolf64107dc2018-10-08 17:27:18 +0200580 if (ret < 0) {
Paolo Bonzinif6fc1e32019-07-25 11:59:20 +0200581 error_setg_file_open(errp, -ret, filename);
Kevin Wolfc66a6152013-04-02 10:47:40 +0200582 if (ret == -EROFS) {
bellard19cb3732006-08-19 11:45:59 +0000583 ret = -EACCES;
Kevin Wolfc66a6152013-04-02 10:47:40 +0200584 }
585 goto fail;
bellard19cb3732006-08-19 11:45:59 +0000586 }
bellard83f64092006-08-01 16:21:11 +0000587 s->fd = fd;
Christoph Hellwig9ef91a62009-08-20 16:58:19 +0200588
Fam Zheng244a5662017-05-03 00:35:56 +0800589 s->perm = 0;
590 s->shared_perm = BLK_PERM_ALL;
591
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +0200592#ifdef CONFIG_LINUX_AIO
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200593 /* Currently Linux does AIO only for files opened with O_DIRECT */
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -0700594 if (s->use_linux_aio) {
595 if (!(s->open_flags & O_DIRECT)) {
596 error_setg(errp, "aio=native was specified, but it requires "
597 "cache.direct=on, which was not specified.");
598 ret = -EINVAL;
599 goto fail;
600 }
601 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
602 error_prepend(errp, "Unable to use native AIO: ");
603 goto fail;
604 }
Kevin Wolf96518252015-03-17 13:45:21 +0100605 }
Stefan Hajnoczi1501ecc2015-07-23 13:48:34 +0100606#else
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200607 if (s->use_linux_aio) {
Kevin Wolfd657c0c2015-12-15 11:35:36 +0100608 error_setg(errp, "aio=native was specified, but is not supported "
609 "in this build.");
610 ret = -EINVAL;
611 goto fail;
Stefan Hajnoczi1501ecc2015-07-23 13:48:34 +0100612 }
613#endif /* !defined(CONFIG_LINUX_AIO) */
Christoph Hellwig9ef91a62009-08-20 16:58:19 +0200614
Aarushi Mehtac6447512020-01-20 14:18:51 +0000615#ifdef CONFIG_LINUX_IO_URING
616 if (s->use_linux_io_uring) {
617 if (!aio_setup_linux_io_uring(bdrv_get_aio_context(bs), errp)) {
618 error_prepend(errp, "Unable to use io_uring: ");
619 goto fail;
620 }
621 }
622#else
623 if (s->use_linux_io_uring) {
624 error_setg(errp, "aio=io_uring was specified, but is not supported "
625 "in this build.");
626 ret = -EINVAL;
627 goto fail;
628 }
629#endif /* !defined(CONFIG_LINUX_IO_URING) */
630
Paolo Bonzini7ce21012013-11-22 13:39:47 +0100631 s->has_discard = true;
Paolo Bonzini97a2ae32013-11-22 13:39:57 +0100632 s->has_write_zeroes = true;
Roger Pau Monne3cad8302014-10-21 16:03:03 +0200633 if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
634 s->needs_alignment = true;
635 }
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100636
637 if (fstat(s->fd, &st) < 0) {
Max Reitz01212d42014-12-02 18:32:53 +0100638 ret = -errno;
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100639 error_setg_errno(errp, errno, "Could not stat file");
640 goto fail;
641 }
John Snow230ff732018-07-10 13:00:40 -0400642
643 if (!device) {
644 if (S_ISBLK(st.st_mode)) {
645 warn_report("Opening a block device as a file using the '%s' "
646 "driver is deprecated", bs->drv->format_name);
647 } else if (S_ISCHR(st.st_mode)) {
648 warn_report("Opening a character device as a file using the '%s' "
649 "driver is deprecated", bs->drv->format_name);
650 } else if (!S_ISREG(st.st_mode)) {
651 error_setg(errp, "A regular file was expected by the '%s' driver, "
652 "but something else was given", bs->drv->format_name);
653 ret = -EINVAL;
654 goto fail;
655 } else {
656 s->discard_zeroes = true;
657 s->has_fallocate = true;
658 }
659 } else {
660 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
661 error_setg(errp, "'%s' driver expects either "
662 "a character or block device", bs->drv->format_name);
663 ret = -EINVAL;
664 goto fail;
665 }
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100666 }
John Snow230ff732018-07-10 13:00:40 -0400667
Paolo Bonzinid0b45032013-11-22 13:39:56 +0100668 if (S_ISBLK(st.st_mode)) {
669#ifdef BLKDISCARDZEROES
670 unsigned int arg;
671 if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
672 s->discard_zeroes = true;
673 }
674#endif
675#ifdef __linux__
676 /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do
677 * not rely on the contents of discarded blocks unless using O_DIRECT.
Paolo Bonzini97a2ae32013-11-22 13:39:57 +0100678 * Same for BLKZEROOUT.
Paolo Bonzinid0b45032013-11-22 13:39:56 +0100679 */
680 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
681 s->discard_zeroes = false;
Paolo Bonzini97a2ae32013-11-22 13:39:57 +0100682 s->has_write_zeroes = false;
Paolo Bonzinid0b45032013-11-22 13:39:56 +0100683 }
684#endif
685 }
Roger Pau Monne3cad8302014-10-21 16:03:03 +0200686#ifdef __FreeBSD__
687 if (S_ISCHR(st.st_mode)) {
688 /*
689 * The file is a char device (disk), which on FreeBSD isn't behind
690 * a pager, so force all requests to be aligned. This is needed
691 * so QEMU makes sure all IO operations on the device are aligned
692 * to sector size, or else FreeBSD will reject them with EINVAL.
693 */
694 s->needs_alignment = true;
695 }
696#endif
Paolo Bonzini260a82e2013-11-22 13:39:55 +0100697
Christoph Hellwigdce512d2010-12-17 11:41:15 +0100698#ifdef CONFIG_XFS
699 if (platform_test_xfs_fd(s->fd)) {
Paolo Bonzini7ce21012013-11-22 13:39:47 +0100700 s->is_xfs = true;
Christoph Hellwigdce512d2010-12-17 11:41:15 +0100701 }
702#endif
703
Kevin Wolf738301e2019-03-22 13:45:23 +0100704 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
Kevin Wolf2f0c6e72020-04-24 14:54:44 +0200705 if (S_ISREG(st.st_mode)) {
706 /* When extending regular files, we get zeros from the OS */
707 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
708 }
Kevin Wolfc66a6152013-04-02 10:47:40 +0200709 ret = 0;
710fail:
Kevin Wolf8bfea152014-04-11 19:16:36 +0200711 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
712 unlink(filename);
713 }
Kevin Wolfc66a6152013-04-02 10:47:40 +0200714 qemu_opts_del(opts);
715 return ret;
bellard83f64092006-08-01 16:21:11 +0000716}
717
Max Reitz015a1032013-09-05 14:22:29 +0200718static int raw_open(BlockDriverState *bs, QDict *options, int flags,
719 Error **errp)
Christoph Hellwig90babde2009-06-15 13:53:38 +0200720{
721 BDRVRawState *s = bs->opaque;
722
723 s->type = FTYPE_FILE;
John Snow230ff732018-07-10 13:00:40 -0400724 return raw_open_common(bs, options, flags, 0, false, errp);
Christoph Hellwig90babde2009-06-15 13:53:38 +0200725}
726
Fam Zheng244a5662017-05-03 00:35:56 +0800727typedef enum {
728 RAW_PL_PREPARE,
729 RAW_PL_COMMIT,
730 RAW_PL_ABORT,
731} RawPermLockOp;
732
733#define PERM_FOREACH(i) \
734 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
735
736/* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
737 * file; if @unlock == true, also unlock the unneeded bytes.
738 * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
739 */
Fam Zheng2996ffa2018-10-11 15:21:33 +0800740static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
Fam Zheng244a5662017-05-03 00:35:56 +0800741 uint64_t perm_lock_bits,
742 uint64_t shared_perm_lock_bits,
743 bool unlock, Error **errp)
744{
745 int ret;
746 int i;
Fam Zheng2996ffa2018-10-11 15:21:33 +0800747 uint64_t locked_perm, locked_shared_perm;
748
749 if (s) {
750 locked_perm = s->locked_perm;
751 locked_shared_perm = s->locked_shared_perm;
752 } else {
753 /*
754 * We don't have the previous bits, just lock/unlock for each of the
755 * requested bits.
756 */
757 if (unlock) {
758 locked_perm = BLK_PERM_ALL;
759 locked_shared_perm = BLK_PERM_ALL;
760 } else {
761 locked_perm = 0;
762 locked_shared_perm = 0;
763 }
764 }
Fam Zheng244a5662017-05-03 00:35:56 +0800765
766 PERM_FOREACH(i) {
767 int off = RAW_LOCK_PERM_BASE + i;
Fam Zheng2996ffa2018-10-11 15:21:33 +0800768 uint64_t bit = (1ULL << i);
769 if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
Max Reitzd0a96152018-05-09 23:53:34 +0200770 ret = qemu_lock_fd(fd, off, 1, false);
Fam Zheng244a5662017-05-03 00:35:56 +0800771 if (ret) {
772 error_setg(errp, "Failed to lock byte %d", off);
773 return ret;
Fam Zheng2996ffa2018-10-11 15:21:33 +0800774 } else if (s) {
775 s->locked_perm |= bit;
Fam Zheng244a5662017-05-03 00:35:56 +0800776 }
Fam Zheng2996ffa2018-10-11 15:21:33 +0800777 } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
Max Reitzd0a96152018-05-09 23:53:34 +0200778 ret = qemu_unlock_fd(fd, off, 1);
Fam Zheng244a5662017-05-03 00:35:56 +0800779 if (ret) {
780 error_setg(errp, "Failed to unlock byte %d", off);
781 return ret;
Fam Zheng2996ffa2018-10-11 15:21:33 +0800782 } else if (s) {
783 s->locked_perm &= ~bit;
Fam Zheng244a5662017-05-03 00:35:56 +0800784 }
785 }
786 }
787 PERM_FOREACH(i) {
788 int off = RAW_LOCK_SHARED_BASE + i;
Fam Zheng2996ffa2018-10-11 15:21:33 +0800789 uint64_t bit = (1ULL << i);
790 if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
Max Reitzd0a96152018-05-09 23:53:34 +0200791 ret = qemu_lock_fd(fd, off, 1, false);
Fam Zheng244a5662017-05-03 00:35:56 +0800792 if (ret) {
793 error_setg(errp, "Failed to lock byte %d", off);
794 return ret;
Fam Zheng2996ffa2018-10-11 15:21:33 +0800795 } else if (s) {
796 s->locked_shared_perm |= bit;
Fam Zheng244a5662017-05-03 00:35:56 +0800797 }
Fam Zheng2996ffa2018-10-11 15:21:33 +0800798 } else if (unlock && (locked_shared_perm & bit) &&
799 !(shared_perm_lock_bits & bit)) {
Max Reitzd0a96152018-05-09 23:53:34 +0200800 ret = qemu_unlock_fd(fd, off, 1);
Fam Zheng244a5662017-05-03 00:35:56 +0800801 if (ret) {
802 error_setg(errp, "Failed to unlock byte %d", off);
803 return ret;
Fam Zheng2996ffa2018-10-11 15:21:33 +0800804 } else if (s) {
805 s->locked_shared_perm &= ~bit;
Fam Zheng244a5662017-05-03 00:35:56 +0800806 }
807 }
808 }
809 return 0;
810}
811
812/* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
Max Reitzd0a96152018-05-09 23:53:34 +0200813static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
Fam Zheng244a5662017-05-03 00:35:56 +0800814 Error **errp)
815{
816 int ret;
817 int i;
818
819 PERM_FOREACH(i) {
820 int off = RAW_LOCK_SHARED_BASE + i;
821 uint64_t p = 1ULL << i;
822 if (perm & p) {
Max Reitzd0a96152018-05-09 23:53:34 +0200823 ret = qemu_lock_fd_test(fd, off, 1, true);
Fam Zheng244a5662017-05-03 00:35:56 +0800824 if (ret) {
825 char *perm_name = bdrv_perm_names(p);
826 error_setg(errp,
827 "Failed to get \"%s\" lock",
828 perm_name);
829 g_free(perm_name);
Fam Zheng244a5662017-05-03 00:35:56 +0800830 return ret;
831 }
832 }
833 }
834 PERM_FOREACH(i) {
835 int off = RAW_LOCK_PERM_BASE + i;
836 uint64_t p = 1ULL << i;
837 if (!(shared_perm & p)) {
Max Reitzd0a96152018-05-09 23:53:34 +0200838 ret = qemu_lock_fd_test(fd, off, 1, true);
Fam Zheng244a5662017-05-03 00:35:56 +0800839 if (ret) {
840 char *perm_name = bdrv_perm_names(p);
841 error_setg(errp,
842 "Failed to get shared \"%s\" lock",
843 perm_name);
844 g_free(perm_name);
Fam Zheng244a5662017-05-03 00:35:56 +0800845 return ret;
846 }
847 }
848 }
849 return 0;
850}
851
852static int raw_handle_perm_lock(BlockDriverState *bs,
853 RawPermLockOp op,
854 uint64_t new_perm, uint64_t new_shared,
855 Error **errp)
856{
857 BDRVRawState *s = bs->opaque;
858 int ret = 0;
859 Error *local_err = NULL;
860
861 if (!s->use_lock) {
862 return 0;
863 }
864
865 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
866 return 0;
867 }
868
Fam Zheng244a5662017-05-03 00:35:56 +0800869 switch (op) {
870 case RAW_PL_PREPARE:
Vladimir Sementsov-Ogievskiy696aaae2019-03-29 14:04:54 +0300871 if ((s->perm | new_perm) == s->perm &&
872 (s->shared_perm & new_shared) == s->shared_perm)
873 {
874 /*
875 * We are going to unlock bytes, it should not fail. If it fail due
876 * to some fs-dependent permission-unrelated reasons (which occurs
877 * sometimes on NFS and leads to abort in bdrv_replace_child) we
878 * can't prevent such errors by any check here. And we ignore them
879 * anyway in ABORT and COMMIT.
880 */
881 return 0;
882 }
Fam Zhengf2e3af22018-10-11 15:21:34 +0800883 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
Fam Zheng244a5662017-05-03 00:35:56 +0800884 ~s->shared_perm | ~new_shared,
885 false, errp);
886 if (!ret) {
Fam Zhengf2e3af22018-10-11 15:21:34 +0800887 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
Fam Zheng244a5662017-05-03 00:35:56 +0800888 if (!ret) {
889 return 0;
890 }
Fam Zhengb8574312018-09-25 13:05:01 +0800891 error_append_hint(errp,
892 "Is another process using the image [%s]?\n",
893 bs->filename);
Fam Zheng244a5662017-05-03 00:35:56 +0800894 }
Fam Zheng244a5662017-05-03 00:35:56 +0800895 /* fall through to unlock bytes. */
896 case RAW_PL_ABORT:
Fam Zhengf2e3af22018-10-11 15:21:34 +0800897 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
Max Reitzd0a96152018-05-09 23:53:34 +0200898 true, &local_err);
Fam Zheng244a5662017-05-03 00:35:56 +0800899 if (local_err) {
900 /* Theoretically the above call only unlocks bytes and it cannot
901 * fail. Something weird happened, report it.
902 */
Fam Zhengdb0754d2018-11-01 14:29:09 +0800903 warn_report_err(local_err);
Fam Zheng244a5662017-05-03 00:35:56 +0800904 }
905 break;
906 case RAW_PL_COMMIT:
Fam Zhengf2e3af22018-10-11 15:21:34 +0800907 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
Max Reitzd0a96152018-05-09 23:53:34 +0200908 true, &local_err);
Fam Zheng244a5662017-05-03 00:35:56 +0800909 if (local_err) {
910 /* Theoretically the above call only unlocks bytes and it cannot
911 * fail. Something weird happened, report it.
912 */
Fam Zhengdb0754d2018-11-01 14:29:09 +0800913 warn_report_err(local_err);
Fam Zheng244a5662017-05-03 00:35:56 +0800914 }
915 break;
916 }
917 return ret;
918}
919
Kevin Wolf5cec2872019-03-02 00:26:30 +0100920static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
Kevin Wolf23dece12019-03-01 22:15:11 +0100921 int *open_flags, uint64_t perm, bool force_dup,
Kevin Wolf6ceabe62019-03-08 15:40:40 +0100922 Error **errp)
Kevin Wolf5cec2872019-03-02 00:26:30 +0100923{
924 BDRVRawState *s = bs->opaque;
925 int fd = -1;
926 int ret;
Kevin Wolf23dece12019-03-01 22:15:11 +0100927 bool has_writers = perm &
928 (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
Kevin Wolf5cec2872019-03-02 00:26:30 +0100929 int fcntl_flags = O_APPEND | O_NONBLOCK;
930#ifdef O_NOATIME
931 fcntl_flags |= O_NOATIME;
932#endif
933
934 *open_flags = 0;
935 if (s->type == FTYPE_CD) {
936 *open_flags |= O_NONBLOCK;
937 }
938
Kevin Wolf23dece12019-03-01 22:15:11 +0100939 raw_parse_flags(flags, open_flags, has_writers);
Kevin Wolf5cec2872019-03-02 00:26:30 +0100940
941#ifdef O_ASYNC
942 /* Not all operating systems have O_ASYNC, and those that don't
943 * will not let us track the state into rs->open_flags (typically
944 * you achieve the same effect with an ioctl, for example I_SETSIG
945 * on Solaris). But we do not use O_ASYNC, so that's fine.
946 */
947 assert((s->open_flags & O_ASYNC) == 0);
948#endif
949
Kevin Wolf6ceabe62019-03-08 15:40:40 +0100950 if (!force_dup && *open_flags == s->open_flags) {
951 /* We're lucky, the existing fd is fine */
952 return s->fd;
953 }
954
Kevin Wolf5cec2872019-03-02 00:26:30 +0100955 if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
956 /* dup the original fd */
957 fd = qemu_dup(s->fd);
958 if (fd >= 0) {
959 ret = fcntl_setfl(fd, *open_flags);
960 if (ret) {
961 qemu_close(fd);
962 fd = -1;
963 }
964 }
965 }
966
967 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
968 if (fd == -1) {
969 const char *normalized_filename = bs->filename;
970 ret = raw_normalize_devicepath(&normalized_filename, errp);
971 if (ret >= 0) {
972 assert(!(*open_flags & O_CREAT));
973 fd = qemu_open(normalized_filename, *open_flags);
974 if (fd == -1) {
975 error_setg_errno(errp, errno, "Could not reopen file");
976 return -1;
977 }
978 }
979 }
980
981 return fd;
982}
983
Jeff Codyeeb6b452012-09-20 15:13:25 -0400984static int raw_reopen_prepare(BDRVReopenState *state,
985 BlockReopenQueue *queue, Error **errp)
986{
987 BDRVRawState *s;
Fam Zheng4e6d13c2016-10-27 18:45:17 +0800988 BDRVRawReopenState *rs;
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +0100989 QemuOpts *opts;
Kevin Wolfa6aeca02019-03-01 22:48:45 +0100990 int ret;
Kevin Wolfdf26a352014-07-16 17:48:17 +0200991 Error *local_err = NULL;
Jeff Codyeeb6b452012-09-20 15:13:25 -0400992
993 assert(state != NULL);
994 assert(state->bs != NULL);
995
996 s = state->bs->opaque;
997
Markus Armbruster5839e532014-08-19 10:31:08 +0200998 state->opaque = g_new0(BDRVRawReopenState, 1);
Fam Zheng4e6d13c2016-10-27 18:45:17 +0800999 rs = state->opaque;
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +01001000
1001 /* Handle options changes */
1002 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
1003 qemu_opts_absorb_qdict(opts, state->options, &local_err);
1004 if (local_err) {
1005 error_propagate(errp, local_err);
1006 ret = -EINVAL;
1007 goto out;
1008 }
1009
Stefan Hajnoczif357fcd2019-03-07 16:49:41 +00001010 rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true);
Alberto Garcia8d324572018-09-06 12:37:07 +03001011 rs->check_cache_dropped =
1012 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
1013
1014 /* This driver's reopen function doesn't currently allow changing
1015 * other options, so let's put them back in the original QDict and
1016 * bdrv_reopen_prepare() will detect changes and complain. */
1017 qemu_opts_to_qdict(opts, state->options);
Jeff Codyeeb6b452012-09-20 15:13:25 -04001018
Kevin Wolf5cec2872019-03-02 00:26:30 +01001019 rs->fd = raw_reconfigure_getfd(state->bs, state->flags, &rs->open_flags,
Kevin Wolf23dece12019-03-01 22:15:11 +01001020 state->perm, true, &local_err);
Kevin Wolf5cec2872019-03-02 00:26:30 +01001021 if (local_err) {
1022 error_propagate(errp, local_err);
1023 ret = -1;
1024 goto out;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001025 }
Kevin Wolfdf26a352014-07-16 17:48:17 +02001026
1027 /* Fail already reopen_prepare() if we can't get a working O_DIRECT
1028 * alignment with the new fd. */
Fam Zheng4e6d13c2016-10-27 18:45:17 +08001029 if (rs->fd != -1) {
1030 raw_probe_alignment(state->bs, rs->fd, &local_err);
Kevin Wolfdf26a352014-07-16 17:48:17 +02001031 if (local_err) {
Kevin Wolfdf26a352014-07-16 17:48:17 +02001032 error_propagate(errp, local_err);
1033 ret = -EINVAL;
Kevin Wolfa6aeca02019-03-01 22:48:45 +01001034 goto out_fd;
1035 }
Kevin Wolfdf26a352014-07-16 17:48:17 +02001036 }
1037
Kevin Wolfe0c9cf32019-03-07 19:07:35 +01001038 s->reopen_state = state;
Kevin Wolfa6aeca02019-03-01 22:48:45 +01001039 ret = 0;
1040out_fd:
1041 if (ret < 0) {
1042 qemu_close(rs->fd);
1043 rs->fd = -1;
1044 }
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +01001045out:
1046 qemu_opts_del(opts);
Jeff Codyeeb6b452012-09-20 15:13:25 -04001047 return ret;
1048}
1049
Jeff Codyeeb6b452012-09-20 15:13:25 -04001050static void raw_reopen_commit(BDRVReopenState *state)
1051{
Fam Zheng4e6d13c2016-10-27 18:45:17 +08001052 BDRVRawReopenState *rs = state->opaque;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001053 BDRVRawState *s = state->bs->opaque;
1054
Stefan Hajnoczif357fcd2019-03-07 16:49:41 +00001055 s->drop_cache = rs->drop_cache;
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +01001056 s->check_cache_dropped = rs->check_cache_dropped;
Fam Zheng4e6d13c2016-10-27 18:45:17 +08001057 s->open_flags = rs->open_flags;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001058
1059 qemu_close(s->fd);
Fam Zheng4e6d13c2016-10-27 18:45:17 +08001060 s->fd = rs->fd;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001061
1062 g_free(state->opaque);
1063 state->opaque = NULL;
Kevin Wolfe0c9cf32019-03-07 19:07:35 +01001064
1065 assert(s->reopen_state == state);
1066 s->reopen_state = NULL;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001067}
1068
1069
1070static void raw_reopen_abort(BDRVReopenState *state)
1071{
Fam Zheng4e6d13c2016-10-27 18:45:17 +08001072 BDRVRawReopenState *rs = state->opaque;
Kevin Wolfe0c9cf32019-03-07 19:07:35 +01001073 BDRVRawState *s = state->bs->opaque;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001074
1075 /* nothing to do if NULL, we didn't get far enough */
Fam Zheng4e6d13c2016-10-27 18:45:17 +08001076 if (rs == NULL) {
Jeff Codyeeb6b452012-09-20 15:13:25 -04001077 return;
1078 }
1079
Fam Zheng4e6d13c2016-10-27 18:45:17 +08001080 if (rs->fd >= 0) {
1081 qemu_close(rs->fd);
1082 rs->fd = -1;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001083 }
1084 g_free(state->opaque);
1085 state->opaque = NULL;
Kevin Wolfe0c9cf32019-03-07 19:07:35 +01001086
1087 assert(s->reopen_state == state);
1088 s->reopen_state = NULL;
Jeff Codyeeb6b452012-09-20 15:13:25 -04001089}
1090
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001091static int sg_get_max_transfer_length(int fd)
Fam Zheng6f607172016-06-03 10:07:02 +08001092{
1093#ifdef BLKSECTGET
Eric Farman48265252017-01-20 17:25:26 +01001094 int max_bytes = 0;
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001095
1096 if (ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
Eric Farman48265252017-01-20 17:25:26 +01001097 return max_bytes;
Fam Zheng6f607172016-06-03 10:07:02 +08001098 } else {
1099 return -errno;
1100 }
1101#else
1102 return -ENOSYS;
1103#endif
1104}
1105
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001106static int sg_get_max_segments(int fd)
Fam Zheng9103f1c2017-03-08 20:08:14 +08001107{
1108#ifdef CONFIG_LINUX
1109 char buf[32];
1110 const char *end;
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001111 char *sysfspath = NULL;
Fam Zheng9103f1c2017-03-08 20:08:14 +08001112 int ret;
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001113 int sysfd = -1;
Fam Zheng9103f1c2017-03-08 20:08:14 +08001114 long max_segments;
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001115 struct stat st;
1116
1117 if (fstat(fd, &st)) {
1118 ret = -errno;
1119 goto out;
1120 }
Fam Zheng9103f1c2017-03-08 20:08:14 +08001121
1122 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001123 major(st.st_rdev), minor(st.st_rdev));
1124 sysfd = open(sysfspath, O_RDONLY);
1125 if (sysfd == -1) {
Fam Zheng9103f1c2017-03-08 20:08:14 +08001126 ret = -errno;
1127 goto out;
1128 }
1129 do {
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001130 ret = read(sysfd, buf, sizeof(buf) - 1);
Fam Zheng9103f1c2017-03-08 20:08:14 +08001131 } while (ret == -1 && errno == EINTR);
1132 if (ret < 0) {
1133 ret = -errno;
1134 goto out;
1135 } else if (ret == 0) {
1136 ret = -EIO;
1137 goto out;
1138 }
1139 buf[ret] = 0;
1140 /* The file is ended with '\n', pass 'end' to accept that. */
1141 ret = qemu_strtol(buf, &end, 10, &max_segments);
1142 if (ret == 0 && end && *end == '\n') {
1143 ret = max_segments;
1144 }
1145
1146out:
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001147 if (sysfd != -1) {
1148 close(sysfd);
Fam Zhengfed414d2017-03-15 00:12:05 +08001149 }
Fam Zheng9103f1c2017-03-08 20:08:14 +08001150 g_free(sysfspath);
1151 return ret;
1152#else
1153 return -ENOTSUP;
1154#endif
1155}
1156
Kevin Wolf3baca892014-07-16 17:48:16 +02001157static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01001158{
1159 BDRVRawState *s = bs->opaque;
Fam Zheng6f607172016-06-03 10:07:02 +08001160
Maxim Levitsky867eccf2019-07-04 15:43:42 +03001161 if (bs->sg) {
1162 int ret = sg_get_max_transfer_length(s->fd);
1163
1164 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1165 bs->bl.max_transfer = pow2floor(ret);
1166 }
1167
1168 ret = sg_get_max_segments(s->fd);
1169 if (ret > 0) {
Wei Yang038adc22019-10-13 10:11:45 +08001170 bs->bl.max_transfer = MIN(bs->bl.max_transfer,
1171 ret * qemu_real_host_page_size);
Fam Zheng6f607172016-06-03 10:07:02 +08001172 }
1173 }
Jeff Codyeeb6b452012-09-20 15:13:25 -04001174
Kevin Wolfdf26a352014-07-16 17:48:17 +02001175 raw_probe_alignment(bs, s->fd, errp);
Denis V. Lunev4196d2f2015-05-12 17:30:55 +03001176 bs->bl.min_mem_alignment = s->buf_align;
Wei Yang038adc22019-10-13 10:11:45 +08001177 bs->bl.opt_mem_alignment = MAX(s->buf_align, qemu_real_host_page_size);
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01001178}
bellard83f64092006-08-01 16:21:11 +00001179
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +01001180static int check_for_dasd(int fd)
1181{
1182#ifdef BIODASDINFO2
1183 struct dasd_information2_t info = {0};
1184
1185 return ioctl(fd, BIODASDINFO2, &info);
1186#else
1187 return -1;
1188#endif
1189}
1190
1191/**
1192 * Try to get @bs's logical and physical block size.
1193 * On success, store them in @bsz and return zero.
1194 * On failure, return negative errno.
1195 */
1196static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1197{
1198 BDRVRawState *s = bs->opaque;
1199 int ret;
1200
1201 /* If DASD, get blocksizes */
1202 if (check_for_dasd(s->fd) < 0) {
1203 return -ENOTSUP;
1204 }
1205 ret = probe_logical_blocksize(s->fd, &bsz->log);
1206 if (ret < 0) {
1207 return ret;
1208 }
1209 return probe_physical_blocksize(s->fd, &bsz->phys);
1210}
1211
1212/**
1213 * Try to get @bs's geometry: cyls, heads, sectors.
1214 * On success, store them in @geo and return 0.
1215 * On failure return -errno.
1216 * (Allows block driver to assign default geometry values that guest sees)
1217 */
1218#ifdef __linux__
1219static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1220{
1221 BDRVRawState *s = bs->opaque;
1222 struct hd_geometry ioctl_geo = {0};
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +01001223
1224 /* If DASD, get its geometry */
1225 if (check_for_dasd(s->fd) < 0) {
1226 return -ENOTSUP;
1227 }
1228 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1229 return -errno;
1230 }
1231 /* HDIO_GETGEO may return success even though geo contains zeros
1232 (e.g. certain multipath setups) */
1233 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1234 return -ENOTSUP;
1235 }
1236 /* Do not return a geometry for partition */
1237 if (ioctl_geo.start != 0) {
1238 return -ENOTSUP;
1239 }
1240 geo->heads = ioctl_geo.heads;
1241 geo->sectors = ioctl_geo.sectors;
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +01001242 geo->cylinders = ioctl_geo.cylinders;
1243
1244 return 0;
1245}
1246#else /* __linux__ */
1247static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1248{
1249 return -ENOTSUP;
1250}
1251#endif
1252
Kevin Wolf03425672018-10-31 11:30:42 +01001253#if defined(__linux__)
1254static int handle_aiocb_ioctl(void *opaque)
Paolo Bonzinide81a162012-05-25 11:46:27 +02001255{
Kevin Wolf03425672018-10-31 11:30:42 +01001256 RawPosixAIOData *aiocb = opaque;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001257 int ret;
1258
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001259 ret = ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf);
Paolo Bonzinide81a162012-05-25 11:46:27 +02001260 if (ret == -1) {
1261 return -errno;
1262 }
1263
Paolo Bonzinib608c8d2013-01-10 15:28:35 +01001264 return 0;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001265}
Kevin Wolf03425672018-10-31 11:30:42 +01001266#endif /* linux */
Paolo Bonzinide81a162012-05-25 11:46:27 +02001267
Kevin Wolf06dc9bd2018-10-25 14:18:58 +01001268static int handle_aiocb_flush(void *opaque)
Paolo Bonzinide81a162012-05-25 11:46:27 +02001269{
Kevin Wolf06dc9bd2018-10-25 14:18:58 +01001270 RawPosixAIOData *aiocb = opaque;
Kevin Wolfe5bcf962017-03-22 22:00:05 +01001271 BDRVRawState *s = aiocb->bs->opaque;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001272 int ret;
1273
Kevin Wolfe5bcf962017-03-22 22:00:05 +01001274 if (s->page_cache_inconsistent) {
1275 return -EIO;
1276 }
1277
Paolo Bonzinide81a162012-05-25 11:46:27 +02001278 ret = qemu_fdatasync(aiocb->aio_fildes);
1279 if (ret == -1) {
Kevin Wolfe5bcf962017-03-22 22:00:05 +01001280 /* There is no clear definition of the semantics of a failing fsync(),
1281 * so we may have to assume the worst. The sad truth is that this
1282 * assumption is correct for Linux. Some pages are now probably marked
1283 * clean in the page cache even though they are inconsistent with the
1284 * on-disk contents. The next fdatasync() call would succeed, but no
1285 * further writeback attempt will be made. We can't get back to a state
1286 * in which we know what is on disk (we would have to rewrite
1287 * everything that was touched since the last fdatasync() at least), so
1288 * make bdrv_flush() fail permanently. Given that the behaviour isn't
1289 * really defined, I have little hope that other OSes are doing better.
1290 *
1291 * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1292 * cache. */
1293 if ((s->open_flags & O_DIRECT) == 0) {
1294 s->page_cache_inconsistent = true;
1295 }
Paolo Bonzinide81a162012-05-25 11:46:27 +02001296 return -errno;
1297 }
1298 return 0;
1299}
1300
1301#ifdef CONFIG_PREADV
1302
1303static bool preadv_present = true;
1304
1305static ssize_t
1306qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1307{
1308 return preadv(fd, iov, nr_iov, offset);
1309}
1310
1311static ssize_t
1312qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1313{
1314 return pwritev(fd, iov, nr_iov, offset);
1315}
1316
1317#else
1318
1319static bool preadv_present = false;
1320
1321static ssize_t
1322qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1323{
1324 return -ENOSYS;
1325}
1326
1327static ssize_t
1328qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1329{
1330 return -ENOSYS;
1331}
1332
1333#endif
1334
1335static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1336{
1337 ssize_t len;
1338
1339 do {
1340 if (aiocb->aio_type & QEMU_AIO_WRITE)
1341 len = qemu_pwritev(aiocb->aio_fildes,
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001342 aiocb->io.iov,
1343 aiocb->io.niov,
Paolo Bonzinide81a162012-05-25 11:46:27 +02001344 aiocb->aio_offset);
1345 else
1346 len = qemu_preadv(aiocb->aio_fildes,
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001347 aiocb->io.iov,
1348 aiocb->io.niov,
Paolo Bonzinide81a162012-05-25 11:46:27 +02001349 aiocb->aio_offset);
1350 } while (len == -1 && errno == EINTR);
1351
1352 if (len == -1) {
1353 return -errno;
1354 }
1355 return len;
1356}
1357
1358/*
1359 * Read/writes the data to/from a given linear buffer.
1360 *
1361 * Returns the number of bytes handles or -errno in case of an error. Short
1362 * reads are only returned if the end of the file is reached.
1363 */
1364static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1365{
1366 ssize_t offset = 0;
1367 ssize_t len;
1368
1369 while (offset < aiocb->aio_nbytes) {
1370 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1371 len = pwrite(aiocb->aio_fildes,
1372 (const char *)buf + offset,
1373 aiocb->aio_nbytes - offset,
1374 aiocb->aio_offset + offset);
1375 } else {
1376 len = pread(aiocb->aio_fildes,
1377 buf + offset,
1378 aiocb->aio_nbytes - offset,
1379 aiocb->aio_offset + offset);
1380 }
1381 if (len == -1 && errno == EINTR) {
1382 continue;
Stefan Hajnoczi61ed73c2014-08-21 13:44:07 +01001383 } else if (len == -1 && errno == EINVAL &&
1384 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1385 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1386 offset > 0) {
1387 /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1388 * after a short read. Assume that O_DIRECT short reads only occur
1389 * at EOF. Therefore this is a short read, not an I/O error.
1390 */
1391 break;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001392 } else if (len == -1) {
1393 offset = -errno;
1394 break;
1395 } else if (len == 0) {
1396 break;
1397 }
1398 offset += len;
1399 }
1400
1401 return offset;
1402}
1403
Kevin Wolf999e6b62018-10-25 14:18:58 +01001404static int handle_aiocb_rw(void *opaque)
Paolo Bonzinide81a162012-05-25 11:46:27 +02001405{
Kevin Wolf999e6b62018-10-25 14:18:58 +01001406 RawPosixAIOData *aiocb = opaque;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001407 ssize_t nbytes;
1408 char *buf;
1409
1410 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1411 /*
1412 * If there is just a single buffer, and it is properly aligned
1413 * we can just use plain pread/pwrite without any problems.
1414 */
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001415 if (aiocb->io.niov == 1) {
Kevin Wolf54c7ca12018-10-31 09:43:17 +01001416 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
1417 goto out;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001418 }
1419 /*
1420 * We have more than one iovec, and all are properly aligned.
1421 *
1422 * Try preadv/pwritev first and fall back to linearizing the
1423 * buffer if it's not supported.
1424 */
1425 if (preadv_present) {
1426 nbytes = handle_aiocb_rw_vector(aiocb);
1427 if (nbytes == aiocb->aio_nbytes ||
1428 (nbytes < 0 && nbytes != -ENOSYS)) {
Kevin Wolf54c7ca12018-10-31 09:43:17 +01001429 goto out;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001430 }
1431 preadv_present = false;
1432 }
1433
1434 /*
1435 * XXX(hch): short read/write. no easy way to handle the reminder
1436 * using these interfaces. For now retry using plain
1437 * pread/pwrite?
1438 */
1439 }
1440
1441 /*
1442 * Ok, we have to do it the hard way, copy all segments into
1443 * a single aligned buffer.
1444 */
Kevin Wolf50d4a852014-05-21 18:02:42 +02001445 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1446 if (buf == NULL) {
Kevin Wolf54c7ca12018-10-31 09:43:17 +01001447 nbytes = -ENOMEM;
1448 goto out;
Kevin Wolf50d4a852014-05-21 18:02:42 +02001449 }
1450
Paolo Bonzinide81a162012-05-25 11:46:27 +02001451 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1452 char *p = buf;
1453 int i;
1454
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001455 for (i = 0; i < aiocb->io.niov; ++i) {
1456 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1457 p += aiocb->io.iov[i].iov_len;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001458 }
Kevin Wolf8eb029c2014-07-01 16:09:54 +02001459 assert(p - buf == aiocb->aio_nbytes);
Paolo Bonzinide81a162012-05-25 11:46:27 +02001460 }
1461
1462 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1463 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1464 char *p = buf;
1465 size_t count = aiocb->aio_nbytes, copy;
1466 int i;
1467
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001468 for (i = 0; i < aiocb->io.niov && count; ++i) {
Paolo Bonzinide81a162012-05-25 11:46:27 +02001469 copy = count;
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001470 if (copy > aiocb->io.iov[i].iov_len) {
1471 copy = aiocb->io.iov[i].iov_len;
Paolo Bonzinide81a162012-05-25 11:46:27 +02001472 }
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001473 memcpy(aiocb->io.iov[i].iov_base, p, copy);
Kevin Wolf8eb029c2014-07-01 16:09:54 +02001474 assert(count >= copy);
Paolo Bonzinide81a162012-05-25 11:46:27 +02001475 p += copy;
1476 count -= copy;
1477 }
Kevin Wolf8eb029c2014-07-01 16:09:54 +02001478 assert(count == 0);
Paolo Bonzinide81a162012-05-25 11:46:27 +02001479 }
1480 qemu_vfree(buf);
1481
Kevin Wolf54c7ca12018-10-31 09:43:17 +01001482out:
1483 if (nbytes == aiocb->aio_nbytes) {
1484 return 0;
1485 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) {
1486 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1487 return -EINVAL;
1488 } else {
1489 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes,
1490 0, aiocb->aio_nbytes - nbytes);
1491 return 0;
1492 }
1493 } else {
1494 assert(nbytes < 0);
1495 return nbytes;
1496 }
Paolo Bonzinide81a162012-05-25 11:46:27 +02001497}
1498
Denis V. Lunev1486df02015-01-30 11:42:11 +03001499static int translate_err(int err)
1500{
1501 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1502 err == -ENOTTY) {
1503 err = -ENOTSUP;
1504 }
1505 return err;
1506}
1507
Denis V. Lunevd50d8222015-01-30 11:42:15 +03001508#ifdef CONFIG_FALLOCATE
Denis V. Lunev0b991712015-01-30 11:42:12 +03001509static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1510{
1511 do {
1512 if (fallocate(fd, mode, offset, len) == 0) {
1513 return 0;
1514 }
1515 } while (errno == EINTR);
1516 return translate_err(-errno);
1517}
1518#endif
1519
Denis V. Lunev37cc9f72015-01-30 11:42:13 +03001520static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
Paolo Bonzini97a2ae32013-11-22 13:39:57 +01001521{
Denis V. Lunev37cc9f72015-01-30 11:42:13 +03001522 int ret = -ENOTSUP;
Paolo Bonzini97a2ae32013-11-22 13:39:57 +01001523 BDRVRawState *s = aiocb->bs->opaque;
1524
Denis V. Lunev37cc9f72015-01-30 11:42:13 +03001525 if (!s->has_write_zeroes) {
Paolo Bonzini97a2ae32013-11-22 13:39:57 +01001526 return -ENOTSUP;
1527 }
1528
Paolo Bonzini97a2ae32013-11-22 13:39:57 +01001529#ifdef BLKZEROOUT
Kevin Wolf738301e2019-03-22 13:45:23 +01001530 /* The BLKZEROOUT implementation in the kernel doesn't set
1531 * BLKDEV_ZERO_NOFALLBACK, so we can't call this if we have to avoid slow
1532 * fallbacks. */
1533 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) {
1534 do {
1535 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1536 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1537 return 0;
1538 }
1539 } while (errno == EINTR);
Paolo Bonzini97a2ae32013-11-22 13:39:57 +01001540
Kevin Wolf738301e2019-03-22 13:45:23 +01001541 ret = translate_err(-errno);
Kevin Wolfeffecce2019-08-16 11:48:17 +02001542 if (ret == -ENOTSUP) {
1543 s->has_write_zeroes = false;
1544 }
Kevin Wolf738301e2019-03-22 13:45:23 +01001545 }
Denis V. Lunev37cc9f72015-01-30 11:42:13 +03001546#endif
1547
Paolo Bonzini97a2ae32013-11-22 13:39:57 +01001548 return ret;
1549}
1550
Kevin Wolf7154d8a2018-10-25 14:18:58 +01001551static int handle_aiocb_write_zeroes(void *opaque)
Denis V. Lunev37cc9f72015-01-30 11:42:13 +03001552{
Kevin Wolf7154d8a2018-10-25 14:18:58 +01001553 RawPosixAIOData *aiocb = opaque;
Denis V. Lunev70d91102017-08-04 18:10:11 +03001554#ifdef CONFIG_FALLOCATE
Max Reitzb2c6f232019-08-23 15:03:40 +02001555 BDRVRawState *s = aiocb->bs->opaque;
Denis V. Lunev70d91102017-08-04 18:10:11 +03001556 int64_t len;
1557#endif
Denis V. Lunev37cc9f72015-01-30 11:42:13 +03001558
1559 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1560 return handle_aiocb_write_zeroes_block(aiocb);
1561 }
1562
Denis V. Lunevb953f072015-01-30 11:42:14 +03001563#ifdef CONFIG_FALLOCATE_ZERO_RANGE
1564 if (s->has_write_zeroes) {
1565 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1566 aiocb->aio_offset, aiocb->aio_nbytes);
Andrey Shinkevich294682c2019-08-27 16:52:53 +03001567 if (ret == -EINVAL) {
1568 /*
1569 * Allow falling back to pwrite for file systems that
1570 * do not support fallocate() for an unaligned byte range.
1571 */
1572 return -ENOTSUP;
1573 }
Denis V. Lunevb953f072015-01-30 11:42:14 +03001574 if (ret == 0 || ret != -ENOTSUP) {
1575 return ret;
1576 }
1577 s->has_write_zeroes = false;
1578 }
1579#endif
1580
Denis V. Lunev1cdc3232015-01-30 11:42:16 +03001581#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1582 if (s->has_discard && s->has_fallocate) {
1583 int ret = do_fallocate(s->fd,
1584 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1585 aiocb->aio_offset, aiocb->aio_nbytes);
1586 if (ret == 0) {
1587 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1588 if (ret == 0 || ret != -ENOTSUP) {
1589 return ret;
1590 }
1591 s->has_fallocate = false;
1592 } else if (ret != -ENOTSUP) {
1593 return ret;
1594 } else {
1595 s->has_discard = false;
1596 }
1597 }
1598#endif
1599
Denis V. Lunevd50d8222015-01-30 11:42:15 +03001600#ifdef CONFIG_FALLOCATE
Denis V. Lunev70d91102017-08-04 18:10:11 +03001601 /* Last resort: we are trying to extend the file with zeroed data. This
1602 * can be done via fallocate(fd, 0) */
1603 len = bdrv_getlength(aiocb->bs);
1604 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
Denis V. Lunevd50d8222015-01-30 11:42:15 +03001605 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1606 if (ret == 0 || ret != -ENOTSUP) {
1607 return ret;
1608 }
1609 s->has_fallocate = false;
1610 }
1611#endif
1612
Denis V. Lunev37cc9f72015-01-30 11:42:13 +03001613 return -ENOTSUP;
1614}
1615
Kevin Wolf7154d8a2018-10-25 14:18:58 +01001616static int handle_aiocb_write_zeroes_unmap(void *opaque)
Kevin Wolf34fa1102018-07-26 11:28:30 +02001617{
Kevin Wolf7154d8a2018-10-25 14:18:58 +01001618 RawPosixAIOData *aiocb = opaque;
Kevin Wolf34fa1102018-07-26 11:28:30 +02001619 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
Kevin Wolf34fa1102018-07-26 11:28:30 +02001620
1621 /* First try to write zeros and unmap at the same time */
1622
1623#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
Simran Singhalb3ac2b92020-04-01 22:23:14 +05301624 int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1625 aiocb->aio_offset, aiocb->aio_nbytes);
Kevin Wolf34fa1102018-07-26 11:28:30 +02001626 if (ret != -ENOTSUP) {
1627 return ret;
1628 }
1629#endif
1630
Kevin Wolf34fa1102018-07-26 11:28:30 +02001631 /* If we couldn't manage to unmap while guaranteed that the area reads as
1632 * all-zero afterwards, just write zeroes without unmapping */
Simran Singhalb3ac2b92020-04-01 22:23:14 +05301633 return handle_aiocb_write_zeroes(aiocb);
Kevin Wolf34fa1102018-07-26 11:28:30 +02001634}
1635
Fam Zheng1efad062018-06-01 17:26:43 +08001636#ifndef HAVE_COPY_FILE_RANGE
1637static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1638 off_t *out_off, size_t len, unsigned int flags)
1639{
1640#ifdef __NR_copy_file_range
1641 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1642 out_off, len, flags);
1643#else
1644 errno = ENOSYS;
1645 return -1;
1646#endif
1647}
1648#endif
1649
Kevin Wolf58a209c2018-10-25 14:18:58 +01001650static int handle_aiocb_copy_range(void *opaque)
Fam Zheng1efad062018-06-01 17:26:43 +08001651{
Kevin Wolf58a209c2018-10-25 14:18:58 +01001652 RawPosixAIOData *aiocb = opaque;
Fam Zheng1efad062018-06-01 17:26:43 +08001653 uint64_t bytes = aiocb->aio_nbytes;
1654 off_t in_off = aiocb->aio_offset;
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001655 off_t out_off = aiocb->copy_range.aio_offset2;
Fam Zheng1efad062018-06-01 17:26:43 +08001656
1657 while (bytes) {
1658 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001659 aiocb->copy_range.aio_fd2, &out_off,
Fam Zheng1efad062018-06-01 17:26:43 +08001660 bytes, 0);
Fam Zhengecc983a2018-07-10 14:31:16 +08001661 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001662 aiocb->copy_range.aio_fd2, out_off, bytes,
1663 0, ret);
Fam Zhengc436e3d2018-06-29 14:03:28 +08001664 if (ret == 0) {
1665 /* No progress (e.g. when beyond EOF), let the caller fall back to
1666 * buffer I/O. */
1667 return -ENOSPC;
Fam Zheng1efad062018-06-01 17:26:43 +08001668 }
1669 if (ret < 0) {
Fam Zhengc436e3d2018-06-29 14:03:28 +08001670 switch (errno) {
1671 case ENOSYS:
Fam Zheng1efad062018-06-01 17:26:43 +08001672 return -ENOTSUP;
Fam Zhengc436e3d2018-06-29 14:03:28 +08001673 case EINTR:
1674 continue;
1675 default:
Fam Zheng1efad062018-06-01 17:26:43 +08001676 return -errno;
1677 }
1678 }
Fam Zheng1efad062018-06-01 17:26:43 +08001679 bytes -= ret;
1680 }
1681 return 0;
1682}
1683
Kevin Wolf46ee0f42018-10-25 14:18:58 +01001684static int handle_aiocb_discard(void *opaque)
Paolo Bonzini82380102013-01-14 16:26:55 +01001685{
Kevin Wolf46ee0f42018-10-25 14:18:58 +01001686 RawPosixAIOData *aiocb = opaque;
Paolo Bonzini82380102013-01-14 16:26:55 +01001687 int ret = -EOPNOTSUPP;
1688 BDRVRawState *s = aiocb->bs->opaque;
1689
Paolo Bonzini7ce21012013-11-22 13:39:47 +01001690 if (!s->has_discard) {
1691 return -ENOTSUP;
Paolo Bonzini82380102013-01-14 16:26:55 +01001692 }
1693
1694 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1695#ifdef BLKDISCARD
1696 do {
1697 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1698 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1699 return 0;
1700 }
1701 } while (errno == EINTR);
1702
1703 ret = -errno;
1704#endif
1705 } else {
Paolo Bonzini82380102013-01-14 16:26:55 +01001706#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
Denis V. Lunev0b991712015-01-30 11:42:12 +03001707 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1708 aiocb->aio_offset, aiocb->aio_nbytes);
Paolo Bonzini82380102013-01-14 16:26:55 +01001709#endif
1710 }
1711
Denis V. Lunev1486df02015-01-30 11:42:11 +03001712 ret = translate_err(ret);
1713 if (ret == -ENOTSUP) {
Paolo Bonzini7ce21012013-11-22 13:39:47 +01001714 s->has_discard = false;
Paolo Bonzini82380102013-01-14 16:26:55 +01001715 }
1716 return ret;
1717}
1718
Nir Soffer3a200132019-08-27 04:05:27 +03001719/*
1720 * Help alignment probing by allocating the first block.
1721 *
1722 * When reading with direct I/O from unallocated area on Gluster backed by XFS,
1723 * reading succeeds regardless of request length. In this case we fallback to
1724 * safe alignment which is not optimal. Allocating the first block avoids this
1725 * fallback.
1726 *
1727 * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
1728 * request alignment, so we use safe values.
1729 *
1730 * Returns: 0 on success, -errno on failure. Since this is an optimization,
1731 * caller may ignore failures.
1732 */
1733static int allocate_first_block(int fd, size_t max_size)
1734{
1735 size_t write_size = (max_size < MAX_BLOCKSIZE)
1736 ? BDRV_SECTOR_SIZE
1737 : MAX_BLOCKSIZE;
Wei Yang038adc22019-10-13 10:11:45 +08001738 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size);
Nir Soffer3a200132019-08-27 04:05:27 +03001739 void *buf;
1740 ssize_t n;
1741 int ret;
1742
1743 buf = qemu_memalign(max_align, write_size);
1744 memset(buf, 0, write_size);
1745
1746 do {
1747 n = pwrite(fd, buf, write_size, 0);
1748 } while (n == -1 && errno == EINTR);
1749
1750 ret = (n == -1) ? -errno : 0;
1751
1752 qemu_vfree(buf);
1753 return ret;
1754}
1755
Kevin Wolf29cb4c02018-10-25 14:18:58 +01001756static int handle_aiocb_truncate(void *opaque)
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001757{
Kevin Wolf29cb4c02018-10-25 14:18:58 +01001758 RawPosixAIOData *aiocb = opaque;
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001759 int result = 0;
1760 int64_t current_length = 0;
1761 char *buf = NULL;
1762 struct stat st;
1763 int fd = aiocb->aio_fildes;
1764 int64_t offset = aiocb->aio_offset;
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001765 PreallocMode prealloc = aiocb->truncate.prealloc;
1766 Error **errp = aiocb->truncate.errp;
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001767
1768 if (fstat(fd, &st) < 0) {
1769 result = -errno;
1770 error_setg_errno(errp, -result, "Could not stat file");
1771 return result;
1772 }
1773
1774 current_length = st.st_size;
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001775 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001776 error_setg(errp, "Cannot use preallocation for shrinking files");
1777 return -ENOTSUP;
1778 }
1779
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001780 switch (prealloc) {
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001781#ifdef CONFIG_POSIX_FALLOCATE
1782 case PREALLOC_MODE_FALLOC:
1783 /*
1784 * Truncating before posix_fallocate() makes it about twice slower on
1785 * file systems that do not support fallocate(), trying to check if a
1786 * block is allocated before allocating it, so don't do that here.
1787 */
1788 if (offset != current_length) {
1789 result = -posix_fallocate(fd, current_length,
1790 offset - current_length);
1791 if (result != 0) {
1792 /* posix_fallocate() doesn't set errno. */
1793 error_setg_errno(errp, -result,
1794 "Could not preallocate new data");
Nir Soffer3a200132019-08-27 04:05:27 +03001795 } else if (current_length == 0) {
1796 /*
1797 * posix_fallocate() uses fallocate() if the filesystem
1798 * supports it, or fallback to manually writing zeroes. If
1799 * fallocate() was used, unaligned reads from the fallocated
1800 * area in raw_probe_alignment() will succeed, hence we need to
1801 * allocate the first block.
1802 *
1803 * Optimize future alignment probing; ignore failures.
1804 */
1805 allocate_first_block(fd, offset);
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001806 }
1807 } else {
1808 result = 0;
1809 }
1810 goto out;
1811#endif
1812 case PREALLOC_MODE_FULL:
1813 {
1814 int64_t num = 0, left = offset - current_length;
1815 off_t seek_result;
1816
1817 /*
1818 * Knowing the final size from the beginning could allow the file
1819 * system driver to do less allocations and possibly avoid
1820 * fragmentation of the file.
1821 */
1822 if (ftruncate(fd, offset) != 0) {
1823 result = -errno;
1824 error_setg_errno(errp, -result, "Could not resize file");
1825 goto out;
1826 }
1827
1828 buf = g_malloc0(65536);
1829
1830 seek_result = lseek(fd, current_length, SEEK_SET);
1831 if (seek_result < 0) {
1832 result = -errno;
1833 error_setg_errno(errp, -result,
1834 "Failed to seek to the old end of file");
1835 goto out;
1836 }
1837
1838 while (left > 0) {
1839 num = MIN(left, 65536);
1840 result = write(fd, buf, num);
1841 if (result < 0) {
Fam Zhenga1c81f42018-07-27 14:53:14 +08001842 if (errno == EINTR) {
1843 continue;
1844 }
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001845 result = -errno;
1846 error_setg_errno(errp, -result,
1847 "Could not write zeros for preallocation");
1848 goto out;
1849 }
1850 left -= result;
1851 }
1852 if (result >= 0) {
1853 result = fsync(fd);
1854 if (result < 0) {
1855 result = -errno;
1856 error_setg_errno(errp, -result,
1857 "Could not flush file to disk");
1858 goto out;
1859 }
1860 }
1861 goto out;
1862 }
1863 case PREALLOC_MODE_OFF:
1864 if (ftruncate(fd, offset) != 0) {
1865 result = -errno;
1866 error_setg_errno(errp, -result, "Could not resize file");
Nir Soffer3a200132019-08-27 04:05:27 +03001867 } else if (current_length == 0 && offset > current_length) {
1868 /* Optimize future alignment probing; ignore failures. */
1869 allocate_first_block(fd, offset);
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001870 }
1871 return result;
1872 default:
1873 result = -ENOTSUP;
1874 error_setg(errp, "Unsupported preallocation mode: %s",
Kevin Wolfd57c44d2018-10-25 16:21:14 +01001875 PreallocMode_str(prealloc));
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02001876 return result;
1877 }
1878
1879out:
1880 if (result < 0) {
1881 if (ftruncate(fd, current_length) < 0) {
1882 error_report("Failed to restore old file length: %s",
1883 strerror(errno));
1884 }
1885 }
1886
1887 g_free(buf);
1888 return result;
1889}
1890
Kevin Wolf5d5de252018-10-26 16:53:47 +01001891static int coroutine_fn raw_thread_pool_submit(BlockDriverState *bs,
1892 ThreadPoolFunc func, void *arg)
1893{
1894 /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
1895 ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1896 return thread_pool_submit_co(pool, func, arg);
1897}
1898
Kevin Wolf9d52aa32016-06-03 17:36:27 +02001899static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
1900 uint64_t bytes, QEMUIOVector *qiov, int type)
bellard83f64092006-08-01 16:21:11 +00001901{
pbrookce1a14d2006-08-07 02:38:06 +00001902 BDRVRawState *s = bs->opaque;
Kevin Wolf999e6b62018-10-25 14:18:58 +01001903 RawPosixAIOData acb;
bellard83f64092006-08-01 16:21:11 +00001904
bellard19cb3732006-08-19 11:45:59 +00001905 if (fd_open(bs) < 0)
Kevin Wolf2174f122014-08-06 17:18:07 +02001906 return -EIO;
bellard19cb3732006-08-19 11:45:59 +00001907
aliguorif141eaf2009-04-07 18:43:24 +00001908 /*
Aarushi Mehtac6447512020-01-20 14:18:51 +00001909 * When using O_DIRECT, the request must be aligned to be able to use
1910 * either libaio or io_uring interface. If not fail back to regular thread
1911 * pool read/write code which emulates this for us if we
1912 * set QEMU_AIO_MISALIGNED.
aliguorif141eaf2009-04-07 18:43:24 +00001913 */
Aarushi Mehtac6447512020-01-20 14:18:51 +00001914 if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) {
1915 type |= QEMU_AIO_MISALIGNED;
1916#ifdef CONFIG_LINUX_IO_URING
1917 } else if (s->use_linux_io_uring) {
1918 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
1919 assert(qiov->size == bytes);
1920 return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
Stefan Weile44bd6f2009-08-28 14:39:31 +02001921#endif
Aarushi Mehtac6447512020-01-20 14:18:51 +00001922#ifdef CONFIG_LINUX_AIO
1923 } else if (s->use_linux_aio) {
1924 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1925 assert(qiov->size == bytes);
1926 return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
1927#endif
Christoph Hellwig9ef91a62009-08-20 16:58:19 +02001928 }
aliguorif141eaf2009-04-07 18:43:24 +00001929
Kevin Wolf999e6b62018-10-25 14:18:58 +01001930 acb = (RawPosixAIOData) {
1931 .bs = bs,
1932 .aio_fildes = s->fd,
1933 .aio_type = type,
1934 .aio_offset = offset,
1935 .aio_nbytes = bytes,
1936 .io = {
1937 .iov = qiov->iov,
1938 .niov = qiov->niov,
1939 },
1940 };
1941
1942 assert(qiov->size == bytes);
1943 return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
Kevin Wolf2174f122014-08-06 17:18:07 +02001944}
1945
Kevin Wolf9d52aa32016-06-03 17:36:27 +02001946static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
1947 uint64_t bytes, QEMUIOVector *qiov,
1948 int flags)
Kevin Wolf2174f122014-08-06 17:18:07 +02001949{
Kevin Wolf9d52aa32016-06-03 17:36:27 +02001950 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
Kevin Wolf2174f122014-08-06 17:18:07 +02001951}
1952
Kevin Wolf9d52aa32016-06-03 17:36:27 +02001953static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
1954 uint64_t bytes, QEMUIOVector *qiov,
1955 int flags)
Kevin Wolf2174f122014-08-06 17:18:07 +02001956{
Kevin Wolf9d52aa32016-06-03 17:36:27 +02001957 assert(flags == 0);
1958 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
bellard83f64092006-08-01 16:21:11 +00001959}
1960
Ming Lei1b3abdc2014-07-04 18:04:34 +08001961static void raw_aio_plug(BlockDriverState *bs)
1962{
Aarushi Mehtac6447512020-01-20 14:18:51 +00001963 BDRVRawState __attribute__((unused)) *s = bs->opaque;
Ming Lei1b3abdc2014-07-04 18:04:34 +08001964#ifdef CONFIG_LINUX_AIO
Kevin Wolf0a4279d2016-09-08 15:09:01 +02001965 if (s->use_linux_aio) {
Paolo Bonzini0187f5c2016-07-04 18:33:20 +02001966 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1967 laio_io_plug(bs, aio);
Ming Lei1b3abdc2014-07-04 18:04:34 +08001968 }
1969#endif
Aarushi Mehtac6447512020-01-20 14:18:51 +00001970#ifdef CONFIG_LINUX_IO_URING
1971 if (s->use_linux_io_uring) {
1972 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
1973 luring_io_plug(bs, aio);
1974 }
1975#endif
Ming Lei1b3abdc2014-07-04 18:04:34 +08001976}
1977
1978static void raw_aio_unplug(BlockDriverState *bs)
1979{
Aarushi Mehtac6447512020-01-20 14:18:51 +00001980 BDRVRawState __attribute__((unused)) *s = bs->opaque;
Ming Lei1b3abdc2014-07-04 18:04:34 +08001981#ifdef CONFIG_LINUX_AIO
Kevin Wolf0a4279d2016-09-08 15:09:01 +02001982 if (s->use_linux_aio) {
Paolo Bonzini0187f5c2016-07-04 18:33:20 +02001983 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1984 laio_io_unplug(bs, aio);
Ming Lei1b3abdc2014-07-04 18:04:34 +08001985 }
1986#endif
Aarushi Mehtac6447512020-01-20 14:18:51 +00001987#ifdef CONFIG_LINUX_IO_URING
1988 if (s->use_linux_io_uring) {
1989 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
1990 luring_io_unplug(bs, aio);
1991 }
1992#endif
Ming Lei1b3abdc2014-07-04 18:04:34 +08001993}
1994
Kevin Wolf33d70fb2018-06-21 19:07:32 +02001995static int raw_co_flush_to_disk(BlockDriverState *bs)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02001996{
1997 BDRVRawState *s = bs->opaque;
Kevin Wolf06dc9bd2018-10-25 14:18:58 +01001998 RawPosixAIOData acb;
Kevin Wolf33d70fb2018-06-21 19:07:32 +02001999 int ret;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02002000
Kevin Wolf33d70fb2018-06-21 19:07:32 +02002001 ret = fd_open(bs);
2002 if (ret < 0) {
2003 return ret;
2004 }
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02002005
Kevin Wolf06dc9bd2018-10-25 14:18:58 +01002006 acb = (RawPosixAIOData) {
2007 .bs = bs,
2008 .aio_fildes = s->fd,
2009 .aio_type = QEMU_AIO_FLUSH,
2010 };
2011
Aarushi Mehtac6447512020-01-20 14:18:51 +00002012#ifdef CONFIG_LINUX_IO_URING
2013 if (s->use_linux_io_uring) {
2014 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2015 return luring_co_submit(bs, aio, s->fd, 0, NULL, QEMU_AIO_FLUSH);
2016 }
2017#endif
Kevin Wolf06dc9bd2018-10-25 14:18:58 +01002018 return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02002019}
2020
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -07002021static void raw_aio_attach_aio_context(BlockDriverState *bs,
2022 AioContext *new_context)
2023{
Aarushi Mehtac6447512020-01-20 14:18:51 +00002024 BDRVRawState __attribute__((unused)) *s = bs->opaque;
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -07002025#ifdef CONFIG_LINUX_AIO
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -07002026 if (s->use_linux_aio) {
Markus Armbrustercb091042019-11-30 20:42:22 +01002027 Error *local_err = NULL;
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -07002028 if (!aio_setup_linux_aio(new_context, &local_err)) {
2029 error_reportf_err(local_err, "Unable to use native AIO, "
2030 "falling back to thread pool: ");
2031 s->use_linux_aio = false;
2032 }
2033 }
2034#endif
Aarushi Mehtac6447512020-01-20 14:18:51 +00002035#ifdef CONFIG_LINUX_IO_URING
2036 if (s->use_linux_io_uring) {
2037 Error *local_err;
2038 if (!aio_setup_linux_io_uring(new_context, &local_err)) {
2039 error_reportf_err(local_err, "Unable to use linux io_uring, "
2040 "falling back to thread pool: ");
2041 s->use_linux_io_uring = false;
2042 }
2043 }
2044#endif
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -07002045}
2046
bellard83f64092006-08-01 16:21:11 +00002047static void raw_close(BlockDriverState *bs)
2048{
2049 BDRVRawState *s = bs->opaque;
Stefan Hajnoczic2f34262014-05-08 16:34:47 +02002050
bellard19cb3732006-08-19 11:45:59 +00002051 if (s->fd >= 0) {
Corey Bryant2e1e79d2012-08-14 16:43:46 -04002052 qemu_close(s->fd);
bellard19cb3732006-08-19 11:45:59 +00002053 s->fd = -1;
2054 }
bellard83f64092006-08-01 16:21:11 +00002055}
2056
Max Reitzd0bc9e52017-06-13 22:20:58 +02002057/**
2058 * Truncates the given regular file @fd to @offset and, when growing, fills the
2059 * new space according to @prealloc.
2060 *
2061 * Returns: 0 on success, -errno on failure.
2062 */
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02002063static int coroutine_fn
2064raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2065 PreallocMode prealloc, Error **errp)
Max Reitz9f63b072017-06-13 22:20:57 +02002066{
Kevin Wolf29cb4c02018-10-25 14:18:58 +01002067 RawPosixAIOData acb;
Max Reitzd0bc9e52017-06-13 22:20:58 +02002068
Kevin Wolf29cb4c02018-10-25 14:18:58 +01002069 acb = (RawPosixAIOData) {
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02002070 .bs = bs,
2071 .aio_fildes = fd,
2072 .aio_type = QEMU_AIO_TRUNCATE,
2073 .aio_offset = offset,
Kevin Wolfd57c44d2018-10-25 16:21:14 +01002074 .truncate = {
2075 .prealloc = prealloc,
2076 .errp = errp,
2077 },
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02002078 };
Max Reitzd0bc9e52017-06-13 22:20:58 +02002079
Kevin Wolf29cb4c02018-10-25 14:18:58 +01002080 return raw_thread_pool_submit(bs, handle_aiocb_truncate, &acb);
Max Reitz9f63b072017-06-13 22:20:57 +02002081}
2082
Kevin Wolf061ca8a2018-06-21 17:54:35 +02002083static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
Max Reitzc80d8b02019-09-18 11:51:40 +02002084 bool exact, PreallocMode prealloc,
Kevin Wolf92b92792020-04-24 14:54:39 +02002085 BdrvRequestFlags flags, Error **errp)
bellard83f64092006-08-01 16:21:11 +00002086{
2087 BDRVRawState *s = bs->opaque;
Christoph Hellwig55b949c2011-09-21 01:10:37 +02002088 struct stat st;
Max Reitzf59adb32017-03-28 22:51:29 +02002089 int ret;
Christoph Hellwig55b949c2011-09-21 01:10:37 +02002090
2091 if (fstat(s->fd, &st)) {
Max Reitzf59adb32017-03-28 22:51:29 +02002092 ret = -errno;
2093 error_setg_errno(errp, -ret, "Failed to fstat() the file");
2094 return ret;
Christoph Hellwig55b949c2011-09-21 01:10:37 +02002095 }
2096
2097 if (S_ISREG(st.st_mode)) {
Max Reitz82325ae2019-09-18 11:51:41 +02002098 /* Always resizes to the exact @offset */
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02002099 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
Max Reitz35d72602017-06-13 22:20:59 +02002100 }
2101
2102 if (prealloc != PREALLOC_MODE_OFF) {
2103 error_setg(errp, "Preallocation mode '%s' unsupported for this "
Markus Armbruster977c7362017-08-24 10:46:08 +02002104 "non-regular file", PreallocMode_str(prealloc));
Max Reitz35d72602017-06-13 22:20:59 +02002105 return -ENOTSUP;
2106 }
2107
2108 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
Max Reitz82325ae2019-09-18 11:51:41 +02002109 int64_t cur_length = raw_getlength(bs);
2110
2111 if (offset != cur_length && exact) {
2112 error_setg(errp, "Cannot resize device files");
2113 return -ENOTSUP;
2114 } else if (offset > cur_length) {
Max Reitzf59adb32017-03-28 22:51:29 +02002115 error_setg(errp, "Cannot grow device files");
2116 return -EINVAL;
2117 }
Christoph Hellwig55b949c2011-09-21 01:10:37 +02002118 } else {
Max Reitzf59adb32017-03-28 22:51:29 +02002119 error_setg(errp, "Resizing this file is not supported");
Christoph Hellwig55b949c2011-09-21 01:10:37 +02002120 return -ENOTSUP;
2121 }
2122
bellard83f64092006-08-01 16:21:11 +00002123 return 0;
2124}
2125
blueswir1128ab2f2008-08-15 18:33:42 +00002126#ifdef __OpenBSD__
2127static int64_t raw_getlength(BlockDriverState *bs)
2128{
2129 BDRVRawState *s = bs->opaque;
2130 int fd = s->fd;
2131 struct stat st;
2132
2133 if (fstat(fd, &st))
Markus Armbrusteraa729702014-06-26 13:23:16 +02002134 return -errno;
blueswir1128ab2f2008-08-15 18:33:42 +00002135 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2136 struct disklabel dl;
2137
2138 if (ioctl(fd, DIOCGDINFO, &dl))
Markus Armbrusteraa729702014-06-26 13:23:16 +02002139 return -errno;
blueswir1128ab2f2008-08-15 18:33:42 +00002140 return (uint64_t)dl.d_secsize *
2141 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2142 } else
2143 return st.st_size;
2144}
Christoph Eggerd1f6fd82011-05-23 14:31:17 +02002145#elif defined(__NetBSD__)
2146static int64_t raw_getlength(BlockDriverState *bs)
2147{
2148 BDRVRawState *s = bs->opaque;
2149 int fd = s->fd;
2150 struct stat st;
2151
2152 if (fstat(fd, &st))
Markus Armbrusteraa729702014-06-26 13:23:16 +02002153 return -errno;
Christoph Eggerd1f6fd82011-05-23 14:31:17 +02002154 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2155 struct dkwedge_info dkw;
2156
2157 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2158 return dkw.dkw_size * 512;
2159 } else {
2160 struct disklabel dl;
2161
2162 if (ioctl(fd, DIOCGDINFO, &dl))
Markus Armbrusteraa729702014-06-26 13:23:16 +02002163 return -errno;
Christoph Eggerd1f6fd82011-05-23 14:31:17 +02002164 return (uint64_t)dl.d_secsize *
2165 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2166 }
2167 } else
2168 return st.st_size;
2169}
Christoph Hellwig50779cc2010-04-06 19:13:44 +02002170#elif defined(__sun__)
2171static int64_t raw_getlength(BlockDriverState *bs)
2172{
2173 BDRVRawState *s = bs->opaque;
2174 struct dk_minfo minfo;
2175 int ret;
Markus Armbrusteraa729702014-06-26 13:23:16 +02002176 int64_t size;
Christoph Hellwig50779cc2010-04-06 19:13:44 +02002177
2178 ret = fd_open(bs);
2179 if (ret < 0) {
2180 return ret;
2181 }
2182
2183 /*
2184 * Use the DKIOCGMEDIAINFO ioctl to read the size.
2185 */
2186 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2187 if (ret != -1) {
2188 return minfo.dki_lbsize * minfo.dki_capacity;
2189 }
2190
2191 /*
2192 * There are reports that lseek on some devices fails, but
2193 * irc discussion said that contingency on contingency was overkill.
2194 */
Markus Armbrusteraa729702014-06-26 13:23:16 +02002195 size = lseek(s->fd, 0, SEEK_END);
2196 if (size < 0) {
2197 return -errno;
2198 }
2199 return size;
Christoph Hellwig50779cc2010-04-06 19:13:44 +02002200}
2201#elif defined(CONFIG_BSD)
2202static int64_t raw_getlength(BlockDriverState *bs)
bellard83f64092006-08-01 16:21:11 +00002203{
2204 BDRVRawState *s = bs->opaque;
2205 int fd = s->fd;
2206 int64_t size;
bellard83f64092006-08-01 16:21:11 +00002207 struct stat sb;
Aurelien Jarnoa167ba52009-11-29 18:00:41 +01002208#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
blueswir19f230112009-03-28 08:37:13 +00002209 int reopened = 0;
2210#endif
bellard19cb3732006-08-19 11:45:59 +00002211 int ret;
2212
2213 ret = fd_open(bs);
2214 if (ret < 0)
2215 return ret;
bellard83f64092006-08-01 16:21:11 +00002216
Aurelien Jarnoa167ba52009-11-29 18:00:41 +01002217#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
blueswir19f230112009-03-28 08:37:13 +00002218again:
2219#endif
bellard83f64092006-08-01 16:21:11 +00002220 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2221#ifdef DIOCGMEDIASIZE
Paolo Bonzini7d374352018-12-13 23:37:37 +01002222 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
blueswir1c5e97232009-03-07 20:06:23 +00002223#elif defined(DIOCGPART)
2224 {
2225 struct partinfo pi;
2226 if (ioctl(fd, DIOCGPART, &pi) == 0)
2227 size = pi.media_size;
2228 else
2229 size = 0;
2230 }
2231 if (size == 0)
bellard83f64092006-08-01 16:21:11 +00002232#endif
Pavel Borzenkov83affaa2011-11-10 22:40:06 +04002233#if defined(__APPLE__) && defined(__MACH__)
Programmingkid728dacb2015-01-19 17:12:55 -05002234 {
2235 uint64_t sectors = 0;
2236 uint32_t sector_size = 0;
2237
2238 if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2239 && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2240 size = sectors * sector_size;
2241 } else {
2242 size = lseek(fd, 0LL, SEEK_END);
2243 if (size < 0) {
2244 return -errno;
2245 }
2246 }
2247 }
bellard83f64092006-08-01 16:21:11 +00002248#else
2249 size = lseek(fd, 0LL, SEEK_END);
Markus Armbrusteraa729702014-06-26 13:23:16 +02002250 if (size < 0) {
2251 return -errno;
2252 }
bellard83f64092006-08-01 16:21:11 +00002253#endif
Aurelien Jarnoa167ba52009-11-29 18:00:41 +01002254#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
blueswir19f230112009-03-28 08:37:13 +00002255 switch(s->type) {
2256 case FTYPE_CD:
2257 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2258 if (size == 2048LL * (unsigned)-1)
2259 size = 0;
2260 /* XXX no disc? maybe we need to reopen... */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02002261 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
blueswir19f230112009-03-28 08:37:13 +00002262 reopened = 1;
2263 goto again;
2264 }
2265 }
2266#endif
Christoph Hellwig50779cc2010-04-06 19:13:44 +02002267 } else {
bellard83f64092006-08-01 16:21:11 +00002268 size = lseek(fd, 0, SEEK_END);
Markus Armbrusteraa729702014-06-26 13:23:16 +02002269 if (size < 0) {
2270 return -errno;
2271 }
bellard83f64092006-08-01 16:21:11 +00002272 }
bellard83f64092006-08-01 16:21:11 +00002273 return size;
2274}
Christoph Hellwig50779cc2010-04-06 19:13:44 +02002275#else
2276static int64_t raw_getlength(BlockDriverState *bs)
2277{
2278 BDRVRawState *s = bs->opaque;
2279 int ret;
Markus Armbrusteraa729702014-06-26 13:23:16 +02002280 int64_t size;
Christoph Hellwig50779cc2010-04-06 19:13:44 +02002281
2282 ret = fd_open(bs);
2283 if (ret < 0) {
2284 return ret;
2285 }
2286
Markus Armbrusteraa729702014-06-26 13:23:16 +02002287 size = lseek(s->fd, 0, SEEK_END);
2288 if (size < 0) {
2289 return -errno;
2290 }
2291 return size;
Christoph Hellwig50779cc2010-04-06 19:13:44 +02002292}
blueswir1128ab2f2008-08-15 18:33:42 +00002293#endif
bellard83f64092006-08-01 16:21:11 +00002294
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002295static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
2296{
2297 struct stat st;
2298 BDRVRawState *s = bs->opaque;
2299
2300 if (fstat(s->fd, &st) < 0) {
2301 return -errno;
2302 }
2303 return (int64_t)st.st_blocks * 512;
2304}
2305
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02002306static int coroutine_fn
2307raw_co_create(BlockdevCreateOptions *options, Error **errp)
bellard83f64092006-08-01 16:21:11 +00002308{
Kevin Wolf927f11e2018-01-16 16:04:21 +01002309 BlockdevCreateOptionsFile *file_opts;
Max Reitz7c20c802018-07-04 16:47:51 +02002310 Error *local_err = NULL;
bellard83f64092006-08-01 16:21:11 +00002311 int fd;
Max Reitzd815efc2018-07-04 16:47:50 +02002312 uint64_t perm, shared;
Stefan Weil1e37d052009-07-11 16:43:37 +02002313 int result = 0;
bellard83f64092006-08-01 16:21:11 +00002314
Kevin Wolf927f11e2018-01-16 16:04:21 +01002315 /* Validate options and set default values */
2316 assert(options->driver == BLOCKDEV_DRIVER_FILE);
2317 file_opts = &options->u.file;
Max Reitz464d9f62014-03-05 22:41:38 +01002318
Kevin Wolf927f11e2018-01-16 16:04:21 +01002319 if (!file_opts->has_nocow) {
2320 file_opts->nocow = false;
2321 }
2322 if (!file_opts->has_preallocation) {
2323 file_opts->preallocation = PREALLOC_MODE_OFF;
Hu Tao06247422014-09-10 17:05:48 +08002324 }
bellard83f64092006-08-01 16:21:11 +00002325
Kevin Wolf927f11e2018-01-16 16:04:21 +01002326 /* Create file */
Max Reitzb8cf1912018-05-09 23:53:35 +02002327 fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644);
Stefan Weil1e37d052009-07-11 16:43:37 +02002328 if (fd < 0) {
2329 result = -errno;
Max Reitze428e432013-10-11 11:37:01 +02002330 error_setg_errno(errp, -result, "Could not create file");
Hu Tao06247422014-09-10 17:05:48 +08002331 goto out;
Stefan Weil1e37d052009-07-11 16:43:37 +02002332 }
Hu Tao06247422014-09-10 17:05:48 +08002333
Max Reitzb8cf1912018-05-09 23:53:35 +02002334 /* Take permissions: We want to discard everything, so we need
2335 * BLK_PERM_WRITE; and truncation to the desired size requires
2336 * BLK_PERM_RESIZE.
2337 * On the other hand, we cannot share the RESIZE permission
2338 * because we promise that after this function, the file has the
2339 * size given in the options. If someone else were to resize it
2340 * concurrently, we could not guarantee that.
2341 * Note that after this function, we can no longer guarantee that
2342 * the file is not touched by a third party, so it may be resized
2343 * then. */
2344 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2345 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2346
2347 /* Step one: Take locks */
Fam Zheng2996ffa2018-10-11 15:21:33 +08002348 result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
Max Reitzb8cf1912018-05-09 23:53:35 +02002349 if (result < 0) {
2350 goto out_close;
2351 }
2352
2353 /* Step two: Check that nobody else has taken conflicting locks */
2354 result = raw_check_lock_bytes(fd, perm, shared, errp);
2355 if (result < 0) {
Fam Zhengb8574312018-09-25 13:05:01 +08002356 error_append_hint(errp,
2357 "Is another process using the image [%s]?\n",
2358 file_opts->filename);
Max Reitz7c20c802018-07-04 16:47:51 +02002359 goto out_unlock;
Max Reitzb8cf1912018-05-09 23:53:35 +02002360 }
2361
2362 /* Clear the file by truncating it to 0 */
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02002363 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
Max Reitzb8cf1912018-05-09 23:53:35 +02002364 if (result < 0) {
Max Reitz7c20c802018-07-04 16:47:51 +02002365 goto out_unlock;
Max Reitzb8cf1912018-05-09 23:53:35 +02002366 }
2367
Kevin Wolf927f11e2018-01-16 16:04:21 +01002368 if (file_opts->nocow) {
Hu Tao06247422014-09-10 17:05:48 +08002369#ifdef __linux__
2370 /* Set NOCOW flag to solve performance issue on fs like btrfs.
2371 * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2372 * will be ignored since any failure of this operation should not
2373 * block the left work.
2374 */
2375 int attr;
2376 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2377 attr |= FS_NOCOW_FL;
2378 ioctl(fd, FS_IOC_SETFLAGS, &attr);
2379 }
2380#endif
2381 }
2382
Max Reitzb8cf1912018-05-09 23:53:35 +02002383 /* Resize and potentially preallocate the file to the desired
2384 * final size */
Kevin Wolf93f4e2f2018-06-21 18:23:16 +02002385 result = raw_regular_truncate(NULL, fd, file_opts->size,
2386 file_opts->preallocation, errp);
Max Reitz9f63b072017-06-13 22:20:57 +02002387 if (result < 0) {
Max Reitz7c20c802018-07-04 16:47:51 +02002388 goto out_unlock;
2389 }
2390
2391out_unlock:
Fam Zheng2996ffa2018-10-11 15:21:33 +08002392 raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
Max Reitz7c20c802018-07-04 16:47:51 +02002393 if (local_err) {
2394 /* The above call should not fail, and if it does, that does
2395 * not mean the whole creation operation has failed. So
2396 * report it the user for their convenience, but do not report
2397 * it to the caller. */
Fam Zhengdb0754d2018-11-01 14:29:09 +08002398 warn_report_err(local_err);
Hu Tao06247422014-09-10 17:05:48 +08002399 }
2400
Nir Soffer5a1dad92017-02-17 02:51:26 +02002401out_close:
Hu Tao06247422014-09-10 17:05:48 +08002402 if (qemu_close(fd) != 0 && result == 0) {
2403 result = -errno;
2404 error_setg_errno(errp, -result, "Could not close the new file");
2405 }
2406out:
Stefan Weil1e37d052009-07-11 16:43:37 +02002407 return result;
bellard83f64092006-08-01 16:21:11 +00002408}
2409
Maxim Levitskyb92902d2020-03-26 03:12:17 +02002410static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
2411 const char *filename,
2412 QemuOpts *opts,
Kevin Wolf927f11e2018-01-16 16:04:21 +01002413 Error **errp)
2414{
2415 BlockdevCreateOptions options;
2416 int64_t total_size = 0;
2417 bool nocow = false;
2418 PreallocMode prealloc;
2419 char *buf = NULL;
2420 Error *local_err = NULL;
2421
2422 /* Skip file: protocol prefix */
2423 strstart(filename, "file:", &filename);
2424
2425 /* Read out options */
2426 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2427 BDRV_SECTOR_SIZE);
2428 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2429 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2430 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2431 PREALLOC_MODE_OFF, &local_err);
2432 g_free(buf);
2433 if (local_err) {
2434 error_propagate(errp, local_err);
2435 return -EINVAL;
2436 }
2437
2438 options = (BlockdevCreateOptions) {
2439 .driver = BLOCKDEV_DRIVER_FILE,
2440 .u.file = {
2441 .filename = (char *) filename,
2442 .size = total_size,
2443 .has_preallocation = true,
2444 .preallocation = prealloc,
2445 .has_nocow = true,
2446 .nocow = nocow,
2447 },
2448 };
2449 return raw_co_create(&options, errp);
2450}
2451
Daniel Henrique Barboza9bffae12020-01-30 18:39:04 -03002452static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
2453 Error **errp)
2454{
2455 struct stat st;
2456 int ret;
2457
2458 if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
2459 error_setg_errno(errp, ENOENT, "%s is not a regular file",
2460 bs->filename);
2461 return -ENOENT;
2462 }
2463
2464 ret = unlink(bs->filename);
2465 if (ret < 0) {
2466 ret = -errno;
2467 error_setg_errno(errp, -ret, "Error when deleting file %s",
2468 bs->filename);
2469 }
2470
2471 return ret;
2472}
2473
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002474/*
2475 * Find allocation range in @bs around offset @start.
2476 * May change underlying file descriptor's file offset.
2477 * If @start is not in a hole, store @start in @data, and the
2478 * beginning of the next hole in @hole, and return 0.
2479 * If @start is in a non-trailing hole, store @start in @hole and the
2480 * beginning of the next non-hole in @data, and return 0.
2481 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2482 * If we can't find out, return a negative errno other than -ENXIO.
2483 */
2484static int find_allocation(BlockDriverState *bs, off_t start,
2485 off_t *data, off_t *hole)
Max Reitz4f11aa82014-05-08 20:57:55 +02002486{
2487#if defined SEEK_HOLE && defined SEEK_DATA
2488 BDRVRawState *s = bs->opaque;
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002489 off_t offs;
Max Reitz4f11aa82014-05-08 20:57:55 +02002490
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002491 /*
2492 * SEEK_DATA cases:
2493 * D1. offs == start: start is in data
2494 * D2. offs > start: start is in a hole, next data at offs
2495 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2496 * or start is beyond EOF
2497 * If the latter happens, the file has been truncated behind
2498 * our back since we opened it. All bets are off then.
2499 * Treating like a trailing hole is simplest.
2500 * D4. offs < 0, errno != ENXIO: we learned nothing
2501 */
2502 offs = lseek(s->fd, start, SEEK_DATA);
2503 if (offs < 0) {
2504 return -errno; /* D3 or D4 */
2505 }
Jeff Codya03083a2018-04-03 00:37:26 -04002506
2507 if (offs < start) {
2508 /* This is not a valid return by lseek(). We are safe to just return
2509 * -EIO in this case, and we'll treat it like D4. */
2510 return -EIO;
2511 }
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002512
2513 if (offs > start) {
2514 /* D2: in hole, next data at offs */
2515 *hole = start;
2516 *data = offs;
2517 return 0;
Max Reitz4f11aa82014-05-08 20:57:55 +02002518 }
2519
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002520 /* D1: in data, end not yet known */
2521
2522 /*
2523 * SEEK_HOLE cases:
2524 * H1. offs == start: start is in a hole
2525 * If this happens here, a hole has been dug behind our back
2526 * since the previous lseek().
2527 * H2. offs > start: either start is in data, next hole at offs,
2528 * or start is in trailing hole, EOF at offs
2529 * Linux treats trailing holes like any other hole: offs ==
2530 * start. Solaris seeks to EOF instead: offs > start (blech).
2531 * If that happens here, a hole has been dug behind our back
2532 * since the previous lseek().
2533 * H3. offs < 0, errno = ENXIO: start is beyond EOF
2534 * If this happens, the file has been truncated behind our
2535 * back since we opened it. Treat it like a trailing hole.
2536 * H4. offs < 0, errno != ENXIO: we learned nothing
2537 * Pretend we know nothing at all, i.e. "forget" about D1.
2538 */
2539 offs = lseek(s->fd, start, SEEK_HOLE);
2540 if (offs < 0) {
2541 return -errno; /* D1 and (H3 or H4) */
2542 }
Jeff Codya03083a2018-04-03 00:37:26 -04002543
2544 if (offs < start) {
2545 /* This is not a valid return by lseek(). We are safe to just return
2546 * -EIO in this case, and we'll treat it like H4. */
2547 return -EIO;
2548 }
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002549
2550 if (offs > start) {
2551 /*
2552 * D1 and H2: either in data, next hole at offs, or it was in
2553 * data but is now in a trailing hole. In the latter case,
2554 * all bets are off. Treating it as if it there was data all
2555 * the way to EOF is safe, so simply do that.
2556 */
Max Reitz4f11aa82014-05-08 20:57:55 +02002557 *data = start;
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002558 *hole = offs;
2559 return 0;
Max Reitz4f11aa82014-05-08 20:57:55 +02002560 }
2561
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002562 /* D1 and H1 */
2563 return -EBUSY;
Max Reitz4f11aa82014-05-08 20:57:55 +02002564#else
2565 return -ENOTSUP;
2566#endif
2567}
2568
Paolo Bonzini55003162012-05-09 16:49:58 +02002569/*
Eric Blakea290f082018-02-13 14:26:44 -06002570 * Returns the allocation status of the specified offset.
Paolo Bonzini55003162012-05-09 16:49:58 +02002571 *
Eric Blakea290f082018-02-13 14:26:44 -06002572 * The block layer guarantees 'offset' and 'bytes' are within bounds.
Paolo Bonzini55003162012-05-09 16:49:58 +02002573 *
Eric Blakea290f082018-02-13 14:26:44 -06002574 * 'pnum' is set to the number of bytes (including and immediately following
2575 * the specified offset) that are known to be in the same
Paolo Bonzini55003162012-05-09 16:49:58 +02002576 * allocated/unallocated state.
2577 *
Eric Blakea290f082018-02-13 14:26:44 -06002578 * 'bytes' is the max value 'pnum' should be set to.
Paolo Bonzini55003162012-05-09 16:49:58 +02002579 */
Eric Blakea290f082018-02-13 14:26:44 -06002580static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2581 bool want_zero,
2582 int64_t offset,
2583 int64_t bytes, int64_t *pnum,
2584 int64_t *map,
2585 BlockDriverState **file)
Paolo Bonzini55003162012-05-09 16:49:58 +02002586{
Eric Blakea290f082018-02-13 14:26:44 -06002587 off_t data = 0, hole = 0;
Max Reitzd7f62752014-10-24 12:57:59 +02002588 int ret;
Paolo Bonzini55003162012-05-09 16:49:58 +02002589
Max Reitz9c3db312019-05-15 06:15:40 +02002590 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
2591
Paolo Bonzini55003162012-05-09 16:49:58 +02002592 ret = fd_open(bs);
2593 if (ret < 0) {
2594 return ret;
2595 }
2596
Eric Blakea290f082018-02-13 14:26:44 -06002597 if (!want_zero) {
2598 *pnum = bytes;
2599 *map = offset;
2600 *file = bs;
2601 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
Max Reitze6d7ec32014-10-24 12:57:58 +02002602 }
Kevin Wolf94282e72012-06-19 22:02:51 +00002603
Eric Blakea290f082018-02-13 14:26:44 -06002604 ret = find_allocation(bs, offset, &data, &hole);
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002605 if (ret == -ENXIO) {
2606 /* Trailing hole */
Eric Blakea290f082018-02-13 14:26:44 -06002607 *pnum = bytes;
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002608 ret = BDRV_BLOCK_ZERO;
2609 } else if (ret < 0) {
2610 /* No info available, so pretend there are no holes */
Eric Blakea290f082018-02-13 14:26:44 -06002611 *pnum = bytes;
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002612 ret = BDRV_BLOCK_DATA;
Eric Blakea290f082018-02-13 14:26:44 -06002613 } else if (data == offset) {
2614 /* On a data extent, compute bytes to the end of the extent,
Kevin Wolff4a769a2015-06-09 10:55:08 +02002615 * possibly including a partial sector at EOF. */
Eric Blakea290f082018-02-13 14:26:44 -06002616 *pnum = MIN(bytes, hole - offset);
Max Reitz9c3db312019-05-15 06:15:40 +02002617
2618 /*
2619 * We are not allowed to return partial sectors, though, so
2620 * round up if necessary.
2621 */
2622 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
2623 int64_t file_length = raw_getlength(bs);
2624 if (file_length > 0) {
2625 /* Ignore errors, this is just a safeguard */
2626 assert(hole == file_length);
2627 }
2628 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
2629 }
2630
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002631 ret = BDRV_BLOCK_DATA;
Paolo Bonzini55003162012-05-09 16:49:58 +02002632 } else {
Eric Blakea290f082018-02-13 14:26:44 -06002633 /* On a hole, compute bytes to the beginning of the next extent. */
2634 assert(hole == offset);
2635 *pnum = MIN(bytes, data - offset);
Markus Armbrusterd1f06fe2014-11-17 11:18:34 +01002636 ret = BDRV_BLOCK_ZERO;
Paolo Bonzini55003162012-05-09 16:49:58 +02002637 }
Eric Blakea290f082018-02-13 14:26:44 -06002638 *map = offset;
Fam Zheng02650ac2016-01-26 11:58:51 +08002639 *file = bs;
Eric Blakea290f082018-02-13 14:26:44 -06002640 return ret | BDRV_BLOCK_OFFSET_VALID;
Paolo Bonzini55003162012-05-09 16:49:58 +02002641}
2642
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +01002643#if defined(__linux__)
2644/* Verify that the file is not in the page cache */
2645static void check_cache_dropped(BlockDriverState *bs, Error **errp)
2646{
2647 const size_t window_size = 128 * 1024 * 1024;
2648 BDRVRawState *s = bs->opaque;
2649 void *window = NULL;
2650 size_t length = 0;
2651 unsigned char *vec;
2652 size_t page_size;
2653 off_t offset;
2654 off_t end;
2655
2656 /* mincore(2) page status information requires 1 byte per page */
2657 page_size = sysconf(_SC_PAGESIZE);
2658 vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2659
2660 end = raw_getlength(bs);
2661
2662 for (offset = 0; offset < end; offset += window_size) {
2663 void *new_window;
2664 size_t new_length;
2665 size_t vec_end;
2666 size_t i;
2667 int ret;
2668
2669 /* Unmap previous window if size has changed */
2670 new_length = MIN(end - offset, window_size);
2671 if (new_length != length) {
2672 munmap(window, length);
2673 window = NULL;
2674 length = 0;
2675 }
2676
2677 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2678 s->fd, offset);
2679 if (new_window == MAP_FAILED) {
2680 error_setg_errno(errp, errno, "mmap failed");
2681 break;
2682 }
2683
2684 window = new_window;
2685 length = new_length;
2686
2687 ret = mincore(window, length, vec);
2688 if (ret < 0) {
2689 error_setg_errno(errp, errno, "mincore failed");
2690 break;
2691 }
2692
2693 vec_end = DIV_ROUND_UP(length, page_size);
2694 for (i = 0; i < vec_end; i++) {
2695 if (vec[i] & 0x1) {
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +01002696 break;
2697 }
2698 }
Markus Armbruster77ed9712020-04-22 15:07:07 +02002699 if (i < vec_end) {
2700 error_setg(errp, "page cache still in use!");
2701 break;
2702 }
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +01002703 }
2704
2705 if (window) {
2706 munmap(window, length);
2707 }
2708
2709 g_free(vec);
2710}
2711#endif /* __linux__ */
2712
Stefan Hajnoczidd577a22018-04-27 17:23:11 +01002713static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2714 Error **errp)
2715{
2716 BDRVRawState *s = bs->opaque;
2717 int ret;
2718
2719 ret = fd_open(bs);
2720 if (ret < 0) {
2721 error_setg_errno(errp, -ret, "The file descriptor is not open");
2722 return;
2723 }
2724
Stefan Hajnoczif357fcd2019-03-07 16:49:41 +00002725 if (!s->drop_cache) {
2726 return;
2727 }
2728
Stefan Hajnoczidd577a22018-04-27 17:23:11 +01002729 if (s->open_flags & O_DIRECT) {
2730 return; /* No host kernel page cache */
2731 }
2732
2733#if defined(__linux__)
2734 /* This sets the scene for the next syscall... */
2735 ret = bdrv_co_flush(bs);
2736 if (ret < 0) {
2737 error_setg_errno(errp, -ret, "flush failed");
2738 return;
2739 }
2740
2741 /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2742 * process. These limitations are okay because we just fsynced the file,
2743 * we don't use mmap, and the file should not be in use by other processes.
2744 */
2745 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2746 if (ret != 0) { /* the return value is a positive errno */
2747 error_setg_errno(errp, ret, "fadvise failed");
2748 return;
2749 }
Stefan Hajnoczi31be8a22018-04-27 17:23:12 +01002750
2751 if (s->check_cache_dropped) {
2752 check_cache_dropped(bs, errp);
2753 }
Stefan Hajnoczidd577a22018-04-27 17:23:11 +01002754#else /* __linux__ */
2755 /* Do nothing. Live migration to a remote host with cache.direct=off is
2756 * unsupported on other host operating systems. Cache consistency issues
2757 * may occur but no error is reported here, partly because that's the
2758 * historical behavior and partly because it's hard to differentiate valid
2759 * configurations that should not cause errors.
2760 */
2761#endif /* !__linux__ */
2762}
2763
Anton Nefedov1c450362019-09-23 15:17:36 +03002764static void raw_account_discard(BDRVRawState *s, uint64_t nbytes, int ret)
2765{
2766 if (ret) {
2767 s->stats.discard_nb_failed++;
2768 } else {
2769 s->stats.discard_nb_ok++;
2770 s->stats.discard_bytes_ok += nbytes;
2771 }
2772}
2773
Kevin Wolf33d70fb2018-06-21 19:07:32 +02002774static coroutine_fn int
Kevin Wolf46ee0f42018-10-25 14:18:58 +01002775raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int bytes, bool blkdev)
Christoph Hellwigdce512d2010-12-17 11:41:15 +01002776{
Christoph Hellwigdce512d2010-12-17 11:41:15 +01002777 BDRVRawState *s = bs->opaque;
Kevin Wolf46ee0f42018-10-25 14:18:58 +01002778 RawPosixAIOData acb;
Anton Nefedov1c450362019-09-23 15:17:36 +03002779 int ret;
Christoph Hellwigdce512d2010-12-17 11:41:15 +01002780
Kevin Wolf46ee0f42018-10-25 14:18:58 +01002781 acb = (RawPosixAIOData) {
2782 .bs = bs,
2783 .aio_fildes = s->fd,
2784 .aio_type = QEMU_AIO_DISCARD,
2785 .aio_offset = offset,
2786 .aio_nbytes = bytes,
2787 };
2788
2789 if (blkdev) {
2790 acb.aio_type |= QEMU_AIO_BLKDEV;
2791 }
2792
Anton Nefedov1c450362019-09-23 15:17:36 +03002793 ret = raw_thread_pool_submit(bs, handle_aiocb_discard, &acb);
2794 raw_account_discard(s, bytes, ret);
2795 return ret;
Kevin Wolf46ee0f42018-10-25 14:18:58 +01002796}
2797
2798static coroutine_fn int
2799raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
2800{
2801 return raw_do_pdiscard(bs, offset, bytes, false);
Christoph Hellwigdce512d2010-12-17 11:41:15 +01002802}
Kevin Wolf0e7e1982009-05-18 16:42:10 +02002803
Kevin Wolf7154d8a2018-10-25 14:18:58 +01002804static int coroutine_fn
2805raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
2806 BdrvRequestFlags flags, bool blkdev)
2807{
2808 BDRVRawState *s = bs->opaque;
2809 RawPosixAIOData acb;
2810 ThreadPoolFunc *handler;
2811
Max Reitz292d06b2019-11-01 16:25:10 +01002812#ifdef CONFIG_FALLOCATE
2813 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
2814 BdrvTrackedRequest *req;
2815 uint64_t end;
2816
2817 /*
2818 * This is a workaround for a bug in the Linux XFS driver,
2819 * where writes submitted through the AIO interface will be
2820 * discarded if they happen beyond a concurrently running
2821 * fallocate() that increases the file length (i.e., both the
2822 * write and the fallocate() happen beyond the EOF).
2823 *
2824 * To work around it, we extend the tracked request for this
2825 * zero write until INT64_MAX (effectively infinity), and mark
2826 * it as serializing.
2827 *
2828 * We have to enable this workaround for all filesystems and
2829 * AIO modes (not just XFS with aio=native), because for
2830 * remote filesystems we do not know the host configuration.
2831 */
2832
2833 req = bdrv_co_get_self_request(bs);
2834 assert(req);
2835 assert(req->type == BDRV_TRACKED_WRITE);
2836 assert(req->offset <= offset);
2837 assert(req->offset + req->bytes >= offset + bytes);
2838
2839 end = INT64_MAX & -(uint64_t)bs->bl.request_alignment;
2840 req->bytes = end - req->offset;
2841 req->overlap_bytes = req->bytes;
2842
2843 bdrv_mark_request_serialising(req, bs->bl.request_alignment);
Max Reitz292d06b2019-11-01 16:25:10 +01002844 }
2845#endif
2846
Kevin Wolf7154d8a2018-10-25 14:18:58 +01002847 acb = (RawPosixAIOData) {
2848 .bs = bs,
2849 .aio_fildes = s->fd,
2850 .aio_type = QEMU_AIO_WRITE_ZEROES,
2851 .aio_offset = offset,
2852 .aio_nbytes = bytes,
2853 };
2854
2855 if (blkdev) {
2856 acb.aio_type |= QEMU_AIO_BLKDEV;
2857 }
Kevin Wolf738301e2019-03-22 13:45:23 +01002858 if (flags & BDRV_REQ_NO_FALLBACK) {
2859 acb.aio_type |= QEMU_AIO_NO_FALLBACK;
2860 }
Kevin Wolf7154d8a2018-10-25 14:18:58 +01002861
2862 if (flags & BDRV_REQ_MAY_UNMAP) {
2863 acb.aio_type |= QEMU_AIO_DISCARD;
2864 handler = handle_aiocb_write_zeroes_unmap;
2865 } else {
2866 handler = handle_aiocb_write_zeroes;
2867 }
2868
2869 return raw_thread_pool_submit(bs, handler, &acb);
2870}
2871
Eric Blake2ffa76c2016-06-01 15:10:10 -06002872static int coroutine_fn raw_co_pwrite_zeroes(
2873 BlockDriverState *bs, int64_t offset,
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +03002874 int bytes, BdrvRequestFlags flags)
Paolo Bonzini260a82e2013-11-22 13:39:55 +01002875{
Kevin Wolf7154d8a2018-10-25 14:18:58 +01002876 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
Paolo Bonzini260a82e2013-11-22 13:39:55 +01002877}
2878
2879static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2880{
2881 BDRVRawState *s = bs->opaque;
2882
2883 bdi->unallocated_blocks_are_zero = s->discard_zeroes;
Paolo Bonzini260a82e2013-11-22 13:39:55 +01002884 return 0;
2885}
2886
Anton Nefedovd9245592019-09-23 15:17:37 +03002887static BlockStatsSpecificFile get_blockstats_specific_file(BlockDriverState *bs)
2888{
2889 BDRVRawState *s = bs->opaque;
2890 return (BlockStatsSpecificFile) {
2891 .discard_nb_ok = s->stats.discard_nb_ok,
2892 .discard_nb_failed = s->stats.discard_nb_failed,
2893 .discard_bytes_ok = s->stats.discard_bytes_ok,
2894 };
2895}
2896
2897static BlockStatsSpecific *raw_get_specific_stats(BlockDriverState *bs)
2898{
2899 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
2900
2901 stats->driver = BLOCKDEV_DRIVER_FILE;
2902 stats->u.file = get_blockstats_specific_file(bs);
2903
2904 return stats;
2905}
2906
2907static BlockStatsSpecific *hdev_get_specific_stats(BlockDriverState *bs)
2908{
2909 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
2910
2911 stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE;
2912 stats->u.host_device = get_blockstats_specific_file(bs);
2913
2914 return stats;
2915}
2916
Chunyan Liu6f482f72014-06-05 17:21:01 +08002917static QemuOptsList raw_create_opts = {
2918 .name = "raw-create-opts",
2919 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
2920 .desc = {
2921 {
2922 .name = BLOCK_OPT_SIZE,
2923 .type = QEMU_OPT_SIZE,
2924 .help = "Virtual disk size"
2925 },
Chunyan Liu4ab15592014-06-30 14:29:58 +08002926 {
2927 .name = BLOCK_OPT_NOCOW,
2928 .type = QEMU_OPT_BOOL,
2929 .help = "Turn off copy-on-write (valid only on btrfs)"
2930 },
Hu Tao06247422014-09-10 17:05:48 +08002931 {
2932 .name = BLOCK_OPT_PREALLOC,
2933 .type = QEMU_OPT_STRING,
Stefano Garzarellaabea0052019-05-24 09:58:47 +02002934 .help = "Preallocation mode (allowed values: off"
2935#ifdef CONFIG_POSIX_FALLOCATE
2936 ", falloc"
2937#endif
2938 ", full)"
Hu Tao06247422014-09-10 17:05:48 +08002939 },
Chunyan Liu6f482f72014-06-05 17:21:01 +08002940 { /* end of list */ }
2941 }
Kevin Wolf0e7e1982009-05-18 16:42:10 +02002942};
2943
Fam Zheng244a5662017-05-03 00:35:56 +08002944static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
2945 Error **errp)
2946{
Kevin Wolf6ceabe62019-03-08 15:40:40 +01002947 BDRVRawState *s = bs->opaque;
2948 BDRVRawReopenState *rs = NULL;
2949 int open_flags;
2950 int ret;
2951
2952 if (s->perm_change_fd) {
2953 /*
2954 * In the context of reopen, this function may be called several times
2955 * (directly and recursively while change permissions of the parent).
2956 * This is even true for children that don't inherit from the original
2957 * reopen node, so s->reopen_state is not set.
2958 *
2959 * Ignore all but the first call.
2960 */
2961 return 0;
2962 }
2963
2964 if (s->reopen_state) {
2965 /* We already have a new file descriptor to set permissions for */
2966 assert(s->reopen_state->perm == perm);
2967 assert(s->reopen_state->shared_perm == shared);
2968 rs = s->reopen_state->opaque;
2969 s->perm_change_fd = rs->fd;
Max Reitz094e3632019-05-22 19:03:45 +02002970 s->perm_change_flags = rs->open_flags;
Kevin Wolf6ceabe62019-03-08 15:40:40 +01002971 } else {
2972 /* We may need a new fd if auto-read-only switches the mode */
Kevin Wolf23dece12019-03-01 22:15:11 +01002973 ret = raw_reconfigure_getfd(bs, bs->open_flags, &open_flags, perm,
Kevin Wolf6ceabe62019-03-08 15:40:40 +01002974 false, errp);
2975 if (ret < 0) {
2976 return ret;
2977 } else if (ret != s->fd) {
2978 s->perm_change_fd = ret;
Max Reitz094e3632019-05-22 19:03:45 +02002979 s->perm_change_flags = open_flags;
Kevin Wolf6ceabe62019-03-08 15:40:40 +01002980 }
2981 }
2982
2983 /* Prepare permissions on old fd to avoid conflicts between old and new,
2984 * but keep everything locked that new will need. */
2985 ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
2986 if (ret < 0) {
2987 goto fail;
2988 }
2989
2990 /* Copy locks to the new fd */
2991 if (s->perm_change_fd) {
2992 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
2993 false, errp);
2994 if (ret < 0) {
2995 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
2996 goto fail;
2997 }
2998 }
2999 return 0;
3000
3001fail:
3002 if (s->perm_change_fd && !s->reopen_state) {
3003 qemu_close(s->perm_change_fd);
3004 }
3005 s->perm_change_fd = 0;
3006 return ret;
Fam Zheng244a5662017-05-03 00:35:56 +08003007}
3008
3009static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
3010{
3011 BDRVRawState *s = bs->opaque;
Kevin Wolf6ceabe62019-03-08 15:40:40 +01003012
3013 /* For reopen, we have already switched to the new fd (.bdrv_set_perm is
3014 * called after .bdrv_reopen_commit) */
3015 if (s->perm_change_fd && s->fd != s->perm_change_fd) {
3016 qemu_close(s->fd);
3017 s->fd = s->perm_change_fd;
Max Reitz094e3632019-05-22 19:03:45 +02003018 s->open_flags = s->perm_change_flags;
Kevin Wolf6ceabe62019-03-08 15:40:40 +01003019 }
3020 s->perm_change_fd = 0;
3021
Fam Zheng244a5662017-05-03 00:35:56 +08003022 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
3023 s->perm = perm;
3024 s->shared_perm = shared;
3025}
3026
3027static void raw_abort_perm_update(BlockDriverState *bs)
3028{
Kevin Wolf6ceabe62019-03-08 15:40:40 +01003029 BDRVRawState *s = bs->opaque;
3030
3031 /* For reopen, .bdrv_reopen_abort is called afterwards and will close
3032 * the file descriptor. */
3033 if (s->perm_change_fd && !s->reopen_state) {
3034 qemu_close(s->perm_change_fd);
3035 }
3036 s->perm_change_fd = 0;
3037
Fam Zheng244a5662017-05-03 00:35:56 +08003038 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3039}
3040
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +03003041static int coroutine_fn raw_co_copy_range_from(
3042 BlockDriverState *bs, BdrvChild *src, uint64_t src_offset,
3043 BdrvChild *dst, uint64_t dst_offset, uint64_t bytes,
3044 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
Fam Zheng1efad062018-06-01 17:26:43 +08003045{
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +03003046 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
3047 read_flags, write_flags);
Fam Zheng1efad062018-06-01 17:26:43 +08003048}
3049
3050static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +03003051 BdrvChild *src,
3052 uint64_t src_offset,
3053 BdrvChild *dst,
3054 uint64_t dst_offset,
3055 uint64_t bytes,
3056 BdrvRequestFlags read_flags,
3057 BdrvRequestFlags write_flags)
Fam Zheng1efad062018-06-01 17:26:43 +08003058{
Kevin Wolf58a209c2018-10-25 14:18:58 +01003059 RawPosixAIOData acb;
Fam Zheng1efad062018-06-01 17:26:43 +08003060 BDRVRawState *s = bs->opaque;
3061 BDRVRawState *src_s;
3062
3063 assert(dst->bs == bs);
3064 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
3065 return -ENOTSUP;
3066 }
3067
3068 src_s = src->bs->opaque;
Fam Zheng9f850f62018-07-02 10:58:34 +08003069 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
Fam Zheng1efad062018-06-01 17:26:43 +08003070 return -EIO;
3071 }
Kevin Wolf58a209c2018-10-25 14:18:58 +01003072
3073 acb = (RawPosixAIOData) {
3074 .bs = bs,
3075 .aio_type = QEMU_AIO_COPY_RANGE,
3076 .aio_fildes = src_s->fd,
3077 .aio_offset = src_offset,
3078 .aio_nbytes = bytes,
3079 .copy_range = {
3080 .aio_fd2 = s->fd,
3081 .aio_offset2 = dst_offset,
3082 },
3083 };
3084
3085 return raw_thread_pool_submit(bs, handle_aiocb_copy_range, &acb);
Fam Zheng1efad062018-06-01 17:26:43 +08003086}
3087
Max Reitz5f535a92014-12-02 18:32:41 +01003088BlockDriver bdrv_file = {
Christoph Hellwig84a12e62010-04-07 22:30:24 +02003089 .format_name = "file",
3090 .protocol_name = "file",
blueswir1856ae5c2009-04-07 17:57:09 +00003091 .instance_size = sizeof(BDRVRawState),
BenoƮt Canet030be322013-09-24 17:07:04 +02003092 .bdrv_needs_filename = true,
blueswir1856ae5c2009-04-07 17:57:09 +00003093 .bdrv_probe = NULL, /* no probe for protocols */
Max Reitz078896a2014-03-05 22:41:37 +01003094 .bdrv_parse_filename = raw_parse_filename,
Kevin Wolf66f82ce2010-04-14 14:17:38 +02003095 .bdrv_file_open = raw_open,
Jeff Codyeeb6b452012-09-20 15:13:25 -04003096 .bdrv_reopen_prepare = raw_reopen_prepare,
3097 .bdrv_reopen_commit = raw_reopen_commit,
3098 .bdrv_reopen_abort = raw_reopen_abort,
blueswir1856ae5c2009-04-07 17:57:09 +00003099 .bdrv_close = raw_close,
Kevin Wolf927f11e2018-01-16 16:04:21 +01003100 .bdrv_co_create = raw_co_create,
Stefan Hajnocziefc75e22018-01-18 13:43:45 +01003101 .bdrv_co_create_opts = raw_co_create_opts,
Peter Lieven3ac21622013-06-28 12:47:42 +02003102 .bdrv_has_zero_init = bdrv_has_zero_init_1,
Eric Blakea290f082018-02-13 14:26:44 -06003103 .bdrv_co_block_status = raw_co_block_status,
Stefan Hajnoczidd577a22018-04-27 17:23:11 +01003104 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
Eric Blake2ffa76c2016-06-01 15:10:10 -06003105 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
Daniel Henrique Barboza9bffae12020-01-30 18:39:04 -03003106 .bdrv_co_delete_file = raw_co_delete_file,
ths3b46e622007-09-17 08:09:54 +00003107
Kevin Wolf9d52aa32016-06-03 17:36:27 +02003108 .bdrv_co_preadv = raw_co_preadv,
3109 .bdrv_co_pwritev = raw_co_pwritev,
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003110 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3111 .bdrv_co_pdiscard = raw_co_pdiscard,
Fam Zheng1efad062018-06-01 17:26:43 +08003112 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3113 .bdrv_co_copy_range_to = raw_co_copy_range_to,
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01003114 .bdrv_refresh_limits = raw_refresh_limits,
Ming Lei1b3abdc2014-07-04 18:04:34 +08003115 .bdrv_io_plug = raw_aio_plug,
3116 .bdrv_io_unplug = raw_aio_unplug,
Nishanth Aravamudaned6e2162018-06-22 12:37:00 -07003117 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
aliguori3c529d92008-12-12 16:41:40 +00003118
Kevin Wolf061ca8a2018-06-21 17:54:35 +02003119 .bdrv_co_truncate = raw_co_truncate,
bellard83f64092006-08-01 16:21:11 +00003120 .bdrv_getlength = raw_getlength,
Paolo Bonzini260a82e2013-11-22 13:39:55 +01003121 .bdrv_get_info = raw_get_info,
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003122 .bdrv_get_allocated_file_size
3123 = raw_get_allocated_file_size,
Anton Nefedovd9245592019-09-23 15:17:37 +03003124 .bdrv_get_specific_stats = raw_get_specific_stats,
Fam Zheng244a5662017-05-03 00:35:56 +08003125 .bdrv_check_perm = raw_check_perm,
3126 .bdrv_set_perm = raw_set_perm,
3127 .bdrv_abort_perm_update = raw_abort_perm_update,
Chunyan Liu6f482f72014-06-05 17:21:01 +08003128 .create_opts = &raw_create_opts,
Alberto Garcia8a2ce0b2019-03-12 18:48:48 +02003129 .mutable_opts = mutable_opts,
bellard83f64092006-08-01 16:21:11 +00003130};
3131
bellard19cb3732006-08-19 11:45:59 +00003132/***********************************************/
3133/* host device */
3134
Pavel Borzenkov83affaa2011-11-10 22:40:06 +04003135#if defined(__APPLE__) && defined(__MACH__)
Programmingkid98caa5b2015-11-20 19:17:48 -05003136static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3137 CFIndex maxPathSize, int flags);
Programmingkidd0855f12016-03-21 11:41:28 -04003138static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
bellard19cb3732006-08-19 11:45:59 +00003139{
Programmingkidd0855f12016-03-21 11:41:28 -04003140 kern_return_t kernResult = KERN_FAILURE;
bellard19cb3732006-08-19 11:45:59 +00003141 mach_port_t masterPort;
3142 CFMutableDictionaryRef classesToMatch;
Programmingkidd0855f12016-03-21 11:41:28 -04003143 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3144 char *mediaType = NULL;
bellard19cb3732006-08-19 11:45:59 +00003145
3146 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
3147 if ( KERN_SUCCESS != kernResult ) {
3148 printf( "IOMasterPort returned %d\n", kernResult );
3149 }
ths3b46e622007-09-17 08:09:54 +00003150
Programmingkidd0855f12016-03-21 11:41:28 -04003151 int index;
3152 for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3153 classesToMatch = IOServiceMatching(matching_array[index]);
3154 if (classesToMatch == NULL) {
3155 error_report("IOServiceMatching returned NULL for %s",
3156 matching_array[index]);
3157 continue;
3158 }
3159 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3160 kCFBooleanTrue);
3161 kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
3162 mediaIterator);
3163 if (kernResult != KERN_SUCCESS) {
3164 error_report("Note: IOServiceGetMatchingServices returned %d",
3165 kernResult);
3166 continue;
3167 }
ths3b46e622007-09-17 08:09:54 +00003168
Programmingkidd0855f12016-03-21 11:41:28 -04003169 /* If a match was found, leave the loop */
3170 if (*mediaIterator != 0) {
Laurent Vivier4f7d28d2018-12-13 17:27:26 +01003171 trace_file_FindEjectableOpticalMedia(matching_array[index]);
Programmingkidd0855f12016-03-21 11:41:28 -04003172 mediaType = g_strdup(matching_array[index]);
3173 break;
3174 }
3175 }
3176 return mediaType;
bellard19cb3732006-08-19 11:45:59 +00003177}
3178
Programmingkid98caa5b2015-11-20 19:17:48 -05003179kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3180 CFIndex maxPathSize, int flags)
bellard19cb3732006-08-19 11:45:59 +00003181{
3182 io_object_t nextMedia;
3183 kern_return_t kernResult = KERN_FAILURE;
3184 *bsdPath = '\0';
3185 nextMedia = IOIteratorNext( mediaIterator );
3186 if ( nextMedia )
3187 {
3188 CFTypeRef bsdPathAsCFString;
3189 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3190 if ( bsdPathAsCFString ) {
3191 size_t devPathLength;
3192 strcpy( bsdPath, _PATH_DEV );
Programmingkid98caa5b2015-11-20 19:17:48 -05003193 if (flags & BDRV_O_NOCACHE) {
3194 strcat(bsdPath, "r");
3195 }
bellard19cb3732006-08-19 11:45:59 +00003196 devPathLength = strlen( bsdPath );
3197 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3198 kernResult = KERN_SUCCESS;
3199 }
3200 CFRelease( bsdPathAsCFString );
3201 }
3202 IOObjectRelease( nextMedia );
3203 }
ths3b46e622007-09-17 08:09:54 +00003204
bellard19cb3732006-08-19 11:45:59 +00003205 return kernResult;
3206}
3207
Programmingkidd0855f12016-03-21 11:41:28 -04003208/* Sets up a real cdrom for use in QEMU */
3209static bool setup_cdrom(char *bsd_path, Error **errp)
3210{
3211 int index, num_of_test_partitions = 2, fd;
3212 char test_partition[MAXPATHLEN];
3213 bool partition_found = false;
3214
3215 /* look for a working partition */
3216 for (index = 0; index < num_of_test_partitions; index++) {
3217 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
3218 index);
3219 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE);
3220 if (fd >= 0) {
3221 partition_found = true;
3222 qemu_close(fd);
3223 break;
3224 }
3225 }
3226
3227 /* if a working partition on the device was not found */
3228 if (partition_found == false) {
3229 error_setg(errp, "Failed to find a working partition on disc");
3230 } else {
Laurent Vivier4f7d28d2018-12-13 17:27:26 +01003231 trace_file_setup_cdrom(test_partition);
Programmingkidd0855f12016-03-21 11:41:28 -04003232 pstrcpy(bsd_path, MAXPATHLEN, test_partition);
3233 }
3234 return partition_found;
3235}
3236
3237/* Prints directions on mounting and unmounting a device */
3238static void print_unmounting_directions(const char *file_name)
3239{
3240 error_report("If device %s is mounted on the desktop, unmount"
3241 " it first before using it in QEMU", file_name);
3242 error_report("Command to unmount device: diskutil unmountDisk %s",
3243 file_name);
3244 error_report("Command to mount device: diskutil mountDisk %s", file_name);
3245}
3246
3247#endif /* defined(__APPLE__) && defined(__MACH__) */
bellard19cb3732006-08-19 11:45:59 +00003248
Christoph Hellwig508c7cb2009-06-15 14:04:22 +02003249static int hdev_probe_device(const char *filename)
3250{
3251 struct stat st;
3252
3253 /* allow a dedicated CD-ROM driver to match with a higher priority */
3254 if (strstart(filename, "/dev/cdrom", NULL))
3255 return 50;
3256
3257 if (stat(filename, &st) >= 0 &&
3258 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
3259 return 100;
3260 }
3261
3262 return 0;
3263}
3264
Stefan Hajnoczida888d32013-02-05 12:28:33 +01003265static int check_hdev_writable(BDRVRawState *s)
3266{
3267#if defined(BLKROGET)
3268 /* Linux block devices can be configured "read-only" using blockdev(8).
3269 * This is independent of device node permissions and therefore open(2)
3270 * with O_RDWR succeeds. Actual writes fail with EPERM.
3271 *
3272 * bdrv_open() is supposed to fail if the disk is read-only. Explicitly
3273 * check for read-only block devices so that Linux block devices behave
3274 * properly.
3275 */
3276 struct stat st;
3277 int readonly = 0;
3278
3279 if (fstat(s->fd, &st)) {
3280 return -errno;
3281 }
3282
3283 if (!S_ISBLK(st.st_mode)) {
3284 return 0;
3285 }
3286
3287 if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
3288 return -errno;
3289 }
3290
3291 if (readonly) {
3292 return -EACCES;
3293 }
3294#endif /* defined(BLKROGET) */
3295 return 0;
3296}
3297
Max Reitz7af803d2014-03-08 00:39:41 +01003298static void hdev_parse_filename(const char *filename, QDict *options,
3299 Error **errp)
3300{
Max Reitz03c320d2017-05-22 21:52:16 +02003301 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
Max Reitz7af803d2014-03-08 00:39:41 +01003302}
3303
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +03003304static bool hdev_is_sg(BlockDriverState *bs)
3305{
3306
3307#if defined(__linux__)
3308
Kevin Wolf0d4377b2016-10-20 14:50:12 +02003309 BDRVRawState *s = bs->opaque;
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +03003310 struct stat st;
3311 struct sg_scsi_id scsiid;
3312 int sg_version;
Kevin Wolf0d4377b2016-10-20 14:50:12 +02003313 int ret;
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +03003314
Kevin Wolf0d4377b2016-10-20 14:50:12 +02003315 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
3316 return false;
3317 }
3318
3319 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
3320 if (ret < 0) {
3321 return false;
3322 }
3323
3324 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
3325 if (ret >= 0) {
Laurent Vivier4f7d28d2018-12-13 17:27:26 +01003326 trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +03003327 return true;
3328 }
3329
3330#endif
3331
3332 return false;
3333}
3334
Max Reitz015a1032013-09-05 14:22:29 +02003335static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
3336 Error **errp)
bellard19cb3732006-08-19 11:45:59 +00003337{
3338 BDRVRawState *s = bs->opaque;
Max Reitze428e432013-10-11 11:37:01 +02003339 Error *local_err = NULL;
Stefan Hajnoczida888d32013-02-05 12:28:33 +01003340 int ret;
aliguoria76bab42008-09-22 19:17:18 +00003341
Pavel Borzenkov83affaa2011-11-10 22:40:06 +04003342#if defined(__APPLE__) && defined(__MACH__)
Markus Armbruster129c7d12017-03-30 19:43:12 +02003343 /*
3344 * Caution: while qdict_get_str() is fine, getting non-string types
3345 * would require more care. When @options come from -blockdev or
3346 * blockdev_add, its members are typed according to the QAPI
3347 * schema, but when they come from -drive, they're all QString.
3348 */
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +03003349 const char *filename = qdict_get_str(options, "filename");
Programmingkidd0855f12016-03-21 11:41:28 -04003350 char bsd_path[MAXPATHLEN] = "";
3351 bool error_occurred = false;
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +03003352
Programmingkidd0855f12016-03-21 11:41:28 -04003353 /* If using a real cdrom */
3354 if (strcmp(filename, "/dev/cdrom") == 0) {
3355 char *mediaType = NULL;
3356 kern_return_t ret_val;
3357 io_iterator_t mediaIterator = 0;
ths5fafdf22007-09-16 21:08:06 +00003358
Programmingkidd0855f12016-03-21 11:41:28 -04003359 mediaType = FindEjectableOpticalMedia(&mediaIterator);
3360 if (mediaType == NULL) {
3361 error_setg(errp, "Please make sure your CD/DVD is in the optical"
3362 " drive");
3363 error_occurred = true;
3364 goto hdev_open_Mac_error;
bellard19cb3732006-08-19 11:45:59 +00003365 }
ths3b46e622007-09-17 08:09:54 +00003366
Programmingkidd0855f12016-03-21 11:41:28 -04003367 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
3368 if (ret_val != KERN_SUCCESS) {
3369 error_setg(errp, "Could not get BSD path for optical drive");
3370 error_occurred = true;
3371 goto hdev_open_Mac_error;
3372 }
3373
3374 /* If a real optical drive was not found */
3375 if (bsd_path[0] == '\0') {
3376 error_setg(errp, "Failed to obtain bsd path for optical drive");
3377 error_occurred = true;
3378 goto hdev_open_Mac_error;
3379 }
3380
3381 /* If using a cdrom disc and finding a partition on the disc failed */
3382 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
3383 setup_cdrom(bsd_path, errp) == false) {
3384 print_unmounting_directions(bsd_path);
3385 error_occurred = true;
3386 goto hdev_open_Mac_error;
3387 }
3388
Eric Blake46f5ac22017-04-27 16:58:17 -05003389 qdict_put_str(options, "filename", bsd_path);
Programmingkidd0855f12016-03-21 11:41:28 -04003390
3391hdev_open_Mac_error:
3392 g_free(mediaType);
3393 if (mediaIterator) {
3394 IOObjectRelease(mediaIterator);
3395 }
3396 if (error_occurred) {
3397 return -ENOENT;
3398 }
bellard19cb3732006-08-19 11:45:59 +00003399 }
Programmingkidd0855f12016-03-21 11:41:28 -04003400#endif /* defined(__APPLE__) && defined(__MACH__) */
bellard19cb3732006-08-19 11:45:59 +00003401
3402 s->type = FTYPE_FILE;
Christoph Hellwig90babde2009-06-15 13:53:38 +02003403
John Snow230ff732018-07-10 13:00:40 -04003404 ret = raw_open_common(bs, options, flags, 0, true, &local_err);
Stefan Hajnoczida888d32013-02-05 12:28:33 +01003405 if (ret < 0) {
Eduardo Habkost621ff942016-06-13 18:57:56 -03003406 error_propagate(errp, local_err);
Programmingkidd0855f12016-03-21 11:41:28 -04003407#if defined(__APPLE__) && defined(__MACH__)
3408 if (*bsd_path) {
3409 filename = bsd_path;
3410 }
3411 /* if a physical device experienced an error while being opened */
3412 if (strncmp(filename, "/dev/", 5) == 0) {
3413 print_unmounting_directions(filename);
3414 }
3415#endif /* defined(__APPLE__) && defined(__MACH__) */
Stefan Hajnoczida888d32013-02-05 12:28:33 +01003416 return ret;
3417 }
3418
Dimitris Aragiorgis3307ed72015-06-23 13:45:00 +03003419 /* Since this does ioctl the device must be already opened */
3420 bs->sg = hdev_is_sg(bs);
3421
Stefan Hajnoczida888d32013-02-05 12:28:33 +01003422 if (flags & BDRV_O_RDWR) {
3423 ret = check_hdev_writable(s);
3424 if (ret < 0) {
3425 raw_close(bs);
Max Reitze428e432013-10-11 11:37:01 +02003426 error_setg_errno(errp, -ret, "The device is not writable");
Stefan Hajnoczida888d32013-02-05 12:28:33 +01003427 return ret;
3428 }
3429 }
3430
3431 return ret;
bellard19cb3732006-08-19 11:45:59 +00003432}
3433
aliguori03ff3ca2008-09-15 15:51:35 +00003434#if defined(__linux__)
Kevin Wolf2f3a7ab2018-10-31 11:25:18 +01003435static int coroutine_fn
3436hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
aliguori221f7152009-03-28 17:28:41 +00003437{
aliguorif141eaf2009-04-07 18:43:24 +00003438 BDRVRawState *s = bs->opaque;
Kevin Wolf03425672018-10-31 11:30:42 +01003439 RawPosixAIOData acb;
Kevin Wolf2f3a7ab2018-10-31 11:25:18 +01003440 int ret;
aliguori221f7152009-03-28 17:28:41 +00003441
Kevin Wolf2f3a7ab2018-10-31 11:25:18 +01003442 ret = fd_open(bs);
3443 if (ret < 0) {
3444 return ret;
3445 }
Paolo Bonzinic208e8c2012-11-02 16:14:20 +01003446
Paolo Bonzini7c9e5272017-08-21 18:58:56 +02003447 if (req == SG_IO && s->pr_mgr) {
3448 struct sg_io_hdr *io_hdr = buf;
3449 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
3450 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
3451 return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
Kevin Wolf2f3a7ab2018-10-31 11:25:18 +01003452 s->fd, io_hdr);
Paolo Bonzini7c9e5272017-08-21 18:58:56 +02003453 }
3454 }
3455
Kevin Wolf03425672018-10-31 11:30:42 +01003456 acb = (RawPosixAIOData) {
3457 .bs = bs,
3458 .aio_type = QEMU_AIO_IOCTL,
3459 .aio_fildes = s->fd,
3460 .aio_offset = 0,
3461 .ioctl = {
3462 .buf = buf,
3463 .cmd = req,
3464 },
3465 };
3466
3467 return raw_thread_pool_submit(bs, handle_aiocb_ioctl, &acb);
aliguori221f7152009-03-28 17:28:41 +00003468}
Max Reitzf7096232015-10-19 17:53:07 +02003469#endif /* linux */
aliguori221f7152009-03-28 17:28:41 +00003470
blueswir19f230112009-03-28 08:37:13 +00003471static int fd_open(BlockDriverState *bs)
3472{
3473 BDRVRawState *s = bs->opaque;
3474
3475 /* this is just to ensure s->fd is sane (its called by io ops) */
3476 if (s->fd >= 0)
3477 return 0;
3478 return -EIO;
3479}
bellard19cb3732006-08-19 11:45:59 +00003480
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003481static coroutine_fn int
3482hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
Andreas FƤrberc36dd8a2013-01-18 16:43:35 +01003483{
Anton Nefedov1c450362019-09-23 15:17:36 +03003484 BDRVRawState *s = bs->opaque;
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003485 int ret;
Andreas FƤrberc36dd8a2013-01-18 16:43:35 +01003486
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003487 ret = fd_open(bs);
3488 if (ret < 0) {
Anton Nefedov1c450362019-09-23 15:17:36 +03003489 raw_account_discard(s, bytes, ret);
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003490 return ret;
Andreas FƤrberc36dd8a2013-01-18 16:43:35 +01003491 }
Kevin Wolf46ee0f42018-10-25 14:18:58 +01003492 return raw_do_pdiscard(bs, offset, bytes, true);
Andreas FƤrberc36dd8a2013-01-18 16:43:35 +01003493}
3494
Eric Blake2ffa76c2016-06-01 15:10:10 -06003495static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +03003496 int64_t offset, int bytes, BdrvRequestFlags flags)
Paolo Bonzinid0b45032013-11-22 13:39:56 +01003497{
Paolo Bonzinid0b45032013-11-22 13:39:56 +01003498 int rc;
3499
3500 rc = fd_open(bs);
3501 if (rc < 0) {
3502 return rc;
3503 }
Kevin Wolf34fa1102018-07-26 11:28:30 +02003504
Kevin Wolf7154d8a2018-10-25 14:18:58 +01003505 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
Paolo Bonzinid0b45032013-11-22 13:39:56 +01003506}
3507
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003508static BlockDriver bdrv_host_device = {
Kevin Wolf0b4ce022009-10-01 12:35:49 +02003509 .format_name = "host_device",
Christoph Hellwig84a12e62010-04-07 22:30:24 +02003510 .protocol_name = "host_device",
Kevin Wolf0b4ce022009-10-01 12:35:49 +02003511 .instance_size = sizeof(BDRVRawState),
BenoƮt Canet030be322013-09-24 17:07:04 +02003512 .bdrv_needs_filename = true,
Kevin Wolf0b4ce022009-10-01 12:35:49 +02003513 .bdrv_probe_device = hdev_probe_device,
Max Reitz7af803d2014-03-08 00:39:41 +01003514 .bdrv_parse_filename = hdev_parse_filename,
Kevin Wolf66f82ce2010-04-14 14:17:38 +02003515 .bdrv_file_open = hdev_open,
Kevin Wolf0b4ce022009-10-01 12:35:49 +02003516 .bdrv_close = raw_close,
Jeff Cody1bc6b702012-11-20 10:21:10 -05003517 .bdrv_reopen_prepare = raw_reopen_prepare,
3518 .bdrv_reopen_commit = raw_reopen_commit,
3519 .bdrv_reopen_abort = raw_reopen_abort,
Maxim Levitsky5a5e7f82020-03-26 03:12:18 +02003520 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3521 .create_opts = &bdrv_create_opts_simple,
Alberto Garcia8a2ce0b2019-03-12 18:48:48 +02003522 .mutable_opts = mutable_opts,
Stefan Hajnoczidd577a22018-04-27 17:23:11 +01003523 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
Eric Blake2ffa76c2016-06-01 15:10:10 -06003524 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
ths3b46e622007-09-17 08:09:54 +00003525
Kevin Wolf9d52aa32016-06-03 17:36:27 +02003526 .bdrv_co_preadv = raw_co_preadv,
3527 .bdrv_co_pwritev = raw_co_pwritev,
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003528 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3529 .bdrv_co_pdiscard = hdev_co_pdiscard,
Fam Zheng1efad062018-06-01 17:26:43 +08003530 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3531 .bdrv_co_copy_range_to = raw_co_copy_range_to,
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01003532 .bdrv_refresh_limits = raw_refresh_limits,
Ming Lei1b3abdc2014-07-04 18:04:34 +08003533 .bdrv_io_plug = raw_aio_plug,
3534 .bdrv_io_unplug = raw_aio_unplug,
Nishanth Aravamudan042b7572018-07-18 14:12:56 -07003535 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
aliguori3c529d92008-12-12 16:41:40 +00003536
Kevin Wolf061ca8a2018-06-21 17:54:35 +02003537 .bdrv_co_truncate = raw_co_truncate,
aurel32e60f4692009-03-07 22:00:29 +00003538 .bdrv_getlength = raw_getlength,
Paolo Bonzini260a82e2013-11-22 13:39:55 +01003539 .bdrv_get_info = raw_get_info,
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003540 .bdrv_get_allocated_file_size
3541 = raw_get_allocated_file_size,
Anton Nefedovd9245592019-09-23 15:17:37 +03003542 .bdrv_get_specific_stats = hdev_get_specific_stats,
Fam Zheng244a5662017-05-03 00:35:56 +08003543 .bdrv_check_perm = raw_check_perm,
3544 .bdrv_set_perm = raw_set_perm,
3545 .bdrv_abort_perm_update = raw_abort_perm_update,
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +01003546 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3547 .bdrv_probe_geometry = hdev_probe_geometry,
bellard19cb3732006-08-19 11:45:59 +00003548
ths985a03b2007-12-24 16:10:43 +00003549 /* generic scsi device */
Christoph Hellwig63ec93d2009-06-15 14:04:34 +02003550#ifdef __linux__
Kevin Wolf2f3a7ab2018-10-31 11:25:18 +01003551 .bdrv_co_ioctl = hdev_co_ioctl,
Christoph Hellwig63ec93d2009-06-15 14:04:34 +02003552#endif
bellard19cb3732006-08-19 11:45:59 +00003553};
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003554
Max Reitz18fa1c42014-03-08 00:39:43 +01003555#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3556static void cdrom_parse_filename(const char *filename, QDict *options,
3557 Error **errp)
3558{
Max Reitz03c320d2017-05-22 21:52:16 +02003559 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
Max Reitz18fa1c42014-03-08 00:39:43 +01003560}
3561#endif
3562
3563#ifdef __linux__
Max Reitz015a1032013-09-05 14:22:29 +02003564static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3565 Error **errp)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003566{
3567 BDRVRawState *s = bs->opaque;
3568
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003569 s->type = FTYPE_CD;
3570
Blue Swirl19a3da72009-06-17 18:27:44 +03003571 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
John Snow230ff732018-07-10 13:00:40 -04003572 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003573}
3574
Christoph Hellwig508c7cb2009-06-15 14:04:22 +02003575static int cdrom_probe_device(const char *filename)
3576{
Cole Robinson3baf7202010-01-14 11:19:40 -05003577 int fd, ret;
3578 int prio = 0;
Johannes Stezenbach343f8562011-06-29 16:25:17 +02003579 struct stat st;
Cole Robinson3baf7202010-01-14 11:19:40 -05003580
Corey Bryant6165f4d2012-08-14 16:43:45 -04003581 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
Cole Robinson3baf7202010-01-14 11:19:40 -05003582 if (fd < 0) {
3583 goto out;
3584 }
Johannes Stezenbach343f8562011-06-29 16:25:17 +02003585 ret = fstat(fd, &st);
3586 if (ret == -1 || !S_ISBLK(st.st_mode)) {
3587 goto outc;
3588 }
Cole Robinson3baf7202010-01-14 11:19:40 -05003589
3590 /* Attempt to detect via a CDROM specific ioctl */
3591 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3592 if (ret >= 0)
3593 prio = 100;
3594
Johannes Stezenbach343f8562011-06-29 16:25:17 +02003595outc:
Corey Bryant2e1e79d2012-08-14 16:43:46 -04003596 qemu_close(fd);
Cole Robinson3baf7202010-01-14 11:19:40 -05003597out:
3598 return prio;
Christoph Hellwig508c7cb2009-06-15 14:04:22 +02003599}
3600
Max Reitze031f752015-10-19 17:53:11 +02003601static bool cdrom_is_inserted(BlockDriverState *bs)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003602{
3603 BDRVRawState *s = bs->opaque;
3604 int ret;
3605
3606 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
Max Reitze031f752015-10-19 17:53:11 +02003607 return ret == CDS_DISC_OK;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003608}
3609
Luiz Capitulinof36f3942012-02-03 16:24:53 -02003610static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003611{
3612 BDRVRawState *s = bs->opaque;
3613
3614 if (eject_flag) {
3615 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3616 perror("CDROMEJECT");
3617 } else {
3618 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3619 perror("CDROMEJECT");
3620 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003621}
3622
Markus Armbruster025e8492011-09-06 18:58:47 +02003623static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003624{
3625 BDRVRawState *s = bs->opaque;
3626
3627 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3628 /*
3629 * Note: an error can happen if the distribution automatically
3630 * mounts the CD-ROM
3631 */
3632 /* perror("CDROM_LOCKDOOR"); */
3633 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003634}
3635
3636static BlockDriver bdrv_host_cdrom = {
3637 .format_name = "host_cdrom",
Christoph Hellwig84a12e62010-04-07 22:30:24 +02003638 .protocol_name = "host_cdrom",
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003639 .instance_size = sizeof(BDRVRawState),
BenoƮt Canet030be322013-09-24 17:07:04 +02003640 .bdrv_needs_filename = true,
Christoph Hellwig508c7cb2009-06-15 14:04:22 +02003641 .bdrv_probe_device = cdrom_probe_device,
Max Reitz18fa1c42014-03-08 00:39:43 +01003642 .bdrv_parse_filename = cdrom_parse_filename,
Kevin Wolf66f82ce2010-04-14 14:17:38 +02003643 .bdrv_file_open = cdrom_open,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003644 .bdrv_close = raw_close,
Jeff Cody1bc6b702012-11-20 10:21:10 -05003645 .bdrv_reopen_prepare = raw_reopen_prepare,
3646 .bdrv_reopen_commit = raw_reopen_commit,
3647 .bdrv_reopen_abort = raw_reopen_abort,
Maxim Levitsky5a5e7f82020-03-26 03:12:18 +02003648 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3649 .create_opts = &bdrv_create_opts_simple,
Alberto Garcia8a2ce0b2019-03-12 18:48:48 +02003650 .mutable_opts = mutable_opts,
Stefan Hajnoczidd577a22018-04-27 17:23:11 +01003651 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003652
Kevin Wolf9d52aa32016-06-03 17:36:27 +02003653 .bdrv_co_preadv = raw_co_preadv,
3654 .bdrv_co_pwritev = raw_co_pwritev,
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003655 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01003656 .bdrv_refresh_limits = raw_refresh_limits,
Ming Lei1b3abdc2014-07-04 18:04:34 +08003657 .bdrv_io_plug = raw_aio_plug,
3658 .bdrv_io_unplug = raw_aio_unplug,
Nishanth Aravamudan042b7572018-07-18 14:12:56 -07003659 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003660
Kevin Wolf061ca8a2018-06-21 17:54:35 +02003661 .bdrv_co_truncate = raw_co_truncate,
Kevin Wolfb94a2612013-10-29 12:18:58 +01003662 .bdrv_getlength = raw_getlength,
3663 .has_variable_length = true,
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003664 .bdrv_get_allocated_file_size
3665 = raw_get_allocated_file_size,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003666
3667 /* removable device support */
3668 .bdrv_is_inserted = cdrom_is_inserted,
3669 .bdrv_eject = cdrom_eject,
Markus Armbruster025e8492011-09-06 18:58:47 +02003670 .bdrv_lock_medium = cdrom_lock_medium,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003671
3672 /* generic scsi device */
Kevin Wolf2f3a7ab2018-10-31 11:25:18 +01003673 .bdrv_co_ioctl = hdev_co_ioctl,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003674};
3675#endif /* __linux__ */
3676
Aurelien Jarnoa167ba52009-11-29 18:00:41 +01003677#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
Andreas Tobler511018e2013-10-31 22:41:46 +01003678static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3679 Error **errp)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003680{
3681 BDRVRawState *s = bs->opaque;
Max Reitze428e432013-10-11 11:37:01 +02003682 Error *local_err = NULL;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003683 int ret;
3684
3685 s->type = FTYPE_CD;
3686
John Snow230ff732018-07-10 13:00:40 -04003687 ret = raw_open_common(bs, options, flags, 0, true, &local_err);
Max Reitze428e432013-10-11 11:37:01 +02003688 if (ret) {
Eduardo Habkost621ff942016-06-13 18:57:56 -03003689 error_propagate(errp, local_err);
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003690 return ret;
Max Reitze428e432013-10-11 11:37:01 +02003691 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003692
Dong Xu Wang9b2260c2011-11-22 18:06:25 +08003693 /* make sure the door isn't locked at this time */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003694 ioctl(s->fd, CDIOCALLOW);
3695 return 0;
3696}
3697
Christoph Hellwig508c7cb2009-06-15 14:04:22 +02003698static int cdrom_probe_device(const char *filename)
3699{
3700 if (strstart(filename, "/dev/cd", NULL) ||
3701 strstart(filename, "/dev/acd", NULL))
3702 return 100;
3703 return 0;
3704}
3705
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003706static int cdrom_reopen(BlockDriverState *bs)
3707{
3708 BDRVRawState *s = bs->opaque;
3709 int fd;
3710
3711 /*
3712 * Force reread of possibly changed/newly loaded disc,
3713 * FreeBSD seems to not notice sometimes...
3714 */
3715 if (s->fd >= 0)
Corey Bryant2e1e79d2012-08-14 16:43:46 -04003716 qemu_close(s->fd);
Corey Bryant6165f4d2012-08-14 16:43:45 -04003717 fd = qemu_open(bs->filename, s->open_flags, 0644);
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003718 if (fd < 0) {
3719 s->fd = -1;
3720 return -EIO;
3721 }
3722 s->fd = fd;
3723
Dong Xu Wang9b2260c2011-11-22 18:06:25 +08003724 /* make sure the door isn't locked at this time */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003725 ioctl(s->fd, CDIOCALLOW);
3726 return 0;
3727}
3728
Max Reitze031f752015-10-19 17:53:11 +02003729static bool cdrom_is_inserted(BlockDriverState *bs)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003730{
3731 return raw_getlength(bs) > 0;
3732}
3733
Luiz Capitulinof36f3942012-02-03 16:24:53 -02003734static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003735{
3736 BDRVRawState *s = bs->opaque;
3737
3738 if (s->fd < 0)
Markus Armbruster822e1cd2011-07-20 18:23:42 +02003739 return;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003740
3741 (void) ioctl(s->fd, CDIOCALLOW);
3742
3743 if (eject_flag) {
3744 if (ioctl(s->fd, CDIOCEJECT) < 0)
3745 perror("CDIOCEJECT");
3746 } else {
3747 if (ioctl(s->fd, CDIOCCLOSE) < 0)
3748 perror("CDIOCCLOSE");
3749 }
3750
Markus Armbruster822e1cd2011-07-20 18:23:42 +02003751 cdrom_reopen(bs);
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003752}
3753
Markus Armbruster025e8492011-09-06 18:58:47 +02003754static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003755{
3756 BDRVRawState *s = bs->opaque;
3757
3758 if (s->fd < 0)
Markus Armbruster7bf37fe2011-07-20 18:23:41 +02003759 return;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003760 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3761 /*
3762 * Note: an error can happen if the distribution automatically
3763 * mounts the CD-ROM
3764 */
3765 /* perror("CDROM_LOCKDOOR"); */
3766 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003767}
3768
3769static BlockDriver bdrv_host_cdrom = {
3770 .format_name = "host_cdrom",
Christoph Hellwig84a12e62010-04-07 22:30:24 +02003771 .protocol_name = "host_cdrom",
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003772 .instance_size = sizeof(BDRVRawState),
BenoƮt Canet030be322013-09-24 17:07:04 +02003773 .bdrv_needs_filename = true,
Christoph Hellwig508c7cb2009-06-15 14:04:22 +02003774 .bdrv_probe_device = cdrom_probe_device,
Max Reitz18fa1c42014-03-08 00:39:43 +01003775 .bdrv_parse_filename = cdrom_parse_filename,
Kevin Wolf66f82ce2010-04-14 14:17:38 +02003776 .bdrv_file_open = cdrom_open,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003777 .bdrv_close = raw_close,
Jeff Cody1bc6b702012-11-20 10:21:10 -05003778 .bdrv_reopen_prepare = raw_reopen_prepare,
3779 .bdrv_reopen_commit = raw_reopen_commit,
3780 .bdrv_reopen_abort = raw_reopen_abort,
Maxim Levitsky5a5e7f82020-03-26 03:12:18 +02003781 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3782 .create_opts = &bdrv_create_opts_simple,
Alberto Garcia8a2ce0b2019-03-12 18:48:48 +02003783 .mutable_opts = mutable_opts,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003784
Kevin Wolf9d52aa32016-06-03 17:36:27 +02003785 .bdrv_co_preadv = raw_co_preadv,
3786 .bdrv_co_pwritev = raw_co_pwritev,
Kevin Wolf33d70fb2018-06-21 19:07:32 +02003787 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01003788 .bdrv_refresh_limits = raw_refresh_limits,
Ming Lei1b3abdc2014-07-04 18:04:34 +08003789 .bdrv_io_plug = raw_aio_plug,
3790 .bdrv_io_unplug = raw_aio_unplug,
Nishanth Aravamudan042b7572018-07-18 14:12:56 -07003791 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003792
Kevin Wolf061ca8a2018-06-21 17:54:35 +02003793 .bdrv_co_truncate = raw_co_truncate,
Kevin Wolfb94a2612013-10-29 12:18:58 +01003794 .bdrv_getlength = raw_getlength,
3795 .has_variable_length = true,
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003796 .bdrv_get_allocated_file_size
3797 = raw_get_allocated_file_size,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003798
3799 /* removable device support */
3800 .bdrv_is_inserted = cdrom_is_inserted,
3801 .bdrv_eject = cdrom_eject,
Markus Armbruster025e8492011-09-06 18:58:47 +02003802 .bdrv_lock_medium = cdrom_lock_medium,
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003803};
3804#endif /* __FreeBSD__ */
3805
Christoph Hellwig84a12e62010-04-07 22:30:24 +02003806static void bdrv_file_init(void)
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003807{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +02003808 /*
3809 * Register all the drivers. Note that order is important, the driver
3810 * registered last will get probed first.
3811 */
Christoph Hellwig84a12e62010-04-07 22:30:24 +02003812 bdrv_register(&bdrv_file);
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003813 bdrv_register(&bdrv_host_device);
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003814#ifdef __linux__
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003815 bdrv_register(&bdrv_host_cdrom);
3816#endif
Aurelien Jarnoa167ba52009-11-29 18:00:41 +01003817#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +02003818 bdrv_register(&bdrv_host_cdrom);
3819#endif
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003820}
3821
Christoph Hellwig84a12e62010-04-07 22:30:24 +02003822block_init(bdrv_file_init);