added debug constants to allow for better mapping to syslog levels

diff --git a/client/ctdb_client.c b/client/ctdb_client.c
index fdd2b99f80a4c250999e751024fd6f0ddcff904f..2cdec005e9cc2ca8489977815b9855d0602a1e9f 100644 (file)
--- a/client/ctdb_client.c
+++ b/client/ctdb_client.c
@@ -202,7 +202,7 @@ static void ctdb_client_read_cb(uint8_t *data, size_t cnt, void *args)
        talloc_steal(tmp_ctx, hdr);
 
        if (cnt == 0) {
-               DEBUG(2,("Daemon has exited - shutting down client\n"));
+               DEBUG(DEBUG_INFO,("Daemon has exited - shutting down client\n"));
                exit(0);
        }
 
@@ -585,7 +585,7 @@ struct ctdb_record_handle *ctdb_fetch_lock(struct ctdb_db_context *ctdb_db, TALL
        }
        h->data    = data;
 
-       DEBUG(3,("ctdb_fetch_lock: key=%*.*s\n", (int)key.dsize, (int)key.dsize, 
+       DEBUG(DEBUG_DEBUG,("ctdb_fetch_lock: key=%*.*s\n", (int)key.dsize, (int)key.dsize, 
                 (const char *)key.dptr));
 
 again:
@@ -597,7 +597,7 @@ again:
                return NULL;
        }
 
-       DEBUG(4,("ctdb_fetch_lock: got chain lock\n"));
+       DEBUG(DEBUG_DEBUG,("ctdb_fetch_lock: got chain lock\n"));
 
        talloc_set_destructor(h, fetch_lock_destructor);
 
@@ -610,20 +610,20 @@ again:
        }
 
 
-       DEBUG(4,("ctdb_fetch_lock: done local fetch\n"));
+       DEBUG(DEBUG_DEBUG,("ctdb_fetch_lock: done local fetch\n"));
 
        if (ret != 0 || h->header.dmaster != ctdb_db->ctdb->pnn) {
                ctdb_ltdb_unlock(ctdb_db, key);
                ret = ctdb_client_force_migration(ctdb_db, key);
                if (ret != 0) {
-                       DEBUG(4,("ctdb_fetch_lock: force_migration failed\n"));
+                       DEBUG(DEBUG_DEBUG,("ctdb_fetch_lock: force_migration failed\n"));
                        talloc_free(h);
                        return NULL;
                }
                goto again;
        }
 
-       DEBUG(4,("ctdb_fetch_lock: we are dmaster - done\n"));
+       DEBUG(DEBUG_DEBUG,("ctdb_fetch_lock: we are dmaster - done\n"));
        return h;
 }
 

diff --git a/common/ctdb_util.c b/common/ctdb_util.c
index 7f7c1a0c8a63d6c3e5cc8c888ac9e6bed8583d43..6724bfc2ec1a25cf3170baba2e8a36caa9319fc0 100644 (file)
--- a/common/ctdb_util.c
+++ b/common/ctdb_util.c
@@ -25,7 +25,8 @@
 #include "system/wait.h"
 #include "../include/ctdb_private.h"
 
-int LogLevel;
+int LogLevel = DEBUG_NOTICE;
+int this_log_level = 0;
 
 /*
   return error string for last error
@@ -54,7 +55,7 @@ void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...)
 */
 void ctdb_fatal(struct ctdb_context *ctdb, const char *msg)
 {
-       DEBUG(0,("ctdb fatal error: %s\n", msg));
+       DEBUG(DEBUG_ALERT,("ctdb fatal error: %s\n", msg));
        abort();
 }
 
@@ -226,7 +227,7 @@ void ctdb_set_scheduler(struct ctdb_context *ctdb)
                DEBUG(0,("Unable to set scheduler to SCHED_FIFO (%s)\n", 
                         strerror(errno)));
        } else {
-               DEBUG(0,("Set scheduler to SCHED_FIFO\n"));
+               DEBUG(DEBUG_NOTICE,("Set scheduler to SCHED_FIFO\n"));
        }
 #endif
 }

diff --git a/common/system_linux.c b/common/system_linux.c
index bd44bd75b40ceb6b450e8d9cc8f0db1b665338d0..7017875fed40beb6491ed0e729f04ac5e66addb4 100644 (file)
--- a/common/system_linux.c
+++ b/common/system_linux.c
@@ -68,7 +68,7 @@ int ctdb_sys_send_arp(const struct sockaddr_in *saddr, const char *iface)
                return -1;
        }
        if (ARPHRD_LOOPBACK == if_hwaddr.ifr_hwaddr.sa_family) {
-               DEBUG(3,("Ignoring loopback arp request\n"));
+               DEBUG(DEBUG_DEBUG,("Ignoring loopback arp request\n"));
                close(s);
                return 0;
        }

diff --git a/ib/ibw_ctdb.c b/ib/ibw_ctdb.c
index 5822ffb1865d53f87c3f38fe232440567faa7c35..d931c2dd0f2e2905a277a56b202fe6afc8a1aba6 100644 (file)
--- a/ib/ibw_ctdb.c
+++ b/ib/ibw_ctdb.c
@@ -136,7 +136,7 @@ int ctdb_ibw_connstate_handler(struct ibw_ctx *ctx, struct ibw_conn *conn)
                                struct ctdb_ibw_node *cn = talloc_get_type(node->private_data, struct ctdb_ibw_node);
                                struct ibw_ctx *ictx = cn->conn->ctx;
 
