tools/xenstore: add wrapper for tdb_fetch()

Add a wrapper function for tdb_fetch taking the name of the node in
the data base as a parameter. Let it return a data pointer and the
length of the data via a length pointer provided as additional
parameter.

Move logging of the TDB access from the callers into the wrapper.

This enables to make set_tdb_key() and tdb_ctx static.

This is in preparation to replace TDB with a more simple data storage.

Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Julien Grall <jgrall@amazon.com>

diff --git a/tools/xenstore/xenstored_core.c b/tools/xenstore/xenstored_core.c
index dab09b52366033c9569950858b6d757256235e6b..a12ede147c27fe09e4720da6a05a2d4314c496da 100644 (file)
--- a/tools/xenstore/xenstored_core.c
+++ b/tools/xenstore/xenstored_core.c
@@ -85,7 +85,7 @@ bool keep_orphans = false;
 static int reopen_log_pipe[2];
 static int reopen_log_pipe0_pollfd_idx = -1;
 char *tracefile = NULL;
-TDB_CONTEXT *tdb_ctx = NULL;
+static TDB_CONTEXT *tdb_ctx = NULL;
 unsigned int trace_flags = TRACE_OBJ | TRACE_IO;
 
 static const char *sockmsg_string(enum xsd_sockmsg_type type);
@@ -556,7 +556,7 @@ static void initialize_fds(int *p_sock_pollfd_idx, int *ptimeout)
        }
 }
 
-void set_tdb_key(const char *name, TDB_DATA *key)
+static void set_tdb_key(const char *name, TDB_DATA *key)
 {
        /*
         * Dropping const is fine here, as the key will never be modified
@@ -566,25 +566,39 @@ void set_tdb_key(const char *name, TDB_DATA *key)
        key->dsize = strlen(name);
 }
 
+struct xs_tdb_record_hdr *db_fetch(const char *db_name, size_t *size)
+{
+       TDB_DATA key, data;
+
+       set_tdb_key(db_name, &key);
+       data = tdb_fetch(tdb_ctx, key);
+       if (!data.dptr) {
+               errno = (tdb_error(tdb_ctx) == TDB_ERR_NOEXIST) ? ENOENT : EIO;
+               *size = 0;
+       } else {
+               *size = data.dsize;
+               trace_tdb("read %s size %zu\n", db_name,
+                         *size + strlen(db_name));
+       }
+
+       return (struct xs_tdb_record_hdr *)data.dptr;
+}
+
 static void get_acc_data(const char *name, struct node_account_data *acc)
 {
-       TDB_DATA key, old_data;
+       size_t size;
        struct xs_tdb_record_hdr *hdr;
 
        if (acc->memory < 0) {
-               set_tdb_key(name, &key);
-               old_data = tdb_fetch(tdb_ctx, key);
+               hdr = db_fetch(name, &size);
                /* No check for error, as the node might not exist. */
-               if (old_data.dptr == NULL) {
+               if (hdr == NULL) {
                        acc->memory = 0;
                } else {
-                       trace_tdb("read %s size %zu\n", name,
-                                 old_data.dsize + key.dsize);
-                       hdr = (void *)old_data.dptr;
-                       acc->memory = old_data.dsize;
+                       acc->memory = size;
                        acc->domid = hdr->perms[0].id;
                }
-               talloc_free(old_data.dptr);
+               talloc_free(hdr);
        }
 }
 
