Merge remote-tracking branch 'remotes/dgibson/tags/ppc-for-4.1-20190712' into staging

[qemu.git] / hw / 9pfs / 9p-proxy.c

diff --git a/hw/9pfs/9p-proxy.c b/hw/9pfs/9p-proxy.c
index f4aa7a9d70f8f4b35f0f1fdbe26c86c88ec4e7a4..57a8c1c808860ec5dbd8ff7f76edd8e7909b6ff1 100644 (file)
--- a/hw/9pfs/9p-proxy.c
+++ b/hw/9pfs/9p-proxy.c
@@ -9,12 +9,16 @@
  * This work is licensed under the terms of the GNU GPL, version 2.  See
  * the COPYING file in the top-level directory.
  */
  * This work is licensed under the terms of the GNU GPL, version 2.  See
  * the COPYING file in the top-level directory.
  */

+

 #include "qemu/osdep.h"
 #include <sys/socket.h>
 #include <sys/un.h>
 #include "qemu/osdep.h"
 #include <sys/socket.h>
 #include <sys/un.h>

+#include "qemu-common.h"

 #include "9p.h"
 #include "9p.h"

+#include "qapi/error.h"

 #include "qemu/cutils.h"
 #include "qemu/error-report.h"
 #include "qemu/cutils.h"
 #include "qemu/error-report.h"

+#include "qemu/option.h"

 #include "fsdev/qemu-fsdev.h"
 #include "9p-proxy.h"
 
 #include "fsdev/qemu-fsdev.h"
 #include "9p-proxy.h"
 


@@ -165,7 +169,8 @@ static int v9fs_receive_response(V9fsProxy *proxy, int type,
         return retval;
     }
     reply->iov_len = PROXY_HDR_SZ;
         return retval;
     }
     reply->iov_len = PROXY_HDR_SZ;

