target-i386: fix pcmpxstrx equal-ordered (strstr) mode

[qemu.git] / nbd.c

diff --git a/nbd.c b/nbd.c
index e56afbc1621c05464678de69c9815e9d4d6803a5..b3d9654499ca01e4125fdb0d0ab0963945fe03a3 100644 (file)
--- a/nbd.c
+++ b/nbd.c
@@ -19,7 +19,7 @@
 #include "block/nbd.h"
 #include "sysemu/block-backend.h"
 
 #include "block/nbd.h"
 #include "sysemu/block-backend.h"
 

-#include "block/coroutine.h"
+#include "qemu/coroutine.h"

 
 #include <errno.h>
 #include <string.h>
 
 #include <errno.h>
 #include <string.h>


@@ -86,6 +86,59 @@
 #define NBD_OPT_ABORT           (2)
 #define NBD_OPT_LIST            (3)
 
 #define NBD_OPT_ABORT           (2)
 #define NBD_OPT_LIST            (3)
 

+/* NBD errors are based on errno numbers, so there is a 1:1 mapping,
+ * but only a limited set of errno values is specified in the protocol.
+ * Everything else is squashed to EINVAL.
+ */
+#define NBD_SUCCESS    0
+#define NBD_EPERM      1
+#define NBD_EIO        5
+#define NBD_ENOMEM     12
+#define NBD_EINVAL     22
+#define NBD_ENOSPC     28
+
+static int system_errno_to_nbd_errno(int err)
+{
+    switch (err) {
+    case 0:
+        return NBD_SUCCESS;
+    case EPERM:
+        return NBD_EPERM;
+    case EIO:
+        return NBD_EIO;
+    case ENOMEM:
+        return NBD_ENOMEM;
+#ifdef EDQUOT
+    case EDQUOT:
+#endif
+    case EFBIG:
+    case ENOSPC:
+        return NBD_ENOSPC;
+    case EINVAL:
+    default:
+        return NBD_EINVAL;
+    }
+}
+
+static int nbd_errno_to_system_errno(int err)
+{
+    switch (err) {
+    case NBD_SUCCESS:
+        return 0;
+    case NBD_EPERM:
+        return EPERM;
+    case NBD_EIO:
+        return EIO;
+    case NBD_ENOMEM:
+        return ENOMEM;
+    case NBD_ENOSPC:
+        return ENOSPC;
+    case NBD_EINVAL:
+    default:
+        return EINVAL;
+    }
+}
+

 /* Definitions for opaque data types */
 
 typedef struct NBDRequest NBDRequest;
 /* Definitions for opaque data types */
 
 typedef struct NBDRequest NBDRequest;


@@ -193,6 +246,26 @@ static ssize_t read_sync(int fd, void *buffer, size_t size)
     return nbd_wr_sync(fd, buffer, size, true);
 }
 
     return nbd_wr_sync(fd, buffer, size, true);
 }
 