@@ -698,7 +712,7 @@ int db_delete(struct connection *conn, const char *name,
 struct node *read_node(struct connection *conn, const void *ctx,
                       const char *name)
 {
-       TDB_DATA key, data;
+       size_t size;
        struct xs_tdb_record_hdr *hdr;
        struct node *node;
        const char *db_name;
@@ -717,29 +731,24 @@ struct node *read_node(struct connection *conn, const void *ctx,
        }
 
        db_name = transaction_prepend(conn, name);
-       set_tdb_key(db_name, &key);
+       hdr = db_fetch(db_name, &size);
 
-       data = tdb_fetch(tdb_ctx, key);
-
-       if (data.dptr == NULL) {
-               if (tdb_error(tdb_ctx) == TDB_ERR_NOEXIST) {
+       if (hdr == NULL) {
+               if (errno == ENOENT) {
                        node->generation = NO_GENERATION;
                        err = access_node(conn, node, NODE_ACCESS_READ, NULL);
                        errno = err ? : ENOENT;
                } else {
-                       log("TDB error on read: %s", tdb_errorstr(tdb_ctx));
+                       log("DB error on read: %s", strerror(errno));
                        errno = EIO;
                }
                goto error;
        }
 
-       trace_tdb("read %s size %zu\n", key.dptr, data.dsize + key.dsize);
-
        node->parent = NULL;
-       talloc_steal(node, data.dptr);
+       talloc_steal(node, hdr);
 
        /* Datalen, childlen, number of permissions */
-       hdr = (void *)data.dptr;
        node->generation = hdr->generation;
        node->perms.num = hdr->num_perms;
        node->datalen = hdr->datalen;
@@ -748,7 +757,7 @@ struct node *read_node(struct connection *conn, const void *ctx,
        /* Permissions are struct xs_permissions. */
        node->perms.p = hdr->perms;
        node->acc.domid = get_node_owner(node);
-       node->acc.memory = data.dsize;
+       node->acc.memory = size;
        if (domain_adjust_node_perms(node))
                goto error;
 

diff --git a/tools/xenstore/xenstored_core.h b/tools/xenstore/xenstored_core.h
index 875ee5192bad69a90fdf8ca4b8377d70eb44603a..f5aa8d51a07543582228be28de7c85d6e6a13473 100644 (file)
--- a/tools/xenstore/xenstored_core.h
+++ b/tools/xenstore/xenstored_core.h
@@ -315,7 +315,6 @@ do {                                                \
                trace("tdb: " __VA_ARGS__);     \
 } while (0)
 
-extern TDB_CONTEXT *tdb_ctx;
 extern int dom0_domid;
 extern int dom0_event;
 extern int priv_domid;
@@ -364,7 +363,7 @@ extern xengnttab_handle **xgt_handle;
 int remember_string(struct hashtable *hash, const char *str);
 
 /* Data base access functions. */
-void set_tdb_key(const char *name, TDB_DATA *key);
+struct xs_tdb_record_hdr *db_fetch(const char *db_name, size_t *size);
 int db_write(struct connection *conn, const char *db_name, void *data,
             size_t size, struct node_account_data *acc,
             enum write_node_mode mode, bool no_quota_check);

diff --git a/tools/xenstore/xenstored_transaction.c b/tools/xenstore/xenstored_transaction.c
index 1961aef0d70e5e21be9c43276522795121d101ec..1981d1d55def7dd39c9cf2e4d6093baf27fc239e 100644 (file)
--- a/tools/xenstore/xenstored_transaction.c
+++ b/tools/xenstore/xenstored_transaction.c
@@ -356,25 +356,21 @@ static int finalize_transaction(struct connection *conn,
                                struct transaction *trans, bool *is_corrupt)
 {
        struct accessed_node *i, *n;
-       TDB_DATA key, ta_key, data;
+       size_t size;
        struct xs_tdb_record_hdr *hdr;
        uint64_t gen;
 
        list_for_each_entry_safe(i, n, &trans->accessed, list) {
                if (i->check_gen) {
-                       set_tdb_key(i->node, &key);
-                       data = tdb_fetch(tdb_ctx, key);
-                       hdr = (void *)data.dptr;
-                       if (!data.dptr) {
-                               if (tdb_error(tdb_ctx) != TDB_ERR_NOEXIST)
-                                       return EIO;
+                       hdr = db_fetch(i->node, &size);
+                       if (!hdr) {
+                               if (errno != ENOENT)
+                                       return errno;
                                gen = NO_GENERATION;
                        } else {
-                               trace_tdb("read %s size %zu\n", key.dptr,
-                                         key.dsize + data.dsize);
                                gen = hdr->generation;
                        }
-                       talloc_free(data.dptr);
+                       talloc_free(hdr);
                        if (i->generation != gen)
                                return EAGAIN;
                }
@@ -392,21 +388,16 @@ static int finalize_transaction(struct connection *conn,
 
        while ((i = list_top(&trans->accessed, struct accessed_node, list))) {
                if (i->ta_node) {
-                       set_tdb_key(i->trans_name, &ta_key);
-                       data = tdb_fetch(tdb_ctx, ta_key);
-                       if (data.dptr) {
+                       hdr = db_fetch(i->trans_name, &size);
+                       if (hdr) {
                                enum write_node_mode mode;
 
-                               trace_tdb("read %s size %zu\n", ta_key.dptr,
-                                         ta_key.dsize + data.dsize);
-                               hdr = (void *)data.dptr;
                                hdr->generation = ++generation;
                                mode = (i->generation == NO_GENERATION)
                                       ? NODE_CREATE : NODE_MODIFY;
-                               *is_corrupt |= db_write(conn, i->node,
-                                                       data.dptr, data.dsize,
-                                                       NULL, mode, true);
-                               talloc_free(data.dptr);
+                               *is_corrupt |= db_write(conn, i->node, hdr,
+                                                       size, NULL, mode, true);
+                               talloc_free(hdr);
                                if (db_delete(conn, i->trans_name, NULL))
                                        *is_corrupt = true;
                        } else {