-    proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
+    retval = proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
+    assert(retval == 4 * 2);

     /*
      * if response size > PROXY_MAX_IO_SZ, read the response but ignore it and
      * return -ENOBUFS
     /*
      * if response size > PROXY_MAX_IO_SZ, read the response but ignore it and
      * return -ENOBUFS


@@ -194,9 +199,7 @@ static int v9fs_receive_response(V9fsProxy *proxy, int type,
     if (header.type == T_ERROR) {
         int ret;
         ret = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);
     if (header.type == T_ERROR) {
         int ret;
         ret = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);

-        if (ret < 0) {
-            *status = ret;
-        }
+        assert(ret == 4);

         return 0;
     }
 
         return 0;
     }
 


@@ -213,6 +216,7 @@ static int v9fs_receive_response(V9fsProxy *proxy, int type,
                                  &prstat.st_atim_sec, &prstat.st_atim_nsec,
                                  &prstat.st_mtim_sec, &prstat.st_mtim_nsec,
                                  &prstat.st_ctim_sec, &prstat.st_ctim_nsec);
                                  &prstat.st_atim_sec, &prstat.st_atim_nsec,
                                  &prstat.st_mtim_sec, &prstat.st_mtim_nsec,
                                  &prstat.st_ctim_sec, &prstat.st_ctim_nsec);

+        assert(retval == 8 * 3 + 4 * 3 + 8 * 10);

         prstat_to_stat(response, &prstat);
         break;
     }
         prstat_to_stat(response, &prstat);
         break;
     }


@@ -225,6 +229,7 @@ static int v9fs_receive_response(V9fsProxy *proxy, int type,
                                  &prstfs.f_files, &prstfs.f_ffree,
                                  &prstfs.f_fsid[0], &prstfs.f_fsid[1],
                                  &prstfs.f_namelen, &prstfs.f_frsize);
                                  &prstfs.f_files, &prstfs.f_ffree,
                                  &prstfs.f_fsid[0], &prstfs.f_fsid[1],
                                  &prstfs.f_namelen, &prstfs.f_frsize);

+        assert(retval == 8 * 11);

         prstatfs_to_statfs(response, &prstfs);
         break;
     }
         prstatfs_to_statfs(response, &prstfs);
         break;
     }


@@ -246,7 +251,8 @@ static int v9fs_receive_response(V9fsProxy *proxy, int type,
         break;
     }
     case T_GETVERSION:
         break;
     }
     case T_GETVERSION:

-        proxy_unmarshal(reply, PROXY_HDR_SZ, "q", response);
+        retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "q", response);
+        assert(retval == 8);

         break;
     default:
         return -1;
         break;
     default:
         return -1;


@@ -274,18 +280,16 @@ static int v9fs_receive_status(V9fsProxy *proxy,
         return retval;
     }
     reply->iov_len = PROXY_HDR_SZ;
         return retval;
     }
     reply->iov_len = PROXY_HDR_SZ;

-    proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
-    if (header.size != sizeof(int)) {
-        *status = -ENOBUFS;
-        return 0;
-    }
+    retval = proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
+    assert(retval == 4 * 2);

     retval = socket_read(proxy->sockfd,
                          reply->iov_base + PROXY_HDR_SZ, header.size);
     if (retval < 0) {
         return retval;
     }
     reply->iov_len += header.size;
     retval = socket_read(proxy->sockfd,
                          reply->iov_base + PROXY_HDR_SZ, header.size);
     if (retval < 0) {
         return retval;
     }
     reply->iov_len += header.size;

-    proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);
+    retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);
+    assert(retval == 4);

     return 0;
 }
 
     return 0;
 }
 


@@ -1083,25 +1087,24 @@ static int proxy_ioc_getversion(FsContext *fs_ctx, V9fsPath *path,
     return err;
 }
 
     return err;
 }
 

-static int connect_namedsocket(const char *path)
+static int connect_namedsocket(const char *path, Error **errp)

 {
 {

-    int sockfd, size;
+    int sockfd;

     struct sockaddr_un helper;
 
     if (strlen(path) >= sizeof(helper.sun_path)) {
     struct sockaddr_un helper;
 
     if (strlen(path) >= sizeof(helper.sun_path)) {

-        error_report("Socket name too long");
+        error_setg(errp, "socket name too long");

         return -1;
     }
     sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
     if (sockfd < 0) {
         return -1;
     }
     sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
     if (sockfd < 0) {

-        error_report("Failed to create socket: %s", strerror(errno));
+        error_setg_errno(errp, errno, "failed to create client socket");

         return -1;
     }
     strcpy(helper.sun_path, path);
     helper.sun_family = AF_UNIX;
         return -1;
     }
     strcpy(helper.sun_path, path);
     helper.sun_family = AF_UNIX;

-    size = strlen(helper.sun_path) + sizeof(helper.sun_family);
-    if (connect(sockfd, (struct sockaddr *)&helper, size) < 0) {
-        error_report("Failed to connect to %s: %s", path, strerror(errno));
+    if (connect(sockfd, (struct sockaddr *)&helper, sizeof(helper)) < 0) {
+        error_setg_errno(errp, errno, "failed to connect to '%s'", path);

         close(sockfd);
         return -1;
     }
         close(sockfd);
         return -1;
     }


@@ -1111,17 +1114,27 @@ static int connect_namedsocket(const char *path)
     return sockfd;
 }
 
     return sockfd;
 }
 

-static int proxy_parse_opts(QemuOpts *opts, struct FsDriverEntry *fs)
+static void error_append_socket_sockfd_hint(Error **errp)
+{
+    error_append_hint(errp, "Either specify socket=/some/path where /some/path"
+                      " points to a listening AF_UNIX socket or sock_fd=fd"
+                      " where fd is a file descriptor to a connected AF_UNIX"
+                      " socket\n");
+}
+
+static int proxy_parse_opts(QemuOpts *opts, FsDriverEntry *fs, Error **errp)

 {
     const char *socket = qemu_opt_get(opts, "socket");
     const char *sock_fd = qemu_opt_get(opts, "sock_fd");
 
     if (!socket && !sock_fd) {
 {
     const char *socket = qemu_opt_get(opts, "socket");
     const char *sock_fd = qemu_opt_get(opts, "sock_fd");
 
     if (!socket && !sock_fd) {

-        error_report("Must specify either socket or sock_fd");
+        error_setg(errp, "both socket and sock_fd properties are missing");
+        error_append_socket_sockfd_hint(errp);

         return -1;
     }
     if (socket && sock_fd) {
         return -1;
     }
     if (socket && sock_fd) {

-        error_report("Both socket and sock_fd options specified");
+        error_setg(errp, "both socket and sock_fd properties are set");
+        error_append_socket_sockfd_hint(errp);

         return -1;
     }
     if (socket) {
         return -1;
     }
     if (socket) {


@@ -1134,17 +1147,17 @@ static int proxy_parse_opts(QemuOpts *opts, struct FsDriverEntry *fs)
     return 0;
 }
 
     return 0;
 }
 

-static int proxy_init(FsContext *ctx)
+static int proxy_init(FsContext *ctx, Error **errp)

 {
     V9fsProxy *proxy = g_malloc(sizeof(V9fsProxy));
     int sock_id;
 
     if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) {
 {
     V9fsProxy *proxy = g_malloc(sizeof(V9fsProxy));
     int sock_id;
 
     if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) {

-        sock_id = connect_namedsocket(ctx->fs_root);
+        sock_id = connect_namedsocket(ctx->fs_root, errp);

     } else {
         sock_id = atoi(ctx->fs_root);
         if (sock_id < 0) {
     } else {
         sock_id = atoi(ctx->fs_root);
         if (sock_id < 0) {

-            error_report("Socket descriptor not initialized");
+            error_setg(errp, "socket descriptor not initialized");

         }
     }
     if (sock_id < 0) {
         }
     }
     if (sock_id < 0) {