+static ssize_t drop_sync(int fd, size_t size)
+{
+    ssize_t ret, dropped = size;
+    uint8_t *buffer = g_malloc(MIN(65536, size));
+
+    while (size > 0) {
+        ret = read_sync(fd, buffer, MIN(65536, size));
+        if (ret < 0) {
+            g_free(buffer);
+            return ret;
+        }
+
+        assert(ret <= size);
+        size -= ret;
+    }
+
+    g_free(buffer);
+    return dropped;
+}
+

 static ssize_t write_sync(int fd, void *buffer, size_t size)
 {
     int ret;
 static ssize_t write_sync(int fd, void *buffer, size_t size)
 {
     int ret;


@@ -303,6 +376,9 @@ static int nbd_handle_list(NBDClient *client, uint32_t length)
 
     csock = client->sock;
     if (length) {
 
     csock = client->sock;
     if (length) {

+        if (drop_sync(csock, length) != length) {
+            return -EIO;
+        }

         return nbd_send_rep(csock, NBD_REP_ERR_INVALID, NBD_OPT_LIST);
     }
 
         return nbd_send_rep(csock, NBD_REP_ERR_INVALID, NBD_OPT_LIST);
     }
 


@@ -350,30 +426,39 @@ fail:
 
 static int nbd_receive_options(NBDClient *client)
 {
 
 static int nbd_receive_options(NBDClient *client)
 {

+    int csock = client->sock;
+    uint32_t flags;
+
+    /* Client sends:
+        [ 0 ..   3]   client flags
+
+        [ 0 ..   7]   NBD_OPTS_MAGIC
+        [ 8 ..  11]   NBD option
+        [12 ..  15]   Data length
+        ...           Rest of request
+
+        [ 0 ..   7]   NBD_OPTS_MAGIC
+        [ 8 ..  11]   Second NBD option
+        [12 ..  15]   Data length
+        ...           Rest of request
+    */
+
+    if (read_sync(csock, &flags, sizeof(flags)) != sizeof(flags)) {
+        LOG("read failed");
+        return -EIO;
+    }
+    TRACE("Checking client flags");
+    be32_to_cpus(&flags);
+    if (flags != 0 && flags != NBD_FLAG_C_FIXED_NEWSTYLE) {
+        LOG("Bad client flags received");
+        return -EIO;
+    }
+

     while (1) {
     while (1) {

-        int csock = client->sock;
+        int ret;

         uint32_t tmp, length;
         uint64_t magic;
 
         uint32_t tmp, length;
         uint64_t magic;
 

-        /* Client sends:
-            [ 0 ..   3]   client flags
-            [ 4 ..  11]   NBD_OPTS_MAGIC
-            [12 ..  15]   NBD option
-            [16 ..  19]   length
-            ...           Rest of request
-        */
-
-        if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
-            LOG("read failed");
-            return -EINVAL;
-        }
-        TRACE("Checking client flags");
-        tmp = be32_to_cpu(tmp);
-        if (tmp != 0 && tmp != NBD_FLAG_C_FIXED_NEWSTYLE) {
-            LOG("Bad client flags received");
-            return -EINVAL;
-        }
-

         if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
             LOG("read failed");
             return -EINVAL;
         if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
             LOG("read failed");
             return -EINVAL;


@@ -398,8 +483,9 @@ static int nbd_receive_options(NBDClient *client)
         TRACE("Checking option");
         switch (be32_to_cpu(tmp)) {
         case NBD_OPT_LIST:
         TRACE("Checking option");
         switch (be32_to_cpu(tmp)) {
         case NBD_OPT_LIST:

-            if (nbd_handle_list(client, length) < 0) {
-                return 1;
+            ret = nbd_handle_list(client, length);
+            if (ret < 0) {
+                return ret;

             }
             break;
 
             }
             break;
 


@@ -494,7 +580,7 @@ fail:
 }
 
 int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags,
 }
 
 int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags,

-                          off_t *size, size_t *blocksize, Error **errp)
+                          off_t *size, Error **errp)

 {
     char buf[256];
     uint64_t magic, s;
 {
     char buf[256];
     uint64_t magic, s;


@@ -602,7 +688,6 @@ int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags,
         goto fail;
     }
     *size = be64_to_cpu(s);
         goto fail;
     }
     *size = be64_to_cpu(s);

-    *blocksize = 1024;

     TRACE("Size is %" PRIu64, *size);
 
     if (!name) {
     TRACE("Size is %" PRIu64, *size);
 
     if (!name) {


@@ -616,7 +701,7 @@ int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags,
             error_setg(errp, "Failed to read export flags");
             goto fail;
         }
             error_setg(errp, "Failed to read export flags");
             goto fail;
         }

-        *flags |= be32_to_cpu(tmp);
+        *flags |= be16_to_cpu(tmp);

     }
     if (read_sync(csock, &buf, 124) != 124) {
         error_setg(errp, "Failed to read reserved block");
     }
     if (read_sync(csock, &buf, 124) != 124) {
         error_setg(errp, "Failed to read reserved block");


@@ -629,7 +714,7 @@ fail:
 }
 
 #ifdef __linux__
 }
 
 #ifdef __linux__

-int nbd_init(int fd, int csock, uint32_t flags, off_t size, size_t blocksize)
+int nbd_init(int fd, int csock, uint32_t flags, off_t size)

 {
     TRACE("Setting NBD socket");
 
 {
     TRACE("Setting NBD socket");
 


@@ -639,17 +724,17 @@ int nbd_init(int fd, int csock, uint32_t flags, off_t size, size_t blocksize)
         return -serrno;
     }
 
         return -serrno;
     }
 

-    TRACE("Setting block size to %lu", (unsigned long)blocksize);
+    TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE);

 
 

-    if (ioctl(fd, NBD_SET_BLKSIZE, blocksize) < 0) {
+    if (ioctl(fd, NBD_SET_BLKSIZE, (size_t)BDRV_SECTOR_SIZE) < 0) {

         int serrno = errno;
         LOG("Failed setting NBD block size");
         return -serrno;
     }
 
         int serrno = errno;
         LOG("Failed setting NBD block size");
         return -serrno;
     }
 