-                               DEBUG(10, ("IBWC_ERROR, reconnecting...\n"));
+                               DEBUG(DEBUG_DEBUG, ("IBWC_ERROR, reconnecting...\n"));
                                talloc_free(cn->conn); /* internal queue content is destroyed */
                                cn->conn = (void *)ibw_conn_new(ictx, node);
                                event_add_timed(node->ctdb->ev, node, timeval_current_ofs(1, 0),

diff --git a/ib/ibw_ctdb_init.c b/ib/ibw_ctdb_init.c
index 28b7a0374c63f7300798ad7b2be7921938698094..d1693550c14d28b4d1cd9f6a82180f353ca90891 100644 (file)
--- a/ib/ibw_ctdb_init.c
+++ b/ib/ibw_ctdb_init.c
@@ -222,7 +222,7 @@ int ctdb_ibw_init(struct ctdb_context *ctdb)
 {
        struct ibw_ctx *ictx;
 
-       DEBUG(10, ("ctdb_ibw_init invoked...\n"));
+       DEBUG(DEBUG_DEBUG, ("ctdb_ibw_init invoked...\n"));
        ictx = ibw_init(
                NULL, //struct ibw_initattr *attr, /* TODO */
                0, //int nattr, /* TODO */
@@ -239,6 +239,6 @@ int ctdb_ibw_init(struct ctdb_context *ctdb)
        ctdb->methods = &ctdb_ibw_methods;
        ctdb->private_data = ictx;
        
-       DEBUG(10, ("ctdb_ibw_init succeeded.\n"));
+       DEBUG(DEBUG_DEBUG, ("ctdb_ibw_init succeeded.\n"));
        return 0;
 }

diff --git a/ib/ibwrapper.c b/ib/ibwrapper.c
index 31acbc4a2d121380c08514e1627ea4ef57a8fb75..981ac5af83ea4d455b3525b6938ab12e72d3ada6 100644 (file)
--- a/ib/ibwrapper.c
+++ b/ib/ibwrapper.c
@@ -64,7 +64,7 @@ static void *ibw_alloc_mr(struct ibw_ctx_priv *pctx, struct ibw_conn_priv *pconn
 {
        void *buf;
 
-       DEBUG(10, ("ibw_alloc_mr(cmid=%p, n=%u)\n", pconn->cm_id, n));
+       DEBUG(DEBUG_DEBUG, ("ibw_alloc_mr(cmid=%p, n=%u)\n", pconn->cm_id, n));
        buf = memalign(pctx->pagesize, n);
        if (!buf) {
                sprintf(ibw_lasterr, "couldn't allocate memory\n");
@@ -83,7 +83,7 @@ static void *ibw_alloc_mr(struct ibw_ctx_priv *pctx, struct ibw_conn_priv *pconn
 
 static void ibw_free_mr(char **ppbuf, struct ibv_mr **ppmr)
 {
-       DEBUG(10, ("ibw_free_mr(%p %p)\n", *ppbuf, *ppmr));
+       DEBUG(DEBUG_DEBUG, ("ibw_free_mr(%p %p)\n", *ppbuf, *ppmr));
        if (*ppmr!=NULL) {
                ibv_dereg_mr(*ppmr);
                *ppmr = NULL;
@@ -102,7 +102,7 @@ static int ibw_init_memory(struct ibw_conn *conn)
        int     i;
        struct ibw_wr   *p;
 
-       DEBUG(10, ("ibw_init_memory(cmid: %p)\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_init_memory(cmid: %p)\n", pconn->cm_id));
        pconn->buf_send = ibw_alloc_mr(pctx, pconn,
                opts->max_send_wr * opts->recv_bufsize, &pconn->mr_send);
        if (!pconn->buf_send) {
@@ -133,7 +133,7 @@ static int ibw_init_memory(struct ibw_conn *conn)
 
 static int ibw_ctx_priv_destruct(struct ibw_ctx_priv *pctx)
 {
-       DEBUG(10, ("ibw_ctx_priv_destruct(%p)\n", pctx));
+       DEBUG(DEBUG_DEBUG, ("ibw_ctx_priv_destruct(%p)\n", pctx));
 
        /* destroy cm */
        if (pctx->cm_channel) {
@@ -155,13 +155,13 @@ static int ibw_ctx_priv_destruct(struct ibw_ctx_priv *pctx)
 
 static int ibw_ctx_destruct(struct ibw_ctx *ctx)
 {
-       DEBUG(10, ("ibw_ctx_destruct(%p)\n", ctx));
+       DEBUG(DEBUG_DEBUG, ("ibw_ctx_destruct(%p)\n", ctx));
        return 0;
 }
 
 static int ibw_conn_priv_destruct(struct ibw_conn_priv *pconn)
 {
-       DEBUG(10, ("ibw_conn_priv_destruct(%p, cmid: %p)\n",
+       DEBUG(DEBUG_DEBUG, ("ibw_conn_priv_destruct(%p, cmid: %p)\n",
                pconn, pconn->cm_id));
 
        /* pconn->wr_index is freed by talloc */
@@ -196,13 +196,13 @@ static int ibw_conn_priv_destruct(struct ibw_conn_priv *pconn)
        if (pconn->pd) {
                ibv_dealloc_pd(pconn->pd);
                pconn->pd = NULL;
-               DEBUG(10, ("pconn=%p pd deallocated\n", pconn));
+               DEBUG(DEBUG_DEBUG, ("pconn=%p pd deallocated\n", pconn));
        }
 
        if (pconn->cm_id) {
                rdma_destroy_id(pconn->cm_id);
                pconn->cm_id = NULL;
-               DEBUG(10, ("pconn=%p cm_id destroyed\n", pconn));
+               DEBUG(DEBUG_DEBUG, ("pconn=%p cm_id destroyed\n", pconn));
        }
 
        return 0;
@@ -217,7 +217,7 @@ static int ibw_wr_destruct(struct ibw_wr *wr)
 
 static int ibw_conn_destruct(struct ibw_conn *conn)
 {
-       DEBUG(10, ("ibw_conn_destruct(%p)\n", conn));
+       DEBUG(DEBUG_DEBUG, ("ibw_conn_destruct(%p)\n", conn));
        
        /* important here: ctx is a talloc _parent_ */
        DLIST_REMOVE(conn->ctx->conn_list, conn);
@@ -255,7 +255,7 @@ static int ibw_setup_cq_qp(struct ibw_conn *conn)
        struct ibv_qp_attr attr;
        int rc;
 
-       DEBUG(10, ("ibw_setup_cq_qp(cmid: %p)\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_setup_cq_qp(cmid: %p)\n", pconn->cm_id));
 
        /* init verbs */
        pconn->verbs_channel = ibv_create_comp_channel(pconn->cm_id->verbs);
@@ -263,7 +263,7 @@ static int ibw_setup_cq_qp(struct ibw_conn *conn)
                sprintf(ibw_lasterr, "ibv_create_comp_channel failed %d\n", errno);
                return -1;
        }
-       DEBUG(10, ("created channel %p\n", pconn->verbs_channel));
+       DEBUG(DEBUG_DEBUG, ("created channel %p\n", pconn->verbs_channel));
 
        pconn->verbs_channel_event = event_add_fd(pctx->ectx, NULL, /* not pconn or conn */
                pconn->verbs_channel->fd, EVENT_FD_READ, ibw_event_handler_verbs, conn);
@@ -273,7 +273,7 @@ static int ibw_setup_cq_qp(struct ibw_conn *conn)
                sprintf(ibw_lasterr, "ibv_alloc_pd failed %d\n", errno);
                return -1;
        }
-       DEBUG(10, ("created pd %p\n", pconn->pd));
+       DEBUG(DEBUG_DEBUG, ("created pd %p\n", pconn->pd));
 
        /* init mr */
        if (ibw_init_memory(conn))
@@ -337,7 +337,7 @@ static int ibw_refill_cq_recv(struct ibw_conn *conn)
        };
        struct ibv_recv_wr *bad_wr;
 
-       DEBUG(10, ("ibw_refill_cq_recv(cmid: %p)\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_refill_cq_recv(cmid: %p)\n", pconn->cm_id));
 
        list.addr = (uintptr_t) pconn->buf_recv + pctx->opts.recv_bufsize * pconn->recv_index;
        wr.wr_id = pconn->recv_index;
@@ -370,7 +370,7 @@ static int ibw_fill_cq(struct ibw_conn *conn)
        };
        struct ibv_recv_wr *bad_wr;
 
-       DEBUG(10, ("ibw_fill_cq(cmid: %p)\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_fill_cq(cmid: %p)\n", pconn->cm_id));
 
        for(i = pctx->opts.max_recv_wr; i!=0; i--) {
                list.addr = (uintptr_t) pconn->buf_recv + pctx->opts.recv_bufsize * pconn->recv_index;
@@ -394,7 +394,7 @@ static int ibw_manage_connect(struct ibw_conn *conn)
        struct ibw_conn_priv *pconn = talloc_get_type(conn->internal, struct ibw_conn_priv);
        int     rc;
 
-       DEBUG(10, ("ibw_manage_connect(cmid: %p)\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_manage_connect(cmid: %p)\n", pconn->cm_id));
 
        if (ibw_setup_cq_qp(conn))
                return -1;
@@ -434,12 +434,12 @@ static void ibw_event_handler_cm(struct event_context *ev,
        }
        cma_id = event->id;
 
-       DEBUG(10, ("cma_event type %d cma_id %p (%s)\n", event->event, cma_id,
+       DEBUG(DEBUG_DEBUG, ("cma_event type %d cma_id %p (%s)\n", event->event, cma_id,
                  (cma_id == pctx->cm_id) ? "parent" : "child"));
 
        switch (event->event) {
        case RDMA_CM_EVENT_ADDR_RESOLVED:
-               DEBUG(11, ("RDMA_CM_EVENT_ADDR_RESOLVED\n"));
+               DEBUG(DEBUG_DEBUG, ("RDMA_CM_EVENT_ADDR_RESOLVED\n"));
                /* continuing from ibw_connect ... */
                rc = rdma_resolve_route(cma_id, 2000);
                if (rc) {
@@ -450,7 +450,7 @@ static void ibw_event_handler_cm(struct event_context *ev,
                break;
 
        case RDMA_CM_EVENT_ROUTE_RESOLVED:
-               DEBUG(11, ("RDMA_CM_EVENT_ROUTE_RESOLVED\n"));
+               DEBUG(DEBUG_DEBUG, ("RDMA_CM_EVENT_ROUTE_RESOLVED\n"));
                /* after RDMA_CM_EVENT_ADDR_RESOLVED: */
                assert(cma_id->context!=NULL);
                conn = talloc_get_type(cma_id->context, struct ibw_conn);
@@ -462,13 +462,13 @@ static void ibw_event_handler_cm(struct event_context *ev,
                break;
 
        case RDMA_CM_EVENT_CONNECT_REQUEST:
-               DEBUG(11, ("RDMA_CM_EVENT_CONNECT_REQUEST\n"));
+               DEBUG(DEBUG_DEBUG, ("RDMA_CM_EVENT_CONNECT_REQUEST\n"));
                ctx->state = IBWS_CONNECT_REQUEST;
                conn = ibw_conn_new(ctx, ctx);
                pconn = talloc_get_type(conn->internal, struct ibw_conn_priv);
                pconn->cm_id = cma_id; /* !!! event will be freed but id not */
                cma_id->context = (void *)conn;
-               DEBUG(10, ("pconn->cm_id %p\n", pconn->cm_id));
+               DEBUG(DEBUG_DEBUG, ("pconn->cm_id %p\n", pconn->cm_id));
 
                if (ibw_setup_cq_qp(conn))
                        goto error;
@@ -482,7 +482,7 @@ static void ibw_event_handler_cm(struct event_context *ev,
                        if (rc)
                                DEBUG(0, ("rdma_reject failed with rc=%d\n", rc));
                        talloc_free(conn);
-                       DEBUG(10, ("pconn->cm_id %p wasn't accepted\n", pconn->cm_id));
+                       DEBUG(DEBUG_DEBUG, ("pconn->cm_id %p wasn't accepted\n", pconn->cm_id));
                }
 
                /* TODO: clarify whether if it's needed by upper layer: */
@@ -494,11 +494,11 @@ static void ibw_event_handler_cm(struct event_context *ev,
 
        case RDMA_CM_EVENT_ESTABLISHED:
                /* expected after ibw_accept and ibw_connect[not directly] */
-               DEBUG(1, ("ESTABLISHED (conn: %p)\n", cma_id->context));
+               DEBUG(DEBUG_INFO, ("ESTABLISHED (conn: %p)\n", cma_id->context));
                conn = talloc_get_type(cma_id->context, struct ibw_conn);
                assert(conn!=NULL); /* important assumption */
 
-               DEBUG(10, ("ibw_setup_cq_qp succeeded (cmid=%p)\n", cma_id));
+               DEBUG(DEBUG_DEBUG, ("ibw_setup_cq_qp succeeded (cmid=%p)\n", cma_id));
 
                /* client conn is up */
                conn->state = IBWC_CONNECTED;
@@ -518,7 +518,7 @@ static void ibw_event_handler_cm(struct event_context *ev,
                goto error;
        case RDMA_CM_EVENT_REJECTED:
                sprintf(ibw_lasterr, "RDMA_CM_EVENT_REJECTED, error %d\n", event->status);
-               DEBUG(1, ("cm event handler: %s", ibw_lasterr));
+               DEBUG(DEBUG_INFO, ("cm event handler: %s", ibw_lasterr));
                conn = talloc_get_type(cma_id->context, struct ibw_conn);
                if (conn) {
                        /* must be done BEFORE connstate */
@@ -532,7 +532,7 @@ static void ibw_event_handler_cm(struct event_context *ev,
                break; /* this is not strictly an error */
 
        case RDMA_CM_EVENT_DISCONNECTED:
-               DEBUG(11, ("RDMA_CM_EVENT_DISCONNECTED\n"));
+               DEBUG(DEBUG_DEBUG, ("RDMA_CM_EVENT_DISCONNECTED\n"));
                if ((rc=rdma_ack_cm_event(event)))
                        DEBUG(0, ("disc/rdma_ack_cm_event failed with %d\n", rc));
                event = NULL; /* don't ack more */
@@ -595,7 +595,7 @@ static void ibw_event_handler_verbs(struct event_context *ev,
        struct ibv_cq *ev_cq;
        void          *ev_ctx;
 
-       DEBUG(10, ("ibw_event_handler_verbs(%u)\n", (uint32_t)flags));
+       DEBUG(DEBUG_DEBUG, ("ibw_event_handler_verbs(%u)\n", (uint32_t)flags));
 
        /* TODO: check whether if it's good to have more channels here... */
        rc = ibv_get_cq_event(pconn->verbs_channel, &ev_cq, &ev_ctx);
@@ -622,21 +622,21 @@ static void ibw_event_handler_verbs(struct event_context *ev,
 
                switch(wc.opcode) {
                case IBV_WC_SEND:
-                       DEBUG(10, ("send completion\n"));
+                       DEBUG(DEBUG_DEBUG, ("send completion\n"));
                        if (ibw_wc_send(conn, &wc))
                                goto error;
                        break;
 
                case IBV_WC_RDMA_WRITE:
-                       DEBUG(10, ("rdma write completion\n"));
+                       DEBUG(DEBUG_DEBUG, ("rdma write completion\n"));
                        break;
        
                case IBV_WC_RDMA_READ:
-                       DEBUG(10, ("rdma read completion\n"));
+                       DEBUG(DEBUG_DEBUG, ("rdma read completion\n"));
                        break;
 
                case IBV_WC_RECV:
-                       DEBUG(10, ("recv completion\n"));
+                       DEBUG(DEBUG_DEBUG, ("recv completion\n"));
                        if (ibw_wc_recv(conn, &wc))
                                goto error;
                        break;
@@ -688,7 +688,7 @@ static int ibw_process_queue(struct ibw_conn *conn)
        assert(p->queued_msg!=NULL);
        assert(msg_size!=0);
 
-       DEBUG(10, ("ibw_process_queue refcnt=%d msgsize=%u\n",
+       DEBUG(DEBUG_DEBUG, ("ibw_process_queue refcnt=%d msgsize=%u\n",
                p->queued_ref_cnt, msg_size));
 
        rc = ibw_send_packet(conn, p->queued_msg, p, msg_size);
@@ -711,7 +711,7 @@ static int ibw_wc_send(struct ibw_conn *conn, struct ibv_wc *wc)
        struct ibw_wr   *p;
        int     send_index;
 
-       DEBUG(10, ("ibw_wc_send(cmid: %p, wr_id: %u, bl: %u)\n",
+       DEBUG(DEBUG_DEBUG, ("ibw_wc_send(cmid: %p, wr_id: %u, bl: %u)\n",
                pconn->cm_id, (uint32_t)wc->wr_id, (uint32_t)wc->byte_len));
 
        assert(pconn->cm_id->qp->qp_num==wc->qp_num);
@@ -720,7 +720,7 @@ static int ibw_wc_send(struct ibw_conn *conn, struct ibv_wc *wc)
        pconn->wr_sent--;
 
        if (send_index < pctx->opts.max_send_wr) {
-               DEBUG(10, ("ibw_wc_send#1 %u\n", (int)wc->wr_id));
+               DEBUG(DEBUG_DEBUG, ("ibw_wc_send#1 %u\n", (int)wc->wr_id));
                p = pconn->wr_index[send_index];
                if (p->buf_large!=NULL) {
                        if (p->ref_cnt) {
@@ -736,7 +736,7 @@ static int ibw_wc_send(struct ibw_conn *conn, struct ibv_wc *wc)
                        DLIST_ADD(pconn->wr_list_avail, p);
                }
        } else { /* "extra" request - not optimized */
-               DEBUG(10, ("ibw_wc_send#2 %u\n", (int)wc->wr_id));
+               DEBUG(DEBUG_DEBUG, ("ibw_wc_send#2 %u\n", (int)wc->wr_id));
                for(p=pconn->extra_sent; p!=NULL; p=p->next)
                        if ((p->wr_id + pctx->opts.max_recv_wr)==(int)wc->wr_id)
                                break;
@@ -759,7 +759,7 @@ static int ibw_wc_send(struct ibw_conn *conn, struct ibv_wc *wc)
 static int ibw_append_to_part(struct ibw_conn_priv *pconn,
        struct ibw_part *part, char **pp, uint32_t add_len, int info)
 {
-       DEBUG(10, ("ibw_append_to_part: cmid=%p, (bs=%u, len=%u, tr=%u), al=%u, i=%u\n",
+       DEBUG(DEBUG_DEBUG, ("ibw_append_to_part: cmid=%p, (bs=%u, len=%u, tr=%u), al=%u, i=%u\n",
                pconn->cm_id, part->bufsize, part->len, part->to_read, add_len, info));
 
        /* allocate more if necessary - it's an "evergrowing" buffer... */
@@ -797,11 +797,11 @@ static int ibw_append_to_part(struct ibw_conn_priv *pconn,
 static int ibw_wc_mem_threshold(struct ibw_conn_priv *pconn,
        struct ibw_part *part, uint32_t threshold)
 {
-       DEBUG(10, ("ibw_wc_mem_threshold: cmid=%p, (bs=%u, len=%u, tr=%u), thr=%u\n",
+       DEBUG(DEBUG_DEBUG, ("ibw_wc_mem_threshold: cmid=%p, (bs=%u, len=%u, tr=%u), thr=%u\n",
                pconn->cm_id, part->bufsize, part->len, part->to_read, threshold));
 
        if (part->bufsize > threshold) {
-               DEBUG(3, ("ibw_wc_mem_threshold: cmid=%p, %u > %u\n",
+               DEBUG(DEBUG_DEBUG, ("ibw_wc_mem_threshold: cmid=%p, %u > %u\n",
                        pconn->cm_id, part->bufsize, threshold));
                talloc_free(part->buf);
                part->buf = talloc_size(pconn, threshold);
@@ -822,7 +822,7 @@ static int ibw_wc_recv(struct ibw_conn *conn, struct ibv_wc *wc)
        char    *p;
        uint32_t        remain = wc->byte_len;
 
-       DEBUG(10, ("ibw_wc_recv: cmid=%p, wr_id: %u, bl: %u\n",
+       DEBUG(DEBUG_DEBUG, ("ibw_wc_recv: cmid=%p, wr_id: %u, bl: %u\n",
                pconn->cm_id, (uint32_t)wc->wr_id, remain));
 
        assert(pconn->cm_id->qp->qp_num==wc->qp_num);
@@ -904,7 +904,7 @@ static int ibw_process_init_attrs(struct ibw_initattr *attr, int nattr, struct i
        int     i;
        const char *name, *value;
 
-       DEBUG(10, ("ibw_process_init_attrs: nattr: %d\n", nattr));
+       DEBUG(DEBUG_DEBUG, ("ibw_process_init_attrs: nattr: %d\n", nattr));
 
        opts->max_send_wr = IBW_MAX_SEND_WR;
        opts->max_recv_wr = IBW_MAX_RECV_WR;
@@ -942,7 +942,7 @@ struct ibw_ctx *ibw_init(struct ibw_initattr *attr, int nattr,
        struct ibw_ctx_priv *pctx;
        int     rc;
 
-       DEBUG(10, ("ibw_init(ctx_userdata: %p, ectx: %p)\n", ctx_userdata, ectx));
+       DEBUG(DEBUG_DEBUG, ("ibw_init(ctx_userdata: %p, ectx: %p)\n", ctx_userdata, ectx));
 
        /* initialize basic data structures */
        memset(ibw_lasterr, 0, IBW_LASTERR_BUFSIZE);
@@ -986,7 +986,7 @@ struct ibw_ctx *ibw_init(struct ibw_initattr *attr, int nattr,
                sprintf(ibw_lasterr, "rdma_create_id error %d\n", rc);
                goto cleanup;
        }
-       DEBUG(10, ("created cm_id %p\n", pctx->cm_id));
+       DEBUG(DEBUG_DEBUG, ("created cm_id %p\n", pctx->cm_id));
 
        pctx->pagesize = sysconf(_SC_PAGESIZE);
 
@@ -1006,7 +1006,7 @@ int ibw_stop(struct ibw_ctx *ctx)
        struct ibw_ctx_priv *pctx = (struct ibw_ctx_priv *)ctx->internal;
        struct ibw_conn *p;
 
-       DEBUG(10, ("ibw_stop\n"));
+       DEBUG(DEBUG_DEBUG, ("ibw_stop\n"));
 
        for(p=ctx->conn_list; p!=NULL; p=p->next) {
                if (ctx->state==IBWC_ERROR || ctx->state==IBWC_CONNECTED) {
@@ -1026,7 +1026,7 @@ int ibw_bind(struct ibw_ctx *ctx, struct sockaddr_in *my_addr)
        struct ibw_ctx_priv *pctx = (struct ibw_ctx_priv *)ctx->internal;
        int     rc;
 
-       DEBUG(10, ("ibw_bind: addr=%s, port=%u\n",
+       DEBUG(DEBUG_DEBUG, ("ibw_bind: addr=%s, port=%u\n",
                inet_ntoa(my_addr->sin_addr), ntohs(my_addr->sin_port)));
        rc = rdma_bind_addr(pctx->cm_id, (struct sockaddr *) my_addr);
        if (rc) {
@@ -1034,7 +1034,7 @@ int ibw_bind(struct ibw_ctx *ctx, struct sockaddr_in *my_addr)
                DEBUG(0, (ibw_lasterr));
                return rc;
        }
-       DEBUG(10, ("rdma_bind_addr successful\n"));
+       DEBUG(DEBUG_DEBUG, ("rdma_bind_addr successful\n"));
 
        return 0;
 }
@@ -1044,7 +1044,7 @@ int ibw_listen(struct ibw_ctx *ctx, int backlog)
        struct ibw_ctx_priv *pctx = talloc_get_type(ctx->internal, struct ibw_ctx_priv);
        int     rc;
 
-       DEBUG(10, ("ibw_listen\n"));
+       DEBUG(DEBUG_DEBUG, ("ibw_listen\n"));
        rc = rdma_listen(pctx->cm_id, backlog);
        if (rc) {
                sprintf(ibw_lasterr, "rdma_listen failed: %d\n", rc);
@@ -1061,7 +1061,7 @@ int ibw_accept(struct ibw_ctx *ctx, struct ibw_conn *conn, void *conn_userdata)
        struct rdma_conn_param  conn_param;
        int     rc;
 
-       DEBUG(10, ("ibw_accept: cmid=%p\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_accept: cmid=%p\n", pconn->cm_id));
        conn->conn_userdata = conn_userdata;
 
        memset(&conn_param, 0, sizeof(struct rdma_conn_param));
@@ -1091,7 +1091,7 @@ int ibw_connect(struct ibw_conn *conn, struct sockaddr_in *serv_addr, void *conn
 
        conn->conn_userdata = conn_userdata;
        pconn = talloc_get_type(conn->internal, struct ibw_conn_priv);
-       DEBUG(10, ("ibw_connect: addr=%s, port=%u\n", inet_ntoa(serv_addr->sin_addr),
+       DEBUG(DEBUG_DEBUG, ("ibw_connect: addr=%s, port=%u\n", inet_ntoa(serv_addr->sin_addr),
                ntohs(serv_addr->sin_port)));
 
        /* clean previous - probably half - initialization */
@@ -1112,7 +1112,7 @@ int ibw_connect(struct ibw_conn *conn, struct sockaddr_in *serv_addr, void *conn
                talloc_free(conn);
                return -1;
        }
-       DEBUG(10, ("ibw_connect: rdma_create_id succeeded, cm_id=%p\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_connect: rdma_create_id succeeded, cm_id=%p\n", pconn->cm_id));
 
        rc = rdma_resolve_addr(pconn->cm_id, NULL, (struct sockaddr *) serv_addr, 2000);
        if (rc) {
@@ -1132,7 +1132,7 @@ int ibw_disconnect(struct ibw_conn *conn)
        int     rc;
        struct ibw_conn_priv *pconn = talloc_get_type(conn->internal, struct ibw_conn_priv);
 
-       DEBUG(10, ("ibw_disconnect: cmid=%p\n", pconn->cm_id));
+       DEBUG(DEBUG_DEBUG, ("ibw_disconnect: cmid=%p\n", pconn->cm_id));
 
        assert(pconn!=NULL);
 
@@ -1149,7 +1149,7 @@ int ibw_disconnect(struct ibw_conn *conn)
                }
                break;
        default:
-               DEBUG(9, ("invalid state for disconnect: %d\n", conn->state));
+               DEBUG(DEBUG_DEBUG, ("invalid state for disconnect: %d\n", conn->state));
                break;
        }
 
@@ -1163,7 +1163,7 @@ int ibw_alloc_send_buf(struct ibw_conn *conn, void **buf, void **key, uint32_t l
        struct ibw_wr *p = pconn->wr_list_avail;
 
        if (p!=NULL) {
-               DEBUG(10, ("ibw_alloc_send_buf#1: cmid=%p, len=%d\n", pconn->cm_id, len));
+               DEBUG(DEBUG_DEBUG, ("ibw_alloc_send_buf#1: cmid=%p, len=%d\n", pconn->cm_id, len));
 
                DLIST_REMOVE(pconn->wr_list_avail, p);
                DLIST_ADD(pconn->wr_list_used, p);
@@ -1180,7 +1180,7 @@ int ibw_alloc_send_buf(struct ibw_conn *conn, void **buf, void **key, uint32_t l
                }
                /* p->wr_id is already filled in ibw_init_memory */
        } else {
-               DEBUG(10, ("ibw_alloc_send_buf#2: cmid=%p, len=%d\n", pconn->cm_id, len));
+               DEBUG(DEBUG_DEBUG, ("ibw_alloc_send_buf#2: cmid=%p, len=%d\n", pconn->cm_id, len));
                /* not optimized */
                p = pconn->extra_avail;
                if (!p) {
@@ -1193,7 +1193,7 @@ int ibw_alloc_send_buf(struct ibw_conn *conn, void **buf, void **key, uint32_t l
                        p->wr_id = pctx->opts.max_send_wr + pconn->extra_max;
                        pconn->extra_max++;
                        switch(pconn->extra_max) {
-                               case 1: DEBUG(2, ("warning: queue performed\n")); break;
+                               case 1: DEBUG(DEBUG_INFO, ("warning: queue performed\n")); break;
                                case 10: DEBUG(0, ("warning: queue reached 10\n")); break;
                                case 100: DEBUG(0, ("warning: queue reached 100\n")); break;
                                case 1000: DEBUG(0, ("warning: queue reached 1000\n")); break;
@@ -1246,10 +1246,10 @@ static int ibw_send_packet(struct ibw_conn *conn, void *buf, struct ibw_wr *p, u
                };
 
                if (p->buf_large==NULL) {
-                       DEBUG(10, ("ibw_send#normal(cmid: %p, wrid: %u, n: %d)\n",
+                       DEBUG(DEBUG_DEBUG, ("ibw_send#normal(cmid: %p, wrid: %u, n: %d)\n",
                                pconn->cm_id, (uint32_t)wr.wr_id, len));
                } else {
-                       DEBUG(10, ("ibw_send#large(cmid: %p, wrid: %u, n: %d)\n",
+                       DEBUG(DEBUG_DEBUG, ("ibw_send#large(cmid: %p, wrid: %u, n: %d)\n",
                                pconn->cm_id, (uint32_t)wr.wr_id, len));
                        list.lkey = p->mr_large->lkey;
                }
@@ -1266,7 +1266,7 @@ static int ibw_send_packet(struct ibw_conn *conn, void *buf, struct ibw_wr *p, u
                return rc;
        } /* else put the request into our own queue: */
 
-       DEBUG(10, ("ibw_send#queued(cmid: %p, len: %u)\n", pconn->cm_id, len));
+       DEBUG(DEBUG_DEBUG, ("ibw_send#queued(cmid: %p, len: %u)\n", pconn->cm_id, len));
 
        /* TODO: clarify how to continue when state==IBWC_STOPPED */
 
@@ -1301,7 +1301,7 @@ int ibw_send(struct ibw_conn *conn, void *buf, void *key, uint32_t len)
                char    *packet = (char *)buf;
                uint32_t        recv_bufsize = pctx->opts.recv_bufsize;
 
-               DEBUG(10, ("ibw_send#frag(cmid: %p, buf: %p, len: %u)\n",
+               DEBUG(DEBUG_DEBUG, ("ibw_send#frag(cmid: %p, buf: %p, len: %u)\n",
                        pconn->cm_id, buf, len));
 
                /* single threaded => no race here: */
@@ -1343,11 +1343,11 @@ int ibw_cancel_send_buf(struct ibw_conn *conn, void *buf, void *key)
 
        /* parallel case */
        if (p->wr_id < pctx->opts.max_send_wr) {
-               DEBUG(10, ("ibw_cancel_send_buf#1 %u", (int)p->wr_id));
+               DEBUG(DEBUG_DEBUG, ("ibw_cancel_send_buf#1 %u", (int)p->wr_id));
                DLIST_REMOVE(pconn->wr_list_used, p);
                DLIST_ADD(pconn->wr_list_avail, p);
        } else { /* "extra" packet */
-               DEBUG(10, ("ibw_cancel_send_buf#2 %u", (int)p->wr_id));
+               DEBUG(DEBUG_DEBUG, ("ibw_cancel_send_buf#2 %u", (int)p->wr_id));
                DLIST_REMOVE(pconn->extra_sent, p);
                DLIST_ADD(pconn->extra_avail, p);
        }

diff --git a/ib/ibwrapper_test.c b/ib/ibwrapper_test.c
index 07c78e7709eb1da03faf7190b0dc27eeafad50d8..ed5ab963676b281edfc3845b958925c466d4885d 100644 (file)
--- a/ib/ibwrapper_test.c
+++ b/ib/ibwrapper_test.c
@@ -91,7 +91,7 @@ int ibwtest_connect_everybody(struct ibwtest_ctx *tcx)
                        return -1;
                }
        }
-       DEBUG(10, ("sent %d connect request...\n", tcx->naddrs));
+       DEBUG(DEBUG_DEBUG, ("sent %d connect request...\n", tcx->naddrs));
 
        return 0;
 }
@@ -103,7 +103,7 @@ int ibwtest_send_id(struct ibw_conn *conn)
        void *key;
        uint32_t        len;
 
-       DEBUG(10, ("ibwtest_send_id\n"));
+       DEBUG(DEBUG_DEBUG, ("ibwtest_send_id\n"));
        len = sizeof(uint32_t)+strlen(tcx->id)+2;
        if (ibw_alloc_send_buf(conn, (void **)&buf, &key, len)) {
                DEBUG(0, ("send_id: ibw_alloc_send_buf failed\n"));
@@ -245,24 +245,24 @@ int ibwtest_connstate_handler(struct ibw_ctx *ctx, struct ibw_conn *conn)
 
                switch(ctx->state) {
                case IBWS_INIT:
-                       DEBUG(10, ("test IBWS_INIT\n"));
+                       DEBUG(DEBUG_DEBUG, ("test IBWS_INIT\n"));
                        break;
                case IBWS_READY:
-                       DEBUG(10, ("test IBWS_READY\n"));
+                       DEBUG(DEBUG_DEBUG, ("test IBWS_READY\n"));
                        break;
                case IBWS_CONNECT_REQUEST:
-                       DEBUG(10, ("test IBWS_CONNECT_REQUEST\n"));
+                       DEBUG(DEBUG_DEBUG, ("test IBWS_CONNECT_REQUEST\n"));
                        tconn = talloc_zero(conn, struct ibwtest_conn);
                        if (ibw_accept(ctx, conn, tconn)) {
                                DEBUG(0, ("error accepting the connect request\n"));
                        }
                        break;
                case IBWS_STOPPED:
-                       DEBUG(10, ("test IBWS_STOPPED\n"));
+                       DEBUG(DEBUG_DEBUG, ("test IBWS_STOPPED\n"));
                        tcx->kill_me = 1; /* main loop can exit */
                        break;
                case IBWS_ERROR:
-                       DEBUG(10, ("test IBWS_ERROR\n"));
+                       DEBUG(DEBUG_DEBUG, ("test IBWS_ERROR\n"));
                        ibw_stop(tcx->ibwctx);
                        break;
                default:
@@ -275,7 +275,7 @@ int ibwtest_connstate_handler(struct ibw_ctx *ctx, struct ibw_conn *conn)
                tconn = talloc_get_type(conn->conn_userdata, struct ibwtest_conn);
                switch(conn->state) {
                case IBWC_INIT:
-                       DEBUG(10, ("test IBWC_INIT\n"));
+                       DEBUG(DEBUG_DEBUG, ("test IBWC_INIT\n"));
                        break;
                case IBWC_CONNECTED:
                        if (gettimeofday(&tcx->start_time, NULL)) {
@@ -285,11 +285,11 @@ int ibwtest_connstate_handler(struct ibw_ctx *ctx, struct ibw_conn *conn)
                        ibwtest_send_id(conn);
                        break;
                case IBWC_DISCONNECTED:
-                       DEBUG(10, ("test IBWC_DISCONNECTED\n"));
+                       DEBUG(DEBUG_DEBUG, ("test IBWC_DISCONNECTED\n"));
                        talloc_free(conn);
                        break;
                case IBWC_ERROR:
-                       DEBUG(10, ("test IBWC_ERROR %s\n", ibw_getLastError()));
+                       DEBUG(DEBUG_DEBUG, ("test IBWC_ERROR %s\n", ibw_getLastError()));
                        break;
                default:
                        assert(0);
@@ -315,7 +315,7 @@ int ibwtest_receive_handler(struct ibw_conn *conn, void *buf, int n)
                tconn->id = talloc_strdup(tconn, ((char *)buf)+sizeof(uint32_t)+1);
        }
        if (op==TESTOP_SEND_ID || op==TESTOP_SEND_TEXT) {
-               DEBUG(11, ("[%d]msg from %s: \"%s\"(%d)\n", op,
+               DEBUG(DEBUG_DEBUG, ("[%d]msg from %s: \"%s\"(%d)\n", op,
                        tconn->id ? tconn->id : "NULL", ((char *)buf)+sizeof(uint32_t)+1, n));
        }
 
@@ -324,7 +324,7 @@ int ibwtest_receive_handler(struct ibw_conn *conn, void *buf, int n)
                        unsigned char sum;
                        sum = ibwtest_get_sum((unsigned char *)buf + sizeof(uint32_t) + 1,
                                n - sizeof(uint32_t) - 2);
-                       DEBUG(11, ("[%d]msg varsize %u/sum %u from %s\n",
+                       DEBUG(DEBUG_DEBUG, ("[%d]msg varsize %u/sum %u from %s\n",
                                op,
                                n - sizeof(uint32_t) - 2,
                                (uint32_t)sum,
@@ -411,7 +411,7 @@ void ibwtest_sigint_handler(int sig)
                        testctx->ibwctx->state==IBWS_ERROR)
                {
                        if (testctx->stopping) {
-                               DEBUG(10, ("forcing exit...\n"));
+                               DEBUG(DEBUG_DEBUG, ("forcing exit...\n"));
                                testctx->kill_me = 1;
                        } else {
                                /* mostly expected case */

diff --git a/include/includes.h b/include/includes.h
index 493dafa908bee86d821ab05c4dc0477ffda6a624..b6133ee6fb078262c4973b594972e988213d802a 100644 (file)
--- a/include/includes.h
+++ b/include/includes.h
@@ -14,8 +14,20 @@ typedef bool BOOL;
 #define False 0
 
 extern int LogLevel;
-
-#define DEBUG(lvl, x) if ((lvl) <= LogLevel) (do_debug x)
+extern int this_log_level;
+
+enum debug_level { 
+       DEBUG_EMERG   = -3, 
+       DEBUG_ALERT   = -2, 
+       DEBUG_CRIT    = -1,
+       DEBUG_ERR     =  0,
+       DEBUG_WARNING =  1,
+       DEBUG_NOTICE  =  2,     
+       DEBUG_INFO    =  3,
+       DEBUG_DEBUG   =  4,
+};
+
+#define DEBUG(lvl, x) do { if ((lvl) <= LogLevel) { this_log_level = (lvl); do_debug x; }} while (0)
 
 #define _PUBLIC_
 

diff --git a/server/ctdb_call.c b/server/ctdb_call.c
index eae99df8a78ded2f161bae72aea0a4a2e1d5acf3..6fcbe37d82c6c8a4a2674fe58f4e72681fde10e5 100644 (file)
--- a/server/ctdb_call.c
+++ b/server/ctdb_call.c
@@ -231,7 +231,7 @@ static void ctdb_become_dmaster(struct ctdb_db_context *ctdb_db,
        struct ctdb_context *ctdb = ctdb_db->ctdb;
        struct ctdb_ltdb_header header;
 
-       DEBUG(2,("pnn %u dmaster response %08x\n", ctdb->pnn, ctdb_hash(&key)));
+       DEBUG(DEBUG_INFO,("pnn %u dmaster response %08x\n", ctdb->pnn, ctdb_hash(&key)));
 
        ZERO_STRUCT(header);
        header.rsn = rsn + 1;
@@ -306,7 +306,7 @@ void ctdb_request_dmaster(struct ctdb_context *ctdb, struct ctdb_req_header *hdr
                return;
        }
        if (ret == -2) {
-               DEBUG(2,(__location__ " deferring ctdb_request_dmaster\n"));
+               DEBUG(DEBUG_INFO,(__location__ " deferring ctdb_request_dmaster\n"));
                return;
        }
 
@@ -317,7 +317,7 @@ void ctdb_request_dmaster(struct ctdb_context *ctdb, struct ctdb_req_header *hdr
                ctdb_fatal(ctdb, "ctdb_req_dmaster to non-lmaster");
        }
 
-       DEBUG(2,("pnn %u dmaster request on %08x for %u from %u\n", 
+       DEBUG(DEBUG_INFO,("pnn %u dmaster request on %08x for %u from %u\n", 
                 ctdb->pnn, ctdb_hash(&key), c->dmaster, c->hdr.srcnode));
 
        /* its a protocol error if the sending node is not the current dmaster */
@@ -392,7 +392,7 @@ void ctdb_request_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
                return;
        }
        if (ret == -2) {
-               DEBUG(2,(__location__ " deferred ctdb_request_call\n"));
+               DEBUG(DEBUG_INFO,(__location__ " deferred ctdb_request_call\n"));
                return;
        }
 
@@ -417,7 +417,7 @@ void ctdb_request_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
             ((header.laccessor == c->hdr.srcnode
               && header.lacount >= ctdb->tunable.max_lacount)
              || (c->flags & CTDB_IMMEDIATE_MIGRATION)) ) {
-               DEBUG(2,("pnn %u starting migration of %08x to %u\n", 
+               DEBUG(DEBUG_INFO,("pnn %u starting migration of %08x to %u\n", 
                         ctdb->pnn, ctdb_hash(&call.key), c->hdr.srcnode));
                ctdb_call_send_dmaster(ctdb_db, c, &header, &call.key, &data);
                talloc_free(data.dptr);

diff --git a/server/ctdb_daemon.c b/server/ctdb_daemon.c
index 137b85eee2c2c22a4c13c143ad7b5c324d3aa658..8f878ccc8398b96de22c8bba3393304eb5a8efbc 100644 (file)
--- a/server/ctdb_daemon.c
+++ b/server/ctdb_daemon.c
@@ -52,7 +52,7 @@ static void flag_change_handler(struct ctdb_context *ctdb, uint64_t srvid,
        ctdb->nodes[c->pnn]->flags = 
                (ctdb->nodes[c->pnn]->flags&NODE_FLAGS_DISCONNECTED) 
                | (c->new_flags & ~NODE_FLAGS_DISCONNECTED);    
-       DEBUG(2,("Node flags for node %u are now 0x%x\n", c->pnn, ctdb->nodes[c->pnn]->flags));
+       DEBUG(DEBUG_INFO,("Node flags for node %u are now 0x%x\n", c->pnn, ctdb->nodes[c->pnn]->flags));
 
        /* make sure we don't hold any IPs when we shouldn't */
        if (c->pnn == ctdb->pnn &&
@@ -167,7 +167,7 @@ int daemon_register_message_handler(struct ctdb_context *ctdb, uint32_t client_i
                DEBUG(0,(__location__ " Failed to register handler %llu in daemon\n", 
                         (unsigned long long)srvid));
        } else {
-               DEBUG(1,(__location__ " Registered message handler for srvid=%llu\n", 
+               DEBUG(DEBUG_INFO,(__location__ " Registered message handler for srvid=%llu\n", 
                         (unsigned long long)srvid));
        }
 
@@ -175,7 +175,7 @@ int daemon_register_message_handler(struct ctdb_context *ctdb, uint32_t client_i
        if ((srvid & 0xFFFFFFFF) == srvid &&
            kill(srvid, 0) == 0) {
                client->pid = srvid;
-               DEBUG(1,(__location__ " Registered PID %u for client %u\n",
+               DEBUG(DEBUG_INFO,(__location__ " Registered PID %u for client %u\n",
                         (unsigned)client->pid, client_id));
        }
        return res;
@@ -512,7 +512,7 @@ static void ctdb_daemon_read_cb(uint8_t *data, size_t cnt, void *args)
                return;
        }
 
-       DEBUG(3,(__location__ " client request %u of type %u length %u from "
+       DEBUG(DEBUG_DEBUG,(__location__ " client request %u of type %u length %u from "
                 "node %u to %u\n", hdr->reqid, hdr->operation, hdr->length,
                 hdr->srcnode, hdr->destnode));
 

diff --git a/server/ctdb_keepalive.c b/server/ctdb_keepalive.c
index 216127cc287e92929fd1cae75e98045369c60bb6..0047e9cf8a10c30f2634ea18b1ee650edea82c1f 100644 (file)
--- a/server/ctdb_keepalive.c
+++ b/server/ctdb_keepalive.c
@@ -69,7 +69,7 @@ static void ctdb_check_for_dead_nodes(struct event_context *ev, struct timed_eve
                }
                
                if (node->tx_cnt == 0) {
-                       DEBUG(5,("sending keepalive to %u\n", node->pnn));
+                       DEBUG(DEBUG_DEBUG,("sending keepalive to %u\n", node->pnn));
                        ctdb_send_keepalive(ctdb, node->pnn);
                }
 

diff --git a/server/ctdb_logging.c b/server/ctdb_logging.c
index 9f7f6b3bb9320e017d6ed5308a6005835e72965e..9748d0e1b78331e123c456a2a7e36870f0087c42 100644 (file)
--- a/server/ctdb_logging.c
+++ b/server/ctdb_logging.c
@@ -40,7 +40,34 @@ static struct ctdb_log_state *log_state;
  */
 static void ctdb_syslog_log(const char *format, va_list ap)
 {
-       vsyslog(LOG_NOTICE, format, ap);
+       int level = LOG_DEBUG;
+       switch (this_log_level) {
+       case DEBUG_EMERG: 
+               level = LOG_EMERG; 
+               break;
+       case DEBUG_ALERT: 
+               level = LOG_ALERT; 
+               break;
+       case DEBUG_CRIT: 
+               level = LOG_CRIT; 
+               break;
+       case DEBUG_ERR: 
+               level = LOG_ERR; 
+               break;
+       case DEBUG_WARNING: 
+               level = LOG_WARNING; 
+               break;
+       case DEBUG_NOTICE: 
+               level = LOG_NOTICE;
+               break;
+       case DEBUG_INFO: 
+               level = LOG_INFO;
+               break;
+       default:
+               level = LOG_DEBUG;
+               break;          
+       }
+       vsyslog(level, format, ap);
 }
 
 

diff --git a/server/ctdb_ltdb_server.c b/server/ctdb_ltdb_server.c
index 683064ea353c8d5c047d1c3d097b717dd73d9bb7..ea0190ec367c825975a0387f64fa744fad111732 100644 (file)
--- a/server/ctdb_ltdb_server.c
+++ b/server/ctdb_ltdb_server.c
@@ -68,7 +68,7 @@ static void lock_fetch_callback(void *p)
                return;
        }
        state->recv_pkt(state->recv_context, state->hdr);
-       DEBUG(2,(__location__ " PACKET REQUEUED\n"));
+       DEBUG(DEBUG_INFO,(__location__ " PACKET REQUEUED\n"));
 }
 
 
@@ -285,7 +285,7 @@ static int ctdb_local_attach(struct ctdb_context *ctdb, const char *db_name, boo
                return -1;
        }
 
-       DEBUG(1,("Attached to database '%s'\n", ctdb_db->db_path));
+       DEBUG(DEBUG_INFO,("Attached to database '%s'\n", ctdb_db->db_path));
        
        /* success */
        return 0;

diff --git a/server/ctdb_monitor.c b/server/ctdb_monitor.c
index f798b92d6dbd4d6add682931022a0eb7d8e445cf..74873e75ec868a79380f11074e47dbb9a96cd96d 100644 (file)
--- a/server/ctdb_monitor.c
+++ b/server/ctdb_monitor.c
@@ -51,7 +51,7 @@ static void ctdb_health_callback(struct ctdb_context *ctdb, int status, void *p)
                node->flags |= NODE_FLAGS_UNHEALTHY;
                ctdb->monitor->next_interval = 1;
        } else if (status == 0 && (node->flags & NODE_FLAGS_UNHEALTHY)) {
-               DEBUG(0,("monitor event OK - node re-enabled\n"));
+               DEBUG(DEBUG_NOTICE,("monitor event OK - node re-enabled\n"));
                node->flags &= ~NODE_FLAGS_UNHEALTHY;
                ctdb->monitor->next_interval = 1;
        }
@@ -147,7 +147,7 @@ static void ctdb_check_health(struct event_context *ev, struct timed_event *te,
 void ctdb_disable_monitoring(struct ctdb_context *ctdb)
 {
        ctdb->monitor->monitoring_mode = CTDB_MONITORING_DISABLED;
-       DEBUG(2,("Monitoring has been disabled\n"));
+       DEBUG(DEBUG_INFO,("Monitoring has been disabled\n"));
 }
 
 /* 
@@ -157,7 +157,7 @@ void ctdb_enable_monitoring(struct ctdb_context *ctdb)
 {
        ctdb->monitor->monitoring_mode  = CTDB_MONITORING_ACTIVE;
        ctdb->monitor->next_interval = 1;
-       DEBUG(2,("Monitoring has been enabled\n"));
+       DEBUG(DEBUG_INFO,("Monitoring has been enabled\n"));
 }
 
 /* stop any monitoring 
@@ -217,7 +217,7 @@ int32_t ctdb_control_modflags(struct ctdb_context *ctdb, TDB_DATA indata)
        node->flags &= ~m->clear;
 
        if (node->flags == old_flags) {
-               DEBUG(2, ("Control modflags on node %u - Unchanged - flags 0x%x\n", ctdb->pnn, node->flags));
+               DEBUG(DEBUG_INFO, ("Control modflags on node %u - Unchanged - flags 0x%x\n", ctdb->pnn, node->flags));
                return 0;
        }
 

diff --git a/server/ctdb_recover.c b/server/ctdb_recover.c
index b239554a02a8baeef312004f27635912493eaef8..d35bb9e8d534ce5dc8d3b5a17dc94f4825a20e3c 100644 (file)
--- a/server/ctdb_recover.c
+++ b/server/ctdb_recover.c
@@ -293,7 +293,7 @@ int32_t ctdb_control_push_db(struct ctdb_context *ctdb, TDB_DATA indata)
 
        rec = (struct ctdb_rec_data *)&reply->data[0];
 
-       DEBUG(1,("starting push of %u records for dbid 0x%x\n",
+       DEBUG(DEBUG_INFO,("starting push of %u records for dbid 0x%x\n",
                 reply->count, reply->db_id));
 
        for (i=0;i<reply->count;i++) {
@@ -322,7 +322,7 @@ int32_t ctdb_control_push_db(struct ctdb_context *ctdb, TDB_DATA indata)
                rec = (struct ctdb_rec_data *)(rec->length + (uint8_t *)rec);
        }           
 
-       DEBUG(3,("finished push of %u records for dbid 0x%x\n",
+       DEBUG(DEBUG_DEBUG,("finished push of %u records for dbid 0x%x\n",
                 reply->count, reply->db_id));
 
        ctdb_lock_all_databases_unmark(ctdb);
@@ -640,7 +640,7 @@ int32_t ctdb_control_delete_record(struct ctdb_context *ctdb, TDB_DATA indata)
        data.dptr = &rec->data[rec->keylen];
 
        if (ctdb_lmaster(ctdb, &key) == ctdb->pnn) {
-               DEBUG(2,(__location__ " Called delete on record where we are lmaster\n"));
+               DEBUG(DEBUG_INFO,(__location__ " Called delete on record where we are lmaster\n"));
                return -1;
        }
 
@@ -677,7 +677,7 @@ int32_t ctdb_control_delete_record(struct ctdb_context *ctdb, TDB_DATA indata)
 
        if (hdr2->rsn > hdr->rsn) {
                tdb_chainunlock(ctdb_db->ltdb->tdb, key);
-               DEBUG(2,(__location__ " Skipping record with rsn=%llu - called with rsn=%llu\n",
+               DEBUG(DEBUG_INFO,(__location__ " Skipping record with rsn=%llu - called with rsn=%llu\n",
                         (unsigned long long)hdr2->rsn, (unsigned long long)hdr->rsn));
                free(data.dptr);
                return -1;              
@@ -685,7 +685,7 @@ int32_t ctdb_control_delete_record(struct ctdb_context *ctdb, TDB_DATA indata)
 
        if (hdr2->dmaster == ctdb->pnn) {
                tdb_chainunlock(ctdb_db->ltdb->tdb, key);
-               DEBUG(2,(__location__ " Attempted delete record where we are the dmaster\n"));
+               DEBUG(DEBUG_INFO,(__location__ " Attempted delete record where we are the dmaster\n"));
                free(data.dptr);
                return -1;                              
        }
@@ -699,7 +699,7 @@ int32_t ctdb_control_delete_record(struct ctdb_context *ctdb, TDB_DATA indata)
        if (tdb_delete(ctdb_db->ltdb->tdb, key) != 0) {
                tdb_unlock(ctdb_db->ltdb->tdb, -1, F_WRLCK);
                tdb_chainunlock(ctdb_db->ltdb->tdb, key);
-               DEBUG(2,(__location__ " Failed to delete record\n"));
+               DEBUG(DEBUG_INFO,(__location__ " Failed to delete record\n"));
                free(data.dptr);
                return -1;                                              
        }

diff --git a/server/ctdb_recoverd.c b/server/ctdb_recoverd.c
index 8595706cc0f7fdb0ab2fac61a9e1c01ae91e38d3..9696fcf20526324a772aa9d73d4851cc5d6b90fc 100644 (file)
--- a/server/ctdb_recoverd.c
+++ b/server/ctdb_recoverd.c
@@ -911,7 +911,7 @@ static void ctdb_set_culprit(struct ctdb_recoverd *rec, uint32_t culprit)
 
        if (rec->last_culprit != culprit ||
            timeval_elapsed(&rec->first_recover_time) > ctdb->tunable.recovery_grace_period) {
-               DEBUG(0,("New recovery culprit %u\n", culprit));
+               DEBUG(DEBUG_NOTICE,("New recovery culprit %u\n", culprit));
                /* either a new node is the culprit, or we've decided to forgive them */
                rec->last_culprit = culprit;
                rec->first_recover_time = timeval_current();
@@ -1144,7 +1144,7 @@ static int push_recdb_database(struct ctdb_context *ctdb, uint32_t dbid,
                return -1;
        }
 
-       DEBUG(0, (__location__ " Recovery - pushed remote database 0x%x of size %u\n", 
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - pushed remote database 0x%x of size %u\n", 
                  dbid, recdata->count));
 
        talloc_free(recdata);
@@ -1182,7 +1182,7 @@ static int recover_database(struct ctdb_recoverd *rec,
                return -1;
        }
 
-       DEBUG(0, (__location__ " Recovery - pulled remote database 0x%x\n", dbid));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - pulled remote database 0x%x\n", dbid));
 
        /* wipe all the remote databases. This is safe as we are in a transaction */
        w.db_id = dbid;
@@ -1228,7 +1228,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
        struct ctdb_dbid_map *dbmap;
        TDB_DATA data;
 
-       DEBUG(0, (__location__ " Starting do_recovery\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Starting do_recovery\n"));
 
        /* if recovery fails, force it again */
        rec->need_recovery = true;
@@ -1248,7 +1248,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                return -1;
        }
 
-       DEBUG(0, (__location__ " Recovery initiated due to problem with node %u\n", culprit));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery initiated due to problem with node %u\n", culprit));
 
        /* get a list of all databases */
        ret = ctdb_ctrl_getdbmap(ctdb, CONTROL_TIMEOUT(), pnn, mem_ctx, &dbmap);
@@ -1274,7 +1274,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                return -1;
        }
 
-       DEBUG(0, (__location__ " Recovery - created remote databases\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - created remote databases\n"));
 
 
        /* set recovery mode to active on all nodes */
@@ -1321,7 +1321,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                return -1;
        }
 
-       DEBUG(0,(__location__ " started transactions on all nodes\n"));
+       DEBUG(DEBUG_NOTICE,(__location__ " started transactions on all nodes\n"));
 
        for (i=0;i<dbmap->num;i++) {
                if (recover_database(rec, mem_ctx, dbmap->dbs[i].dbid, pnn, nodemap, generation) != 0) {
@@ -1330,7 +1330,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                }
        }
 
-       DEBUG(0, (__location__ " Recovery - starting database commits\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - starting database commits\n"));
 
        /* commit all the changes */
        if (ctdb_client_async_control(ctdb, CTDB_CONTROL_TRANSACTION_COMMIT,
@@ -1340,7 +1340,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                return -1;
        }
 
-       DEBUG(0, (__location__ " Recovery - committed databases\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - committed databases\n"));
        
 
        /* build a new vnn map with all the currently active and
@@ -1364,7 +1364,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                return -1;
        }
 
-       DEBUG(0, (__location__ " Recovery - updated vnnmap\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - updated vnnmap\n"));
 
        /* update recmaster to point to us for all nodes */
        ret = set_recovery_master(ctdb, nodemap, pnn);
@@ -1373,7 +1373,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                return -1;
        }
 
-       DEBUG(0, (__location__ " Recovery - updated recmaster\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - updated recmaster\n"));
 
        /*
          update all nodes to have the same flags that we have
@@ -1384,7 +1384,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                return -1;
        }
        
-       DEBUG(0, (__location__ " Recovery - updated flags\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery - updated flags\n"));
 
        /*
          if enabled, tell nodes to takeover their public IPs
@@ -1396,7 +1396,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
                        DEBUG(0, (__location__ " Unable to setup public takeover addresses\n"));
                        return -1;
                }
-               DEBUG(1, (__location__ " Recovery - done takeover\n"));
+               DEBUG(DEBUG_INFO, (__location__ " Recovery - done takeover\n"));
        }
 
        /* execute the "recovered" event script on all nodes */
@@ -1417,7 +1417,7 @@ static int do_recovery(struct ctdb_recoverd *rec,
           has been reconfigured */
        ctdb_send_message(ctdb, CTDB_BROADCAST_CONNECTED, CTDB_SRVID_RECONFIGURE, tdb_null);
 
-       DEBUG(0, (__location__ " Recovery complete\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Recovery complete\n"));
 
        rec->need_recovery = false;
 
@@ -1425,9 +1425,9 @@ static int do_recovery(struct ctdb_recoverd *rec,
           We now wait for rerecovery_timeout before we allow 
           another recovery to take place.
        */
-       DEBUG(0, (__location__ " New recoveries supressed for the rerecovery timeout\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " New recoveries supressed for the rerecovery timeout\n"));
        ctdb_wait_timeout(ctdb, ctdb->tunable.rerecovery_timeout);
-       DEBUG(0, (__location__ " Rerecovery timeout elapsed. Recovery reactivated.\n"));
+       DEBUG(DEBUG_NOTICE, (__location__ " Rerecovery timeout elapsed. Recovery reactivated.\n"));
 
        return 0;
 }

diff --git a/server/ctdb_server.c b/server/ctdb_server.c
index 1bf6e5e51522a1100e76a129c8966f8754e609d0..f3b1035c4232fe536b72e5714cbc9930af7e2f5e 100644 (file)
--- a/server/ctdb_server.c
+++ b/server/ctdb_server.c
@@ -219,7 +219,7 @@ void ctdb_input_pkt(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
        tmp_ctx = talloc_new(ctdb);
        talloc_steal(tmp_ctx, hdr);
 
-       DEBUG(3,(__location__ " ctdb request %u of type %u length %u from "
+       DEBUG(DEBUG_DEBUG,(__location__ " ctdb request %u of type %u length %u from "
                 "node %u to %u\n", hdr->reqid, hdr->operation, hdr->length,
                 hdr->srcnode, hdr->destnode));
 
@@ -320,7 +320,7 @@ done:
 void ctdb_node_dead(struct ctdb_node *node)
 {
        if (node->flags & NODE_FLAGS_DISCONNECTED) {
-               DEBUG(1,("%s: node %s is already marked disconnected: %u connected\n", 
+               DEBUG(DEBUG_INFO,("%s: node %s is already marked disconnected: %u connected\n", 
                         node->ctdb->name, node->name, 
                         node->ctdb->num_connected));
                return;
@@ -343,7 +343,7 @@ void ctdb_node_dead(struct ctdb_node *node)
 void ctdb_node_connected(struct ctdb_node *node)
 {
        if (!(node->flags & NODE_FLAGS_DISCONNECTED)) {
-               DEBUG(1,("%s: node %s is already marked connected: %u connected\n", 
+               DEBUG(DEBUG_INFO,("%s: node %s is already marked connected: %u connected\n", 
                         node->ctdb->name, node->name, 
                         node->ctdb->num_connected));
                return;
@@ -352,7 +352,7 @@ void ctdb_node_connected(struct ctdb_node *node)
        node->dead_count = 0;
        node->flags &= ~NODE_FLAGS_DISCONNECTED;
        node->flags |= NODE_FLAGS_UNHEALTHY;
-       DEBUG(1,("%s: connected to %s - %u connected\n", 
+       DEBUG(DEBUG_INFO,("%s: connected to %s - %u connected\n", 
                 node->ctdb->name, node->name, node->ctdb->num_connected));
 }
 

diff --git a/server/ctdb_takeover.c b/server/ctdb_takeover.c
index cea3f95e34e3c4e3ff05ecd646034a8f1c60d3d5..15894fce7bfd95db3db4dd0e8f05e2f2bd451cc8 100644 (file)
--- a/server/ctdb_takeover.c
+++ b/server/ctdb_takeover.c
@@ -87,7 +87,7 @@ static void ctdb_control_send_arp(struct event_context *ev, struct timed_event *
        tcparray = arp->tcparray;
        if (tcparray) {
                for (i=0;i<tcparray->num;i++) {
-                       DEBUG(2,("sending tcp tickle ack for %u->%s:%u\n",
+                       DEBUG(DEBUG_INFO,("sending tcp tickle ack for %u->%s:%u\n",
                                 (unsigned)ntohs(tcparray->connections[i].daddr.sin_port), 
                                 inet_ntoa(tcparray->connections[i].saddr.sin_addr),
                                 (unsigned)ntohs(tcparray->connections[i].saddr.sin_port)));
@@ -269,16 +269,16 @@ static void release_kill_clients(struct ctdb_context *ctdb, struct sockaddr_in i
 {
        struct ctdb_client_ip *ip;
 
-       DEBUG(1,("release_kill_clients for ip %s\n", inet_ntoa(in.sin_addr)));
+       DEBUG(DEBUG_INFO,("release_kill_clients for ip %s\n", inet_ntoa(in.sin_addr)));
 
        for (ip=ctdb->client_ip_list; ip; ip=ip->next) {
-               DEBUG(2,("checking for client %u with IP %s\n", 
+               DEBUG(DEBUG_INFO,("checking for client %u with IP %s\n", 
                         ip->client_id, inet_ntoa(ip->ip.sin_addr)));
                if (ctdb_same_ip(&ip->ip, &in)) {
                        struct ctdb_client *client = ctdb_reqid_find(ctdb, 
                                                                     ip->client_id, 
                                                                     struct ctdb_client);
-                       DEBUG(1,("matched client %u with IP %s and pid %u\n", 
+                       DEBUG(DEBUG_INFO,("matched client %u with IP %s and pid %u\n", 
                                 ip->client_id, inet_ntoa(ip->ip.sin_addr), client->pid));
                        if (client->pid != 0) {
                                DEBUG(0,(__location__ " Killing client pid %u for IP %s on client_id %u\n",
@@ -346,7 +346,7 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
        vnn->takeover_ctx = NULL;
 
        if (!ctdb_sys_have_ip(pip->sin)) {
-               DEBUG(2,("Redundant release of IP %s/%u on interface %s (ip not held)\n", 
+               DEBUG(DEBUG_INFO,("Redundant release of IP %s/%u on interface %s (ip not held)\n", 
                         inet_ntoa(pip->sin.sin_addr), vnn->public_netmask_bits, 
                         vnn->iface));
                return 0;
@@ -903,7 +903,7 @@ try_again:
  */
 static int ctdb_client_ip_destructor(struct ctdb_client_ip *ip)
 {
-       DEBUG(3,("destroying client tcp for %s:%u (client_id %u)\n",
+       DEBUG(DEBUG_DEBUG,("destroying client tcp for %s:%u (client_id %u)\n",
                 inet_ntoa(ip->ip.sin_addr), ntohs(ip->ip.sin_port), ip->client_id));
        DLIST_REMOVE(ip->ctdb->client_ip_list, ip);
        return 0;
@@ -965,7 +965,7 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
        data.dptr = (uint8_t *)&t;
        data.dsize = sizeof(t);
 
-       DEBUG(1,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
+       DEBUG(DEBUG_INFO,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
                 (unsigned)ntohs(p->dest.sin_port), 
                 inet_ntoa(p->src.sin_addr),
                 (unsigned)ntohs(p->src.sin_port), client_id, client->pid));
@@ -1058,7 +1058,7 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata)
        tcp.saddr = p->src;
        tcp.daddr = p->dest;
        if (ctdb_tcp_find(vnn->tcp_array, &tcp) != NULL) {
-               DEBUG(4,("Already had tickle info for %s:%u for vnn:%u\n",
+               DEBUG(DEBUG_DEBUG,("Already had tickle info for %s:%u for vnn:%u\n",
                         inet_ntoa(tcp.daddr.sin_addr),
                         ntohs(tcp.daddr.sin_port),
                         vnn->pnn));
@@ -1076,7 +1076,7 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata)
        tcparray->connections[tcparray->num].daddr = p->dest;
        tcparray->num++;
                                
-       DEBUG(2,("Added tickle info for %s:%u from vnn %u\n",
+       DEBUG(DEBUG_INFO,("Added tickle info for %s:%u from vnn %u\n",
                 inet_ntoa(tcp.daddr.sin_addr),
                 ntohs(tcp.daddr.sin_port),
                 vnn->pnn));
@@ -1104,7 +1104,7 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
           and we dont need to do anything
         */
        if (vnn->tcp_array == NULL) {
-               DEBUG(2,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
+               DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
                         inet_ntoa(conn->daddr.sin_addr),
                         ntohs(conn->daddr.sin_port)));
                return;
@@ -1116,7 +1116,7 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
         */
        tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
        if (tcpp == NULL) {
-               DEBUG(2,("Trying to remove tickle that doesnt exist %s:%u\n",
+               DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist %s:%u\n",
                         inet_ntoa(conn->daddr.sin_addr),
                         ntohs(conn->daddr.sin_port)));
                return;
@@ -1141,7 +1141,7 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
 
        vnn->tcp_update_needed = true;
 
-       DEBUG(2,("Removed tickle info for %s:%u\n",
+       DEBUG(DEBUG_INFO,("Removed tickle info for %s:%u\n",
                 inet_ntoa(conn->saddr.sin_addr),
                 ntohs(conn->saddr.sin_port)));
 }
@@ -1307,7 +1307,7 @@ static void capture_tcp_handler(struct event_context *ev, struct fd_event *fde,
        /* This one has been tickled !
           now reset him and remove him from the list.
         */
-       DEBUG(1, ("sending a tcp reset to kill connection :%d -> %s:%d\n", ntohs(con->dst.sin_port), inet_ntoa(con->src.sin_addr), ntohs(con->src.sin_port)));
+       DEBUG(DEBUG_INFO, ("sending a tcp reset to kill connection :%d -> %s:%d\n", ntohs(con->dst.sin_port), inet_ntoa(con->src.sin_addr), ntohs(con->src.sin_port)));
 
        ctdb_sys_send_tcp(killtcp->sending_fd, &con->dst, 
                          &con->src, ack_seq, seq, 1);

diff --git a/server/eventscript.c b/server/eventscript.c
index d82d9d7f7cdc8f70a1e32ad1c8cc6f28c4b26d6a..17090975b101d1df775995851a0b994ac96fcddd 100644 (file)
--- a/server/eventscript.c
+++ b/server/eventscript.c
@@ -156,7 +156,7 @@ static int ctdb_event_script_v(struct ctdb_context *ctdb, const char *fmt, va_li
                                script, options);
                CTDB_NO_MEMORY(ctdb, cmdstr);
 
-               DEBUG(1,("Executing event script %s\n",cmdstr));
+               DEBUG(DEBUG_INFO,("Executing event script %s\n",cmdstr));
 
                child_state.start = timeval_current();
                child_state.script_running = cmdstr;

diff --git a/tcp/tcp_connect.c b/tcp/tcp_connect.c
index 3c4e7bfb10dc5a1bfac4617f237f099dab49b750..0d1f402c24dc7083c2dbf72f36bd75677d6b24ba 100644 (file)
--- a/tcp/tcp_connect.c
+++ b/tcp/tcp_connect.c
@@ -308,7 +308,7 @@ static int ctdb_tcp_listen_automatic(struct ctdb_context *ctdb)
                                     ctdb->address.port);
        ctdb->pnn = ctdb->nodes[i]->pnn;
        ctdb->nodes[i]->flags &= ~NODE_FLAGS_DISCONNECTED;
-       DEBUG(1,("ctdb chose network address %s:%u pnn %u\n", 
+       DEBUG(DEBUG_INFO,("ctdb chose network address %s:%u pnn %u\n", 
                 ctdb->address.address, 
                 ctdb->address.port, 
                 ctdb->pnn));