Drivers: hv: kvp: Cleanup error handling in KVP

In preparation to implementing IP injection, cleanup the way we propagate
and handle errors both in the driver as well as in the user level daemon.

Signed-off-by: K. Y. Srinivasan <kys@microsoft.com>
Reviewed-by: Haiyang Zhang <haiyangz@microsoft.com>
Reviewed-by: Olaf Hering <olaf@aepfle.de>
Reviewed-by: Ben Hutchings <ben@decadent.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 33 insertions, 33 deletions

diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c
index 8fbcf7b3c69d..069e2b38decb 100644
--- a/tools/hv/hv_kvp_daemon.c
+++ b/tools/hv/hv_kvp_daemon.c
@@ -71,13 +71,14 @@ enum key_index {
 static char kvp_send_buffer[4096];
 static char kvp_recv_buffer[4096 * 2];
 static struct sockaddr_nl addr;
+static int in_hand_shake = 1;
 
 static char *os_name = "";
 static char *os_major = "";
 static char *os_minor = "";
 static char *processor_arch;
 static char *os_build;
-static char *lic_version;
+static char *lic_version = "Unknown version";
 static struct utsname uts_buf;
 
 
@@ -394,7 +395,7 @@ static int kvp_get_value(int pool, __u8 *key, int key_size, __u8 *value,
         return 1;
 }
 
-static void kvp_pool_enumerate(int pool, int index, __u8 *key, int key_size,
+static int kvp_pool_enumerate(int pool, int index, __u8 *key, int key_size,
                                 __u8 *value, int value_size)
 {
         struct kvp_record *record;
@@ -406,16 +407,12 @@ static void kvp_pool_enumerate(int pool, int index, __u8 *key, int key_size,
         record = kvp_file_info[pool].records;
 
         if (index >= kvp_file_info[pool].num_records) {
-                /*
-                 * This is an invalid index; terminate enumeration;
-                 * - a NULL value will do the trick.
-                 */
-                strcpy(value, "");
-                return;
+                return 1;
         }
 
         memcpy(key, record[index].key, key_size);
         memcpy(value, record[index].value, value_size);
+        return 0;
 }
 
 
@@ -646,6 +643,8 @@ int main(void)
         char    *p;
         char    *key_value;
         char    *key_name;
+        int     op;
+        int     pool;
 
         daemon(1, 0);
         openlog("KVP", 0, LOG_USER);
@@ -687,7 +686,7 @@ int main(void)
         message->id.val = CN_KVP_VAL;
 
         hv_msg = (struct hv_kvp_msg *)message->data;
-        hv_msg->kvp_hdr.operation = KVP_OP_REGISTER;
+        hv_msg->kvp_hdr.operation = KVP_OP_REGISTER1;
         message->ack = 0;
         message->len = sizeof(struct hv_kvp_msg);
 
@@ -721,12 +720,21 @@ int main(void)
                 incoming_cn_msg = (struct cn_msg *)NLMSG_DATA(incoming_msg);
                 hv_msg = (struct hv_kvp_msg *)incoming_cn_msg->data;
 
-                switch (hv_msg->kvp_hdr.operation) {
-                case KVP_OP_REGISTER:
+                /*
+                 * We will use the KVP header information to pass back
+                 * the error from this daemon. So, first copy the state
+                 * and set the error code to success.
+                 */
+                op = hv_msg->kvp_hdr.operation;
+                pool = hv_msg->kvp_hdr.pool;
+                hv_msg->error = HV_S_OK;
+
+                if ((in_hand_shake) && (op == KVP_OP_REGISTER1)) {
                         /*
                          * Driver is registering with us; stash away the version
                          * information.
                          */
+                        in_hand_shake = 0;
                         p = (char *)hv_msg->body.kvp_register.version;
                         lic_version = malloc(strlen(p) + 1);
                         if (lic_version) {
@@ -737,44 +745,39 @@ int main(void)
                                 syslog(LOG_ERR, "malloc failed");
                         }
                         continue;
+                }
 
-                /*
-                 * The current protocol with the kernel component uses a
-                 * NULL key name to pass an error condition.
-                 * For the SET, GET and DELETE operations,
-                 * use the existing protocol to pass back error.
-                 */
-
+                switch (op) {
                 case KVP_OP_SET:
-                        if (kvp_key_add_or_modify(hv_msg->kvp_hdr.pool,
+                        if (kvp_key_add_or_modify(pool,
                                         hv_msg->body.kvp_set.data.key,
                                         hv_msg->body.kvp_set.data.key_size,
                                         hv_msg->body.kvp_set.data.value,
                                         hv_msg->body.kvp_set.data.value_size))
-                                strcpy(hv_msg->body.kvp_set.data.key, "");
+                                        hv_msg->error = HV_S_CONT;
                         break;
 
                 case KVP_OP_GET:
-                        if (kvp_get_value(hv_msg->kvp_hdr.pool,
+                        if (kvp_get_value(pool,
                                         hv_msg->body.kvp_set.data.key,
                                         hv_msg->body.kvp_set.data.key_size,
                                         hv_msg->body.kvp_set.data.value,
                                         hv_msg->body.kvp_set.data.value_size))
-                                strcpy(hv_msg->body.kvp_set.data.key, "");
+                                        hv_msg->error = HV_S_CONT;
                         break;
 
                 case KVP_OP_DELETE:
-                        if (kvp_key_delete(hv_msg->kvp_hdr.pool,
+                        if (kvp_key_delete(pool,
                                         hv_msg->body.kvp_delete.key,
                                         hv_msg->body.kvp_delete.key_size))
-                                strcpy(hv_msg->body.kvp_delete.key, "");
+                                        hv_msg->error = HV_S_CONT;
                         break;
 
                 default:
                         break;
                 }
 
-                if (hv_msg->kvp_hdr.operation != KVP_OP_ENUMERATE)
+                if (op != KVP_OP_ENUMERATE)
                         goto kvp_done;
 
                 /*
@@ -782,13 +785,14 @@ int main(void)
                  * both the key and the value; if not read from the
                  * appropriate pool.
                  */
-                if (hv_msg->kvp_hdr.pool != KVP_POOL_AUTO) {
-                        kvp_pool_enumerate(hv_msg->kvp_hdr.pool,
+                if (pool != KVP_POOL_AUTO) {
+                        if (kvp_pool_enumerate(pool,
                                         hv_msg->body.kvp_enum_data.index,
                                         hv_msg->body.kvp_enum_data.data.key,
                                         HV_KVP_EXCHANGE_MAX_KEY_SIZE,
                                         hv_msg->body.kvp_enum_data.data.value,
-                                        HV_KVP_EXCHANGE_MAX_VALUE_SIZE);
+                                        HV_KVP_EXCHANGE_MAX_VALUE_SIZE))
+                                        hv_msg->error = HV_S_CONT;
                         goto kvp_done;
                 }
 
@@ -841,11 +845,7 @@ int main(void)
                         strcpy(key_name, "ProcessorArchitecture");
                         break;
                 default:
-                        strcpy(key_value, "Unknown Key");
-                        /*
-                         * We use a null key name to terminate enumeration.
-                         */
-                        strcpy(key_name, "");
+                        hv_msg->error = HV_S_CONT;
                         break;
                 }
                 /*