-        TRACE("Setting size to %zd block(s)", (size_t)(size / blocksize));
+    TRACE("Setting size to %zd block(s)", (size_t)(size / BDRV_SECTOR_SIZE));

 
 

-    if (ioctl(fd, NBD_SET_SIZE_BLOCKS, size / blocksize) < 0) {
+    if (ioctl(fd, NBD_SET_SIZE_BLOCKS, (size_t)(size / BDRV_SECTOR_SIZE)) < 0) {

         int serrno = errno;
         LOG("Failed setting size (in blocks)");
         return -serrno;
         int serrno = errno;
         LOG("Failed setting size (in blocks)");
         return -serrno;


@@ -714,7 +799,7 @@ int nbd_client(int fd)
     return ret;
 }
 #else
     return ret;
 }
 #else

-int nbd_init(int fd, int csock, uint32_t flags, off_t size, size_t blocksize)
+int nbd_init(int fd, int csock, uint32_t flags, off_t size)

 {
     return -ENOTSUP;
 }
 {
     return -ENOTSUP;
 }


@@ -824,6 +909,8 @@ ssize_t nbd_receive_reply(int csock, struct nbd_reply *reply)
     reply->error  = be32_to_cpup((uint32_t*)(buf + 4));
     reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
 
     reply->error  = be32_to_cpup((uint32_t*)(buf + 4));
     reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
 

+    reply->error = nbd_errno_to_system_errno(reply->error);
+

     TRACE("Got reply: "
           "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
           magic, reply->error, reply->handle);
     TRACE("Got reply: "
           "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
           magic, reply->error, reply->handle);


@@ -840,6 +927,8 @@ static ssize_t nbd_send_reply(int csock, struct nbd_reply *reply)
     uint8_t buf[NBD_REPLY_SIZE];
     ssize_t ret;
 
     uint8_t buf[NBD_REPLY_SIZE];
     ssize_t ret;
 

+    reply->error = system_errno_to_nbd_errno(reply->error);
+

     /* Reply
        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
        [ 4 ..  7]    error   (0 == no error)
     /* Reply
        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
        [ 4 ..  7]    error   (0 == no error)


@@ -874,7 +963,7 @@ void nbd_client_put(NBDClient *client)
 {
     if (--client->refcount == 0) {
         /* The last reference should be dropped by client->close,
 {
     if (--client->refcount == 0) {
         /* The last reference should be dropped by client->close,

-         * which is called by nbd_client_close.
+         * which is called by client_close.

          */
         assert(client->closing);
 
          */
         assert(client->closing);
 


@@ -889,7 +978,7 @@ void nbd_client_put(NBDClient *client)
     }
 }
 
     }
 }
 

-void nbd_client_close(NBDClient *client)
+static void client_close(NBDClient *client)

 {
     if (client->closing) {
         return;
 {
     if (client->closing) {
         return;


@@ -916,7 +1005,7 @@ static NBDRequest *nbd_request_get(NBDClient *client)
     client->nb_requests++;
     nbd_update_can_read(client);
 
     client->nb_requests++;
     nbd_update_can_read(client);
 

-    req = g_slice_new0(NBDRequest);
+    req = g_new0(NBDRequest, 1);

     nbd_client_get(client);
     req->client = client;
     return req;
     nbd_client_get(client);
     req->client = client;
     return req;


@@ -929,7 +1018,7 @@ static void nbd_request_put(NBDRequest *req)
     if (req->data) {
         qemu_vfree(req->data);
     }
     if (req->data) {
         qemu_vfree(req->data);
     }

-    g_slice_free(NBDRequest, req);
+    g_free(req);

 
     client->nb_requests--;
     nbd_update_can_read(client);
 
     client->nb_requests--;
     nbd_update_can_read(client);


@@ -965,7 +1054,8 @@ static void blk_aio_detach(void *opaque)
 }
 
 NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size,
 }
 
 NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size,

-                          uint32_t nbdflags, void (*close)(NBDExport *))
+                          uint32_t nbdflags, void (*close)(NBDExport *),
+                          Error **errp)

 {
     NBDExport *exp = g_malloc0(sizeof(NBDExport));
     exp->refcount = 1;
 {
     NBDExport *exp = g_malloc0(sizeof(NBDExport));
     exp->refcount = 1;


@@ -973,7 +1063,14 @@ NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size,
     exp->blk = blk;
     exp->dev_offset = dev_offset;
     exp->nbdflags = nbdflags;
     exp->blk = blk;
     exp->dev_offset = dev_offset;
     exp->nbdflags = nbdflags;

-    exp->size = size == -1 ? blk_getlength(blk) : size;
+    exp->size = size < 0 ? blk_getlength(blk) : size;
+    if (exp->size < 0) {
+        error_setg_errno(errp, -exp->size,
+                         "Failed to determine the NBD export's length");
+        goto fail;
+    }
+    exp->size -= exp->size % BDRV_SECTOR_SIZE;
+

     exp->close = close;
     exp->ctx = blk_get_aio_context(blk);
     blk_ref(blk);
     exp->close = close;
     exp->ctx = blk_get_aio_context(blk);
     blk_ref(blk);


@@ -985,6 +1082,10 @@ NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size,
      */
     blk_invalidate_cache(blk, NULL);
     return exp;
      */
     blk_invalidate_cache(blk, NULL);
     return exp;

+
+fail:
+    g_free(exp);
+    return NULL;

 }
 
 NBDExport *nbd_export_find(const char *name)
 }
 
 NBDExport *nbd_export_find(const char *name)


