OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

block: Make blk_{pread,pwrite}() return 0 on success

Browse Source 
They currently return the value of their 'bytes' parameter on success.

Make them return 0 instead, for consistency with other I/O functions and
in preparation to implement them using generated_co_wrapper. This also
makes it clear that short reads/writes are not possible.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Message-Id: <20220705161527.1054072-2-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
This commit is contained in:
Alberto Faria 2022-07-05 17:15:09 +01:00 committed by Hanna Reitz
parent 92529251d2
commit bf5b16fa40
12 changed files with 49 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
block.c
View File

@ -1045,14 +1045,16 @@ static int find_image_format(BlockBackend *file, const char *filename,
return ret;
}
drv = bdrv_probe_all(buf, ret, filename);
drv = bdrv_probe_all(buf, sizeof(buf), filename);
if (!drv) {
error_setg(errp, "Could not determine image format: No compatible "
"driver found");
ret = -ENOENT;
*pdrv = NULL;
return -ENOENT;
}
*pdrv = drv;
return ret;
return 0;
}
/**

7
block/block-backend.c
View File

@ -1573,19 +1573,16 @@ int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes)
ret = blk_do_preadv(blk, offset, bytes, &qiov, 0);
blk_dec_in_flight(blk);
return ret < 0 ? ret : bytes;
return ret;
}
int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
BdrvRequestFlags flags)
{
int ret;
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
IO_OR_GS_CODE();
ret = blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
return ret < 0 ? ret : bytes;
return blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
}
int64_t blk_getlength(BlockBackend *blk)

6
block/qcow.c
View File

@ -891,14 +891,14 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
/* write all the data */
ret = blk_pwrite(qcow_blk, 0, &header, sizeof(header), 0);
if (ret != sizeof(header)) {
if (ret < 0) {
goto exit;
}
if (qcow_opts->has_backing_file) {
ret = blk_pwrite(qcow_blk, sizeof(header),
qcow_opts->backing_file, backing_filename_len, 0);
if (ret != backing_filename_len) {
if (ret < 0) {
goto exit;
}
}
@ -908,7 +908,7 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
i++) {
ret = blk_pwrite(qcow_blk, header_size + BDRV_SECTOR_SIZE * i,
tmp, BDRV_SECTOR_SIZE, 0);
if (ret != BDRV_SECTOR_SIZE) {
if (ret < 0) {
g_free(tmp);
goto exit;
}

2
hw/block/m25p80.c
View File

@ -1532,7 +1532,7 @@ static void m25p80_realize(SSIPeripheral *ss, Error **errp)
trace_m25p80_binding(s);
s->storage = blk_blockalign(s->blk, s->size);
if (blk_pread(s->blk, 0, s->storage, s->size) != s->size) {
if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
error_setg(errp, "failed to read the initial flash content");
return;
}

4
hw/misc/mac_via.c
View File

@ -1029,8 +1029,8 @@ static void mos6522_q800_via1_realize(DeviceState *dev, Error **errp)
return;
}
len = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM));
if (len != sizeof(v1s->PRAM)) {
ret = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM));
if (ret < 0) {
error_setg(errp, "can't read PRAM contents");
return;
}

2
hw/misc/sifive_u_otp.c
View File

