sheepdog: handle vdi objects in resend_aio_req

[qemu.git] / block / sheepdog.c

diff --git a/block/sheepdog.c b/block/sheepdog.c
index 38fb6296501c0f4f69a6e189a924379464aca05d..ddb8bfbf79e99219652d645131835724de822a10 100644 (file)
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -125,8 +125,9 @@ typedef struct SheepdogObjReq {
     uint32_t data_length;
     uint64_t oid;
     uint64_t cow_oid;
     uint32_t data_length;
     uint64_t oid;
     uint64_t cow_oid;

-    uint32_t copies;
-    uint32_t rsvd;
+    uint8_t copies;
+    uint8_t copy_policy;
+    uint8_t reserved[6];

     uint64_t offset;
 } SheepdogObjReq;
 
     uint64_t offset;
 } SheepdogObjReq;
 


@@ -138,7 +139,9 @@ typedef struct SheepdogObjRsp {
     uint32_t id;
     uint32_t data_length;
     uint32_t result;
     uint32_t id;
     uint32_t data_length;
     uint32_t result;

-    uint32_t copies;
+    uint8_t copies;
+    uint8_t copy_policy;
+    uint8_t reserved[2];

     uint32_t pad[6];
 } SheepdogObjRsp;
 
     uint32_t pad[6];
 } SheepdogObjRsp;
 


@@ -151,7 +154,9 @@ typedef struct SheepdogVdiReq {
     uint32_t data_length;
     uint64_t vdi_size;
     uint32_t vdi_id;
     uint32_t data_length;
     uint64_t vdi_size;
     uint32_t vdi_id;

-    uint32_t copies;
+    uint8_t copies;
+    uint8_t copy_policy;
+    uint8_t reserved[2];

     uint32_t snapid;
     uint32_t pad[3];
 } SheepdogVdiReq;
     uint32_t snapid;
     uint32_t pad[3];
 } SheepdogVdiReq;


@@ -489,13 +494,13 @@ static coroutine_fn int send_co_req(int sockfd, SheepdogReq *hdr, void *data,
     int ret;
 
     ret = qemu_co_send(sockfd, hdr, sizeof(*hdr));
     int ret;
 
     ret = qemu_co_send(sockfd, hdr, sizeof(*hdr));

-    if (ret < sizeof(*hdr)) {
+    if (ret != sizeof(*hdr)) {

         error_report("failed to send a req, %s", strerror(errno));
         return ret;
     }
 
     ret = qemu_co_send(sockfd, data, *wlen);
         error_report("failed to send a req, %s", strerror(errno));
         return ret;
     }
 
     ret = qemu_co_send(sockfd, data, *wlen);

-    if (ret < *wlen) {
+    if (ret != *wlen) {

         error_report("failed to send a req, %s", strerror(errno));
     }
 
         error_report("failed to send a req, %s", strerror(errno));
     }
 


@@ -541,7 +546,7 @@ static coroutine_fn void do_co_req(void *opaque)
     qemu_aio_set_fd_handler(sockfd, restart_co_req, NULL, co);
 
     ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
     qemu_aio_set_fd_handler(sockfd, restart_co_req, NULL, co);
 
     ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));