@@ -1026,16 +1127,10 @@ void nbd_export_close(NBDExport *exp)
 
     nbd_export_get(exp);
     QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) {
 
     nbd_export_get(exp);
     QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) {

-        nbd_client_close(client);
+        client_close(client);

     }
     nbd_export_set_name(exp, NULL);
     nbd_export_put(exp);
     }
     nbd_export_set_name(exp, NULL);
     nbd_export_put(exp);

-    if (exp->blk) {
-        blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
-                                        blk_aio_detach, exp);
-        blk_unref(exp->blk);
-        exp->blk = NULL;
-    }

 }
 
 void nbd_export_get(NBDExport *exp)
 }
 
 void nbd_export_get(NBDExport *exp)


@@ -1058,6 +1153,13 @@ void nbd_export_put(NBDExport *exp)
             exp->close(exp);
         }
 
             exp->close(exp);
         }
 

+        if (exp->blk) {
+            blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
+                                            blk_aio_detach, exp);
+            blk_unref(exp->blk);
+            exp->blk = NULL;
+        }
+

         g_free(exp);
     }
 }
         g_free(exp);
     }
 }


@@ -1204,6 +1306,14 @@ static void nbd_trip(void *opaque)
         goto invalid_request;
     }
 
         goto invalid_request;
     }
 

+    if (client->closing) {
+        /*
+         * The client may be closed when we are blocked in
+         * nbd_co_receive_request()
+         */
+        goto done;
+    }
+

     switch (command) {
     case NBD_CMD_READ:
         TRACE("Request type is READ");
     switch (command) {
     case NBD_CMD_READ:
         TRACE("Request type is READ");


@@ -1295,7 +1405,7 @@ static void nbd_trip(void *opaque)
     default:
         LOG("invalid request type (%u) received", request.type);
     invalid_request:
     default:
         LOG("invalid request type (%u) received", request.type);
     invalid_request:

-        reply.error = -EINVAL;
+        reply.error = EINVAL;

     error_reply:
         if (nbd_co_send_reply(req, &reply, 0) < 0) {
             goto out;
     error_reply:
         if (nbd_co_send_reply(req, &reply, 0) < 0) {
             goto out;


@@ -1311,7 +1421,7 @@ done:
 
 out:
     nbd_request_put(req);
 
 out:
     nbd_request_put(req);

-    nbd_client_close(client);
+    client_close(client);

 }
 
 static void nbd_read(void *opaque)
 }
 
 static void nbd_read(void *opaque)


@@ -1336,6 +1446,7 @@ static void nbd_set_handlers(NBDClient *client)
 {
     if (client->exp && client->exp->ctx) {
         aio_set_fd_handler(client->exp->ctx, client->sock,
 {
     if (client->exp && client->exp->ctx) {
         aio_set_fd_handler(client->exp->ctx, client->sock,

+                           true,

                            client->can_read ? nbd_read : NULL,
                            client->send_coroutine ? nbd_restart_write : NULL,
                            client);
                            client->can_read ? nbd_read : NULL,
                            client->send_coroutine ? nbd_restart_write : NULL,
                            client);


@@ -1345,7 +1456,8 @@ static void nbd_set_handlers(NBDClient *client)
 static void nbd_unset_handlers(NBDClient *client)
 {
     if (client->exp && client->exp->ctx) {
 static void nbd_unset_handlers(NBDClient *client)
 {
     if (client->exp && client->exp->ctx) {

-        aio_set_fd_handler(client->exp->ctx, client->sock, NULL, NULL, NULL);
+        aio_set_fd_handler(client->exp->ctx, client->sock,
+                           true, NULL, NULL, NULL);

     }
 }
 
     }
 }