WIP: debug

diff --git a/contrib/ucw/mempool.c b/contrib/ucw/mempool.c
index b80c4742f8b38ade718afc2d13b6897ebd990240..99722bba63e20f4fa1b301660255c453913afb92 100644 (file)
--- a/contrib/ucw/mempool.c
+++ b/contrib/ucw/mempool.c
@@ -158,6 +158,7 @@ mp_new(unsigned chunk_size)
                .threshold = chunk_size >> 1,
                .last_big = &pool->last_big
        };
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        return pool;
 }
 
@@ -189,6 +190,7 @@ mp_delete(struct mempool *pool)
        if (pool == NULL) {
                return;
        }
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        DBG("Deleting mempool %p", pool);
        mp_free_big_chain(pool->state.last[1]);
        mp_free_chain(pool->unused);
@@ -198,6 +200,7 @@ mp_delete(struct mempool *pool)
 void
 mp_flush(struct mempool *pool)
 {
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        mp_free_big_chain(pool->state.last[1]);
        struct mempool_chunk *chunk = pool->state.last[0], *next;
        while (chunk) {
@@ -229,6 +232,7 @@ mp_flush(struct mempool *pool)
        pool->state.last[1] = NULL;
        pool->state.free[1] = 0;
        pool->last_big = &pool->last_big;
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
 }
 
 static void
@@ -249,6 +253,7 @@ mp_stats_chain(struct mempool_chunk *chunk, struct mempool_stats *stats, unsigne
 void
 mp_stats(struct mempool *pool, struct mempool_stats *stats)
 {
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        bzero(stats, sizeof(*stats));
        mp_stats_chain(pool->state.last[0], stats, 0);
        mp_stats_chain(pool->state.last[1], stats, 1);
@@ -258,6 +263,7 @@ mp_stats(struct mempool *pool, struct mempool_stats *stats)
 uint64_t
 mp_total_size(struct mempool *pool)
 {
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        struct mempool_stats stats;
        mp_stats(pool, &stats);
        return stats.total_size;
@@ -266,6 +272,7 @@ mp_total_size(struct mempool *pool)
 static void *
 mp_alloc_internal(struct mempool *pool, unsigned size)
 {
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        struct mempool_chunk *chunk;
        if (size <= pool->threshold) {
                pool->idx = 0;
@@ -306,22 +313,27 @@ mp_alloc_internal(struct mempool *pool, unsigned size)
 void *
 mp_alloc(struct mempool *pool, unsigned size)
 {
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        unsigned avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1);
+       VALGRIND_CHECK_MEM_IS_DEFINED(&avail, sizeof(unsigned)); // TODO
        void *ptr = NULL;
        if (size <= avail) {
                pool->state.free[0] = avail - size;
+               VALGRIND_CHECK_MEM_IS_DEFINED(pool->state.last[0], sizeof(uint8_t *));
                ptr = (uint8_t*)pool->state.last[0] - avail;
                VALGRIND_MEMPOOL_ALLOC(pool->state.last[0], ptr, size);
        } else {
                ptr = mp_alloc_internal(pool, size);
        }
        ASAN_UNPOISON_MEMORY_REGION(ptr, size);
+       VALGRIND_CHECK_MEM_IS_ADDRESSABLE(ptr, size);
        return ptr;
 }
 
 void *
 mp_alloc_noalign(struct mempool *pool, unsigned size)
 {
+       VALGRIND_CHECK_MEM_IS_DEFINED(pool, sizeof(pool)); // TODO
        void *ptr = NULL;
        if (size <= pool->state.free[0]) {
                ptr = (uint8_t*)pool->state.last[0] - pool->state.free[0];
@@ -331,6 +343,7 @@ mp_alloc_noalign(struct mempool *pool, unsigned size)
                ptr = mp_alloc_internal(pool, size);
        }
        ASAN_UNPOISON_MEMORY_REGION(ptr, size);
+       VALGRIND_CHECK_MEM_IS_ADDRESSABLE(ptr, size);
        return ptr;
 }
 

diff --git a/daemon/worker.c b/daemon/worker.c
index 23abe92fd19cf20b5c62423293fae2218a220d76..5c83b0f8f578227f456fc761c0d41a9d1d6e0235 100644 (file)
--- a/daemon/worker.c
+++ b/daemon/worker.c
@@ -25,6 +25,7 @@
 #include <contrib/macros.h>
 #include <contrib/ucw/mempool.h>
 #include <contrib/wire.h>
+#include <contrib/memcheck.h>
 #if defined(__GLIBC__) && defined(_GNU_SOURCE)
 #include <malloc.h>
 #endif
@@ -1542,6 +1543,23 @@ static int qr_task_step(struct qr_task *task,
        return ret;
 }
 
+static void check_rrset(const knot_rrset_t      *rrset)
+{
+       VALGRIND_CHECK_MEM_IS_DEFINED(rrset, sizeof(rrset));
+       //VALGRIND_CHECK_MEM_IS_DEFINED(rrset->rrs, sizeof(rrset->rrs));
+        uint16_t rr_count = rrset->rrs.count;
+        knot_rdata_t *rr = rrset->rrs.rdata;
+        // Loop over rdata in rrset.
+        for (uint16_t i = 0; i < rr_count; i++) {
+               VALGRIND_CHECK_MEM_IS_DEFINED(&rr->len, sizeof(rr->len));
+               if (rr->len > 0)
+                       VALGRIND_CHECK_MEM_IS_DEFINED(rr->data, rr->len);
+
+               rr = knot_rdataset_next(rr);
+        }
+}
+
+
 static int parse_packet(knot_pkt_t *query)
 {
        if (!query){
@@ -1551,12 +1569,16 @@ static int parse_packet(knot_pkt_t *query)
        /* Parse query packet. */
        int ret = knot_pkt_parse(query, 0);
        if (ret == KNOT_ETRAIL) {
+               if (query->rrset_count > 0)  // TODO
+                       check_rrset(query->rr);
                /* Extra data after message end. */
                ret = kr_error(EMSGSIZE);
        } else if (ret != KNOT_EOK) {
                /* Malformed query. */
                ret = kr_error(EPROTO);
        } else {
+               if (query->rrset_count > 0)  // TODO
+                       check_rrset(query->rr);
                ret = kr_ok();
        }
 

diff --git a/lib/cache/api.c b/lib/cache/api.c
index adc3f319682b2219b95f6c6d97ded37fe7d3081c..fd0b7e488f9c25ffee9e1514e5140ff6ce4b86f1 100644 (file)
--- a/lib/cache/api.c
+++ b/lib/cache/api.c
@@ -30,6 +30,7 @@
 #include "contrib/base32hex.h"
 #include "contrib/cleanup.h"
 #include "contrib/macros.h"
+#include "contrib/memcheck.h"
 #include "lib/cache/api.h"
 #include "lib/cache/cdb_lmdb.h"
 #include "lib/defines.h"
@@ -593,6 +594,7 @@ static ssize_t stash_rrset(struct kr_cache *cache, const struct kr_query *qry,
        eh->time = timestamp;
        eh->ttl  = MAX(MIN(ttl, cache->ttl_max), cache->ttl_min);
        eh->rank = rank;
+       VALGRIND_CHECK_MEM_IS_ADDRESSABLE(val_new_entry.data, val_new_entry.len);
        if (rdataset_dematerialize(&rr->rrs, eh->data)
            || rdataset_dematerialize(rds_sigs, eh->data + rr_ssize)) {
                /* minimize the damage from incomplete write; TODO: better */
@@ -601,7 +603,9 @@ static ssize_t stash_rrset(struct kr_cache *cache, const struct kr_query *qry,
                eh->rank = 0;
                assert(false);
        }
+       VALGRIND_CHECK_MEM_IS_DEFINED(val_new_entry.data, val_new_entry.len);
        assert(entry_h_consistent_E(val_new_entry, rr->type));
+       VALGRIND_CHECK_MEM_IS_DEFINED(val_new_entry.data, val_new_entry.len);
 
        #if 0 /* Occasionally useful when debugging some kinds of changes. */
        {
@@ -628,6 +632,7 @@ static ssize_t stash_rrset(struct kr_cache *cache, const struct kr_query *qry,
                        );
        } }
 
+       VALGRIND_CHECK_MEM_IS_DEFINED(val_new_entry.data, val_new_entry.len);
        return (ssize_t) val_new_entry.len;
 return_needs_pkt:
        if (needs_pkt) *needs_pkt = true;

diff --git a/lib/cache/cdb_lmdb.c b/lib/cache/cdb_lmdb.c
index 2b469d1074ac6adcc3e3b1e13477b91aca883430..456111323cdea3096e8a6751662dd812e72774c4 100644 (file)
--- a/lib/cache/cdb_lmdb.c
+++ b/lib/cache/cdb_lmdb.c
@@ -312,7 +312,8 @@ static int cdb_open(struct lmdb_env *env, const char *path, size_t mapsize,
 {
        /* Cache doesn't require durability, we can be
         * loose with the requirements as a tradeoff for speed. */
-       const unsigned flags = MDB_WRITEMAP | MDB_MAPASYNC | MDB_NOTLS;
+       const unsigned flags = MDB_NOTLS; // TODO
+       // const unsigned flags = MDB_WRITEMAP | MDB_MAPASYNC | MDB_NOTLS; 
        int ret = cdb_open_env(env, flags, path, mapsize, stats);
        if (ret != 0) {
                return ret;
@@ -519,7 +520,7 @@ static int cdb_readv(knot_db_t *db, struct kr_cdb_stats *stats,
                        }
                        return ret;
                }
-               VALGRIND_CHECK_MEM_IS_DEFINED(_val.mv_data, _val.mv_size);
+               VALGRIND_MAKE_MEM_DEFINED(_val.mv_data, _val.mv_size);
                /* Update the result. */
                val[i] = val_mdb2knot(_val);
        }

diff --git a/lib/cache/entry_list.c b/lib/cache/entry_list.c
index 3d0d8165d45c6850c0f0f83e5b9a9652e00b5508..860df12c12dfedc6d2bcdc48173cdbc7bfee4946 100644 (file)
--- a/lib/cache/entry_list.c
+++ b/lib/cache/entry_list.c
@@ -20,6 +20,7 @@
 
 #include "lib/cache/impl.h"
 #include "lib/utils.h"
+#include "contrib/memcheck.h"
 
 
 static int entry_h_len(knot_db_val_t val);
@@ -28,6 +29,7 @@ static int entry_h_len(knot_db_val_t val);
 void entry_list_memcpy(struct entry_apex *ea, entry_list_t list)
 {
        assert(ea);
+       VALGRIND_CHECK_MEM_IS_DEFINED(list, sizeof(entry_list_t));
        memset(ea, 0, offsetof(struct entry_apex, data));
        ea->has_ns      = list[EL_NS    ].len;
        ea->has_cname   = list[EL_CNAME ].len;
@@ -39,6 +41,7 @@ void entry_list_memcpy(struct entry_apex *ea, entry_list_t list)
        uint8_t *it = ea->data;
        for (int i = 0; i < EL_LENGTH; ++i) {
                if (list[i].data) {
+                       VALGRIND_CHECK_MEM_IS_DEFINED(list[i].data, list[i].len);
                        memcpy(it, list[i].data, list[i].len);
                        /* LATER(optim.): coalesce consecutive writes? */
                } else {

diff --git a/lib/cache/entry_rr.c b/lib/cache/entry_rr.c
index 94dd0e83e702c1465f9b8e0f51cc390c09d07ec5..0984ae4c99ebd7de065f3a03d122c96fec5367ed 100644 (file)
--- a/lib/cache/entry_rr.c
+++ b/lib/cache/entry_rr.c
@@ -20,6 +20,7 @@
  */
 
 #include "lib/cache/impl.h"
+#include "contrib/memcheck.h"
 
 int rdataset_dematerialize(const knot_rdataset_t *rds, uint8_t * restrict data)
 {
@@ -37,6 +38,7 @@ int rdataset_dematerialize(const knot_rdataset_t *rds, uint8_t * restrict data)
        data += sizeof(rr_count);
        if (rr_count) {
                size_t size = knot_rdataset_size(rds);
+               VALGRIND_CHECK_MEM_IS_DEFINED(rds->rdata, size);
                memcpy(data, rds->rdata, size);
                data += size;
        }