use qemu_blockalign consistently

Use qemu_blockalign for all allocations in the block layer.  This allows
increasing the required alignment, which is need to support O_DIRECT on
devices with large block sizes.

Signed-off-by: Christoph Hellwig <[email protected]>
Signed-off-by: Kevin Wolf <[email protected]>

diff --git a/hw/scsi-disk.c b/hw/scsi-disk.c
index 1446ca634ce986b45178b6e3e132059009180d93..ee20e8f04a2b8ebcbf81eef123fed1b4820e52c5 100644 (file)
--- a/hw/scsi-disk.c
+++ b/hw/scsi-disk.c
@@ -70,14 +70,15 @@ struct SCSIDiskState
     char *serial;
 };
 
-static SCSIDiskReq *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun)
+static SCSIDiskReq *scsi_new_request(SCSIDiskState *s, uint32_t tag,
+        uint32_t lun)
 {
     SCSIRequest *req;
     SCSIDiskReq *r;
 
-    req = scsi_req_alloc(sizeof(SCSIDiskReq), d, tag, lun);
+    req = scsi_req_alloc(sizeof(SCSIDiskReq), &s->qdev, tag, lun);
     r = DO_UPCAST(SCSIDiskReq, req, req);
-    r->iov.iov_base = qemu_memalign(512, SCSI_DMA_BUF_SIZE);
+    r->iov.iov_base = qemu_blockalign(s->bs, SCSI_DMA_BUF_SIZE);
     return r;
 }
 
@@ -939,7 +940,7 @@ static int32_t scsi_send_command(SCSIDevice *d, uint32_t tag,
     }
     /* ??? Tags are not unique for different luns.  We only implement a
        single lun, so this should not matter.  */
-    r = scsi_new_request(d, tag, lun);
+    r = scsi_new_request(s, tag, lun);
     outbuf = (uint8_t *)r->iov.iov_base;
     is_write = 0;
     DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun, tag, buf[0]);

diff --git a/hw/sd.c b/hw/sd.c
index c928120abd69bdc3c9bf1b6d27b1f328e5416d33..4bcf1c01a65878453ad6c4e645a115c32e319b43 100644 (file)
--- a/hw/sd.c
+++ b/hw/sd.c
@@ -440,7 +440,7 @@ SDState *sd_init(BlockDriverState *bs, int is_spi)
     SDState *sd;
 
     sd = (SDState *) qemu_mallocz(sizeof(SDState));
-    sd->buf = qemu_memalign(512, 512);
+    sd->buf = qemu_blockalign(bs, 512);
     sd->spi = is_spi;
     sd->enable = 1;
     sd_reset(sd, bs);

diff --git a/posix-aio-compat.c b/posix-aio-compat.c
index 10f1f037fbe6a3f04ebe7daa90e318ba5bd97294..842f1a24aa91441641bd32a8f8f9ee1f0a1b77b7 100644 (file)
--- a/posix-aio-compat.c
+++ b/posix-aio-compat.c
@@ -270,7 +270,7 @@ static ssize_t handle_aiocb_rw(struct qemu_paiocb *aiocb)
      * Ok, we have to do it the hard way, copy all segments into
      * a single aligned buffer.
      */
-    buf = qemu_memalign(512, aiocb->aio_nbytes);
+    buf = qemu_blockalign(aiocb->common.bs, aiocb->aio_nbytes);
     if (aiocb->aio_type & QEMU_AIO_WRITE) {
         char *p = buf;
         int i;

diff --git a/qemu-io.c b/qemu-io.c
index bd3bd16fdf59f97f3fba43f501a8748c449e348a..b4e5cc8fe623b395479ba8bdd342e45489e9d8b7 100644 (file)
--- a/qemu-io.c
+++ b/qemu-io.c
@@ -61,7 +61,7 @@ static void *qemu_io_alloc(size_t len, int pattern)
 
        if (misalign)
                len += MISALIGN_OFFSET;
-       buf = qemu_memalign(512, len);
+       buf = qemu_blockalign(bs, len);
        memset(buf, pattern, len);
        if (misalign)
                buf += MISALIGN_OFFSET;

diff --git a/qemu-nbd.c b/qemu-nbd.c
index 91b569f8e630596d4566a5e526653ca765cde586..923a3bfd346ec2419fd2d0fb22dbd659340cef8a 100644 (file)
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -446,7 +446,7 @@ int main(int argc, char **argv)
     max_fd = sharing_fds[0];
     nb_fds++;
 
-    data = qemu_memalign(512, NBD_BUFFER_SIZE);
+    data = qemu_blockalign(bs, NBD_BUFFER_SIZE);
     if (data == NULL)
         errx(EXIT_FAILURE, "Cannot allocate data buffer");