@ -240,7 +240,7 @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
return;
}
if (blk_pread(s->blk, 0, s->fuse, filesize) != filesize) {
if (blk_pread(s->blk, 0, s->fuse, filesize) < 0) {
error_setg(errp, "failed to read the initial flash content");
return;
}

8
hw/nvram/eeprom_at24c.c
View File

@ -64,8 +64,8 @@ int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
case I2C_START_RECV:
DPRINTK("clear\n");
if (ee->blk && ee->changed) {
int len = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
if (len != ee->rsize) {
int ret = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
if (ret < 0) {
ERR(TYPE_AT24C_EE
" : failed to write backing file\n");
}
@ -165,9 +165,9 @@ void at24c_eeprom_reset(DeviceState *state)
memset(ee->mem, 0, ee->rsize);
if (ee->blk) {
int len = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
int ret = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
if (len != ee->rsize) {
if (ret < 0) {
ERR(TYPE_AT24C_EE
" : Failed initial sync with backing file\n");
}

14
hw/nvram/spapr_nvram.c
View File

@ -103,7 +103,7 @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
{
SpaprNvram *nvram = spapr->nvram;
hwaddr offset, buffer, len;
int alen;
int ret;
void *membuf;
if ((nargs != 3) || (nret != 2)) {
@ -128,9 +128,9 @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
membuf = cpu_physical_memory_map(buffer, &len, false);
alen = len;
ret = 0;
if (nvram->blk) {
alen = blk_pwrite(nvram->blk, offset, membuf, len, 0);
ret = blk_pwrite(nvram->blk, offset, membuf, len, 0);
}
assert(nvram->buf);
@ -138,8 +138,8 @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
cpu_physical_memory_unmap(membuf, len, 0, len);
rtas_st(rets, 0, (alen < len) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
rtas_st(rets, 1, (alen < 0) ? 0 : alen);
rtas_st(rets, 0, (ret < 0) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
rtas_st(rets, 1, (ret < 0) ? 0 : len);
}
static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
@ -179,9 +179,9 @@ static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
}
if (nvram->blk) {
int alen = blk_pread(nvram->blk, 0, nvram->buf, nvram->size);
ret = blk_pread(nvram->blk, 0, nvram->buf, nvram->size);
if (alen != nvram->size) {
if (ret < 0) {
error_setg(errp, "can't read spapr-nvram contents");
return;
}

2
hw/ppc/pnv_pnor.c
View File

@ -99,7 +99,7 @@ static void pnv_pnor_realize(DeviceState *dev, Error **errp)
s->storage = blk_blockalign(s->blk, s->size);
if (blk_pread(s->blk, 0, s->storage, s->size) != s->size) {
if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
error_setg(errp, "failed to read the initial flash content");
return;
}

25
qemu-img.c
View File

@ -5120,30 +5120,23 @@ static int img_dd(int argc, char **argv)
in.buf = g_new(uint8_t, in.bsz);
for (out_pos = 0; in_pos < size; block_count++) {
int in_ret, out_ret;
int bytes = (in_pos + in.bsz > size) ? size - in_pos : in.bsz;
if (in_pos + in.bsz > size) {
in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
} else {
in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
}
if (in_ret < 0) {
ret = blk_pread(blk1, in_pos, in.buf, bytes);
if (ret < 0) {
error_report("error while reading from input image file: %s",
strerror(-in_ret));
ret = -1;
strerror(-ret));
goto out;
}
in_pos += in_ret;
in_pos += bytes;
out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
if (out_ret < 0) {
ret = blk_pwrite(blk2, out_pos, in.buf, bytes, 0);
if (ret < 0) {
error_report("error while writing to output image file: %s",
strerror(-out_ret));
ret = -1;
strerror(-ret));
goto out;
}
out_pos += out_ret;
out_pos += bytes;
}
out:

18
qemu-io-cmds.c
View File

@ -541,28 +541,34 @@ fail:
static int do_pread(BlockBackend *blk, char *buf, int64_t offset,
int64_t bytes, int64_t *total)
{
int ret;
if (bytes > INT_MAX) {
return -ERANGE;
}
*total = blk_pread(blk, offset, (uint8_t *)buf, bytes);
if (*total < 0) {
return *total;
ret = blk_pread(blk, offset, (uint8_t *)buf, bytes);
if (ret < 0) {
return ret;
}
*total = bytes;
return 1;
}
static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset,
int64_t bytes, int flags, int64_t *total)
{
int ret;
if (bytes > INT_MAX) {
return -ERANGE;
}
*total = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
if (*total < 0) {
return *total;
ret = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
if (ret < 0) {
return ret;
}
*total = bytes;
return 1;
}

4
tests/unit/test-block-iothread.c
View File

@ -117,7 +117,7 @@ static void test_sync_op_blk_pread(BlockBackend *blk)
/* Success */
ret = blk_pread(blk, 0, buf, sizeof(buf));
g_assert_cmpint(ret, ==, 512);
g_assert_cmpint(ret, ==, 0);
/* Early error: Negative offset */
ret = blk_pread(blk, -2, buf, sizeof(buf));
@ -131,7 +131,7 @@ static void test_sync_op_blk_pwrite(BlockBackend *blk)
/* Success */
ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
g_assert_cmpint(ret, ==, 512);
g_assert_cmpint(ret, ==, 0);
/* Early error: Negative offset */
ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);