-    if (ret < sizeof(*hdr)) {
+    if (ret != sizeof(*hdr)) {

         error_report("failed to get a rsp, %s", strerror(errno));
         ret = -errno;
         goto out;
         error_report("failed to get a rsp, %s", strerror(errno));
         ret = -errno;
         goto out;


@@ -553,7 +558,7 @@ static coroutine_fn void do_co_req(void *opaque)
 
     if (*rlen) {
         ret = qemu_co_recv(sockfd, data, *rlen);
 
     if (*rlen) {
         ret = qemu_co_recv(sockfd, data, *rlen);

-        if (ret < *rlen) {
+        if (ret != *rlen) {

             error_report("failed to get the data, %s", strerror(errno));
             ret = -errno;
             goto out;
             error_report("failed to get the data, %s", strerror(errno));
             ret = -errno;
             goto out;


@@ -664,7 +669,7 @@ static void coroutine_fn aio_read_response(void *opaque)
 
     /* read a header */
     ret = qemu_co_recv(fd, &rsp, sizeof(rsp));
 
     /* read a header */
     ret = qemu_co_recv(fd, &rsp, sizeof(rsp));

-    if (ret < 0) {
+    if (ret != sizeof(rsp)) {

         error_report("failed to get the header, %s", strerror(errno));
         goto out;
     }
         error_report("failed to get the header, %s", strerror(errno));
         goto out;
     }


@@ -715,7 +720,7 @@ static void coroutine_fn aio_read_response(void *opaque)
     case AIOCB_READ_UDATA:
         ret = qemu_co_recvv(fd, acb->qiov->iov, acb->qiov->niov,
                             aio_req->iov_offset, rsp.data_length);
     case AIOCB_READ_UDATA:
         ret = qemu_co_recvv(fd, acb->qiov->iov, acb->qiov->niov,
                             aio_req->iov_offset, rsp.data_length);

-        if (ret < 0) {
+        if (ret != rsp.data_length) {

             error_report("failed to get the data, %s", strerror(errno));
             goto out;
         }
             error_report("failed to get the data, %s", strerror(errno));
             goto out;
         }


@@ -1059,7 +1064,7 @@ static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
 
     /* send a header */
     ret = qemu_co_send(s->fd, &hdr, sizeof(hdr));
 
     /* send a header */
     ret = qemu_co_send(s->fd, &hdr, sizeof(hdr));

-    if (ret < 0) {
+    if (ret != sizeof(hdr)) {

         qemu_co_mutex_unlock(&s->lock);
         error_report("failed to send a req, %s", strerror(errno));
         return -errno;
         qemu_co_mutex_unlock(&s->lock);
         error_report("failed to send a req, %s", strerror(errno));
         return -errno;


@@ -1067,7 +1072,7 @@ static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
 
     if (wlen) {
         ret = qemu_co_sendv(s->fd, iov, niov, aio_req->iov_offset, wlen);
 
     if (wlen) {
         ret = qemu_co_sendv(s->fd, iov, niov, aio_req->iov_offset, wlen);

-        if (ret < 0) {
+        if (ret != wlen) {

             qemu_co_mutex_unlock(&s->lock);
             error_report("failed to send a data, %s", strerror(errno));
             return -errno;
             qemu_co_mutex_unlock(&s->lock);
             error_report("failed to send a data, %s", strerror(errno));
             return -errno;


@@ -1081,7 +1086,7 @@ static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
     return 0;
 }
 
     return 0;
 }
 

-static int read_write_object(int fd, char *buf, uint64_t oid, int copies,
+static int read_write_object(int fd, char *buf, uint64_t oid, uint8_t copies,

                              unsigned int datalen, uint64_t offset,
                              bool write, bool create, uint32_t cache_flags)
 {
                              unsigned int datalen, uint64_t offset,
                              bool write, bool create, uint32_t cache_flags)
 {


@@ -1129,7 +1134,7 @@ static int read_write_object(int fd, char *buf, uint64_t oid, int copies,
     }
 }
 
     }
 }
 

-static int read_object(int fd, char *buf, uint64_t oid, int copies,
+static int read_object(int fd, char *buf, uint64_t oid, uint8_t copies,

                        unsigned int datalen, uint64_t offset,
                        uint32_t cache_flags)
 {
                        unsigned int datalen, uint64_t offset,
                        uint32_t cache_flags)
 {


@@ -1137,7 +1142,7 @@ static int read_object(int fd, char *buf, uint64_t oid, int copies,
                              false, cache_flags);
 }
 
                              false, cache_flags);
 }
 

-static int write_object(int fd, char *buf, uint64_t oid, int copies,
+static int write_object(int fd, char *buf, uint64_t oid, uint8_t copies,

                         unsigned int datalen, uint64_t offset, bool create,
                         uint32_t cache_flags)
 {
                         unsigned int datalen, uint64_t offset, bool create,
                         uint32_t cache_flags)
 {


@@ -1192,11 +1197,15 @@ static int coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req)
         return ret;
     }
 
         return ret;
     }
 

-    aio_req->oid = vid_to_data_oid(s->inode.vdi_id,
-                                   data_oid_to_idx(aio_req->oid));
+    if (is_data_obj(aio_req->oid)) {
+        aio_req->oid = vid_to_data_oid(s->inode.vdi_id,
+                                       data_oid_to_idx(aio_req->oid));
+    } else {
+        aio_req->oid = vid_to_vdi_oid(s->inode.vdi_id);
+    }

 
     /* check whether this request becomes a CoW one */
 
     /* check whether this request becomes a CoW one */

-    if (acb->aiocb_type == AIOCB_WRITE_UDATA) {
+    if (acb->aiocb_type == AIOCB_WRITE_UDATA && is_data_obj(aio_req->oid)) {

         int idx = data_oid_to_idx(aio_req->oid);
         AIOReq *areq;
 
         int idx = data_oid_to_idx(aio_req->oid);
         AIOReq *areq;
 


@@ -1224,8 +1233,15 @@ static int coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req)
         create = true;
     }
 out:
         create = true;
     }
 out:

-    return add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
-                           create, acb->aiocb_type);
+    if (is_data_obj(aio_req->oid)) {
+        return add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
+                               create, acb->aiocb_type);
+    } else {
+        struct iovec iov;
+        iov.iov_base = &s->inode;
+        iov.iov_len = sizeof(s->inode);
+        return add_aio_request(s, aio_req, &iov, 1, false, AIOCB_WRITE_UDATA);
+    }

 }
 
 /* TODO Convert to fine grained options */
 }
 
 /* TODO Convert to fine grained options */


@@ -1344,7 +1360,8 @@ out:
 }
 
 static int do_sd_create(BDRVSheepdogState *s, char *filename, int64_t vdi_size,
 }
 
 static int do_sd_create(BDRVSheepdogState *s, char *filename, int64_t vdi_size,

-                        uint32_t base_vid, uint32_t *vdi_id, int snapshot)
+                        uint32_t base_vid, uint32_t *vdi_id, int snapshot,
+                        uint8_t copy_policy)

 {
     SheepdogVdiReq hdr;
     SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
 {
     SheepdogVdiReq hdr;
     SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;


@@ -1374,6 +1391,7 @@ static int do_sd_create(BDRVSheepdogState *s, char *filename, int64_t vdi_size,
 
     hdr.data_length = wlen;
     hdr.vdi_size = vdi_size;
 
     hdr.data_length = wlen;
     hdr.vdi_size = vdi_size;

+    hdr.copy_policy = copy_policy;

 
     ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
 
 
     ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
 


@@ -1526,7 +1544,8 @@ static int sd_create(const char *filename, QEMUOptionParameter *options,
         bdrv_unref(bs);
     }
 
         bdrv_unref(bs);
     }
 

-    ret = do_sd_create(s, vdi, vdi_size, base_vid, &vid, 0);
+    /* TODO: allow users to specify copy number */
+    ret = do_sd_create(s, vdi, vdi_size, base_vid, &vid, 0, 0);

     if (!prealloc || ret) {
         goto out;
     }
     if (!prealloc || ret) {
         goto out;
     }


@@ -1716,7 +1735,7 @@ static int sd_create_branch(BDRVSheepdogState *s)
      */
     deleted = sd_delete(s);
     ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &vid,
      */
     deleted = sd_delete(s);
     ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &vid,

-                       !deleted);
+                       !deleted, s->inode.copy_policy);

     if (ret) {
         goto out;
     }
     if (ret) {
         goto out;
     }


