Fix warnings and constness handling in lvmetad-core (adjusting the

dm_config_find_node to give non-const node pointer, since that better reflects
the contract of that function).

diff --git a/daemons/common/daemon-server.c b/daemons/common/daemon-server.c
index 9ec14a7b2b53073113886947da08aff9eae28133..1ecc97c4596ff386b4afaad751c207cdaf12e7fb 100644 (file)
--- a/daemons/common/daemon-server.c
+++ b/daemons/common/daemon-server.c
@@ -201,7 +201,7 @@ static void _daemonise(void)
        setsid();
 }
 
-response daemon_reply_simple(char *id, ...)
+response daemon_reply_simple(const char *id, ...)
 {
        va_list ap;
        va_start(ap, id);

diff --git a/daemons/common/daemon-server.h b/daemons/common/daemon-server.h
index b524c760b38bb2d54cf94b831d0afbebde8e119e..a2492e40c87d14156d7b285b3c88832863f62f99 100644 (file)
--- a/daemons/common/daemon-server.h
+++ b/daemons/common/daemon-server.h
@@ -41,7 +41,7 @@ struct daemon_state;
  * Craft a simple reply, without the need to construct a config_tree. See
  * daemon_send_simple in daemon-client.h for the description of the parameters.
  */
-response daemon_reply_simple(char *id, ...);
+response daemon_reply_simple(const char *id, ...);
 
 static inline int daemon_request_int(request r, const char *path, int def) {
        if (!r.cft)

diff --git a/daemons/lvmetad/lvmetad-core.c b/daemons/lvmetad/lvmetad-core.c
index 8e10d0b48988931311fe9803b9f737c3808ce390..6b69a12b646c7a931934a628ccaad6fc777bd9f4 100644 (file)
--- a/daemons/lvmetad/lvmetad-core.c
+++ b/daemons/lvmetad/lvmetad-core.c
@@ -1,11 +1,11 @@
 #include <assert.h>
 #include <pthread.h>
-
-#include "libdevmapper.h"
 #include <malloc.h>
 #include <stdint.h>
+#include <unistd.h>
 
-#include "../common/daemon-server.h"
+#include "libdevmapper.h"
+#include "daemon-server.h"
 
 typedef struct {
        struct dm_hash_table *pvs;
@@ -19,29 +19,29 @@ typedef struct {
        } lock;
 } lvmetad_state;
 
-void debug(const char *fmt, ...) {
+static void debug(const char *fmt, ...) {
        va_list ap;
        va_start(ap, fmt);
-       fprintf(stderr, "[D %u] ", pthread_self());
+       fprintf(stderr, "[D %lu] ", pthread_self());
        vfprintf(stderr, fmt, ap);
        va_end(ap);
 };
 
-void lock_pvs(lvmetad_state *s) { pthread_mutex_lock(&s->lock.pvs); }
-void unlock_pvs(lvmetad_state *s) { pthread_mutex_unlock(&s->lock.pvs); }
+static void lock_pvs(lvmetad_state *s) { pthread_mutex_lock(&s->lock.pvs); }
+static void unlock_pvs(lvmetad_state *s) { pthread_mutex_unlock(&s->lock.pvs); }
 
-void lock_vgs(lvmetad_state *s) { pthread_mutex_lock(&s->lock.vgs); }
-void unlock_vgs(lvmetad_state *s) { pthread_mutex_unlock(&s->lock.vgs); }
+static void lock_vgs(lvmetad_state *s) { pthread_mutex_lock(&s->lock.vgs); }
+static void unlock_vgs(lvmetad_state *s) { pthread_mutex_unlock(&s->lock.vgs); }
 
-void lock_pvid_map(lvmetad_state *s) { pthread_mutex_lock(&s->lock.pvid_map); }
-void unlock_pvid_map(lvmetad_state *s) { pthread_mutex_unlock(&s->lock.pvid_map); }
+static void lock_pvid_map(lvmetad_state *s) { pthread_mutex_lock(&s->lock.pvid_map); }
+static void unlock_pvid_map(lvmetad_state *s) { pthread_mutex_unlock(&s->lock.pvid_map); }
 
 /*
  * TODO: It may be beneficial to clean up the vg lock hash from time to time,
  * since if we have many "rogue" requests for nonexistent things, we will keep
  * allocating memory that we never release. Not good.
  */
-struct dm_config_tree *lock_vg(lvmetad_state *s, const char *id) {
+static struct dm_config_tree *lock_vg(lvmetad_state *s, const char *id) {
        lock_vgs(s);
        pthread_mutex_t *vg = dm_hash_lookup(s->lock.vg, id);
        if (!vg) {
@@ -58,7 +58,7 @@ struct dm_config_tree *lock_vg(lvmetad_state *s, const char *id) {
        return cft;
 }
 
-void unlock_vg(lvmetad_state *s, const char *id) {
+static void unlock_vg(lvmetad_state *s, const char *id) {
        lock_vgs(s); /* someone might be changing the s->lock.vg structure right
                      * now, so avoid stepping on each other's toes */
        pthread_mutex_unlock(dm_hash_lookup(s->lock.vg, id));
@@ -78,10 +78,9 @@ static struct dm_config_node *pvs(struct dm_config_node *vg)
  * library here or there.
  */
 static void set_flag(struct dm_config_tree *cft, struct dm_config_node *parent,
-                    char *field, const char *flag, int want) {
+                    const char *field, const char *flag, int want) {
        struct dm_config_value *value = NULL, *pred = NULL;
        struct dm_config_node *node = dm_config_find_node(parent->child, field);
-       int found = 0;
 
        if (node)
                value = node->v;
@@ -184,20 +183,23 @@ static response vg_by_uuid(lvmetad_state *s, request r)
 
 static int compare_value(struct dm_config_value *a, struct dm_config_value *b)
 {
+       int r = 0;
+
        if (a->type > b->type)
                return 1;
        if (a->type < b->type)
                return -1;
 
        switch (a->type) {
-       case DM_CFG_STRING: return strcmp(a->v.str, b->v.str);
-       case DM_CFG_FLOAT: return a->v.r == b->v.r;
-       case DM_CFG_INT: return a->v.i == b->v.i;
+       case DM_CFG_STRING: r = strcmp(a->v.str, b->v.str);
+       case DM_CFG_FLOAT: r = (a->v.r == b->v.r);
+       case DM_CFG_INT: r = (a->v.i == b->v.i);
        case DM_CFG_EMPTY_ARRAY: return 0;
        }
 
-       if (a->next && b->next)
-               return compare_value(a->next, b->next);
+       if (r == 0 && a->next && b->next)
+               r = compare_value(a->next, b->next);
+       return r;
 }
 
 static int compare_config(struct dm_config_node *a, struct dm_config_node *b)
@@ -226,7 +228,7 @@ static int compare_config(struct dm_config_node *a, struct dm_config_node *b)
 }
 
 /* You need to be holding the pvid_map lock already to call this. */
-int update_pvid_map(lvmetad_state *s, struct dm_config_tree *vg, const char *vgid)
+static int update_pvid_map(lvmetad_state *s, struct dm_config_tree *vg, const char *vgid)
 {
        struct dm_config_node *pv = pvs(vg->root);
 
@@ -234,8 +236,8 @@ int update_pvid_map(lvmetad_state *s, struct dm_config_tree *vg, const char *vgi
                return 0;
 
        while (pv) {
-               char *pvid = dm_config_find_str(pv->child, "id", NULL);
-               dm_hash_insert(s->pvid_map, pvid, vgid);
+               const char *pvid = dm_config_find_str(pv->child, "id", NULL);
+               dm_hash_insert(s->pvid_map, pvid, (void *) vgid);
                pv = pv->sib;
        }
 

diff --git a/libdm/libdevmapper.h b/libdm/libdevmapper.h
index 62f56ae9bb788ac634cb167d527331f94e7ae920..6529b467ce1321559b7b4d976021565d88ff26a5 100644 (file)
--- a/libdm/libdevmapper.h
+++ b/libdm/libdevmapper.h
@@ -1275,7 +1275,7 @@ int dm_config_write_node(const struct dm_config_node *cn, dm_putline_fn putline,
 time_t dm_config_timestamp(struct dm_config_tree *cft);
 int dm_config_changed(struct dm_config_tree *cft);
 
-const struct dm_config_node *dm_config_find_node(const struct dm_config_node *cn, const char *path);
+struct dm_config_node *dm_config_find_node(const struct dm_config_node *cn, const char *path);
 const char *dm_config_find_str(const struct dm_config_node *cn, const char *path, const char *fail);
 int dm_config_find_int(const struct dm_config_node *cn, const char *path, int fail);
 float dm_config_find_float(const struct dm_config_node *cn, const char *path, float fail);

diff --git a/libdm/libdm-config.c b/libdm/libdm-config.c
index 688d9a7c4b64f2f9f7974abeff64734824f57c77..d6a3fe69fc21637bddfa814ac6487644e7bd3e7b 100644 (file)
--- a/libdm/libdm-config.c
+++ b/libdm/libdm-config.c
@@ -809,8 +809,8 @@ static char *_dup_tok(struct parser *p)
 /*
  * utility functions
  */
-static const struct dm_config_node *_find_config_node(const void *start,
-                                                     const char *path)
+static struct dm_config_node *_find_config_node(const void *start,
+                                               const char *path)
 {
        const char *e;
        const struct dm_config_node *cn = start;
@@ -848,15 +848,15 @@ static const struct dm_config_node *_find_config_node(const void *start,
                path = e;
        }
 
-       return cn_found;
+       return (struct dm_config_node *) cn_found;
 }
 
-typedef const struct dm_config_node *_node_lookup_fn(const void *start, const char *path);
+typedef struct dm_config_node *_node_lookup_fn(const void *start, const char *path);
 
-static const struct dm_config_node *_find_first_config_node(const void *start, const char *path)
+static struct dm_config_node *_find_first_config_node(const void *start, const char *path)
 {
        const struct dm_config_tree *cft = start;
-       const struct dm_config_node *cn = NULL;
+       struct dm_config_node *cn = NULL;
 
        while (cft) {
                if ((cn = _find_config_node(cft->root, path)))
@@ -973,8 +973,8 @@ static int _find_config_bool(const void *start, _node_lookup_fn find,
  * node-based lookup
  **/
 
-const struct dm_config_node *dm_config_find_node(const struct dm_config_node *cn,
-                                                const char *path)
+struct dm_config_node *dm_config_find_node(const struct dm_config_node *cn,
+                                          const char *path)
 {
        return _find_config_node(cn, path);
 }