@@ -2006,7 +2025,7 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
     }
 
     ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &new_vid,
     }
 
     ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &new_vid,

-                       1);
+                       1, s->inode.copy_policy);

     if (ret < 0) {
         error_report("failed to create inode for snapshot. %s",
                      strerror(errno));
     if (ret < 0) {
         error_report("failed to create inode for snapshot. %s",
                      strerror(errno));


@@ -2338,6 +2357,7 @@ static BlockDriver bdrv_sheepdog = {
     .format_name    = "sheepdog",
     .protocol_name  = "sheepdog",
     .instance_size  = sizeof(BDRVSheepdogState),
     .format_name    = "sheepdog",
     .protocol_name  = "sheepdog",
     .instance_size  = sizeof(BDRVSheepdogState),

+    .bdrv_needs_filename = true,

     .bdrv_file_open = sd_open,
     .bdrv_close     = sd_close,
     .bdrv_create    = sd_create,
     .bdrv_file_open = sd_open,
     .bdrv_close     = sd_close,
     .bdrv_create    = sd_create,


@@ -2366,6 +2386,7 @@ static BlockDriver bdrv_sheepdog_tcp = {
     .format_name    = "sheepdog",
     .protocol_name  = "sheepdog+tcp",
     .instance_size  = sizeof(BDRVSheepdogState),
     .format_name    = "sheepdog",
     .protocol_name  = "sheepdog+tcp",
     .instance_size  = sizeof(BDRVSheepdogState),

+    .bdrv_needs_filename = true,

     .bdrv_file_open = sd_open,
     .bdrv_close     = sd_close,
     .bdrv_create    = sd_create,
     .bdrv_file_open = sd_open,
     .bdrv_close     = sd_close,
     .bdrv_create    = sd_create,


@@ -2394,6 +2415,7 @@ static BlockDriver bdrv_sheepdog_unix = {
     .format_name    = "sheepdog",
     .protocol_name  = "sheepdog+unix",
     .instance_size  = sizeof(BDRVSheepdogState),
     .format_name    = "sheepdog",
     .protocol_name  = "sheepdog+unix",
     .instance_size  = sizeof(BDRVSheepdogState),

+    .bdrv_needs_filename = true,

     .bdrv_file_open = sd_open,
     .bdrv_close     = sd_close,
     .bdrv_create    = sd_create,
     .bdrv_file_open = sd_open,
     .bdrv_close     = sd_close,
     .bdrv_create    = sd_create,