PF: Remove debugging output

diff --git a/sys/net/pf/if_pflog.c b/sys/net/pf/if_pflog.c
index 7c1fd2f..bf88b86 100644 (file)
--- a/sys/net/pf/if_pflog.c
+++ b/sys/net/pf/if_pflog.c
@@ -312,10 +312,8 @@ pflog_modevent(module_t mod, int type, void *data)
                break;
 
        case MOD_UNLOAD:
-               kprintf("PF: if_pflog MOD_UNLOAD\n"); /* XXX */
                if_clone_detach(&pflog_cloner);
                while (!LIST_EMPTY(&pflogif_list)) {
-                       kprintf("PF: if_pflog MOD_UNLOAD p1\n"); /* XXX */
                        pflog_clone_destroy(
                                &LIST_FIRST(&pflogif_list)->sc_if);
                }

diff --git a/sys/net/pf/pf.c b/sys/net/pf/pf.c
index 594fdaf..d600b47 100644 (file)
--- a/sys/net/pf/pf.c
+++ b/sys/net/pf/pf.c
@@ -886,20 +886,15 @@ pf_insert_state(struct pfi_kif *kif, struct pf_state *state)
 void
 pf_purge_thread(void *v)
 {
-       kprintf("PF: Entering pf_purge_thread()\n");
-       kprintf("PF: pf_end_threads before: %i\n", pf_end_threads);
        int nloops = 0;
        int locked = 0;
 
        for (;;) {
-               kprintf("PF: Entering pf_purge_thread() for-loop start\n");
-               kprintf("PF: pf_end_threads in loop: %i\n", pf_end_threads);
                tsleep(pf_purge_thread, PWAIT, "pftm", 1 * hz);
 
                lockmgr(&pf_consistency_lock, LK_EXCLUSIVE);
 
                if (pf_end_threads) {
-                       kprintf("PF: Entering pf_purge_thread() pf_end_threads!\n");
                        pf_purge_expired_states(pf_status.states, 1);
                        pf_purge_expired_fragments();
                        pf_purge_expired_src_nodes(1);
@@ -1098,7 +1093,6 @@ pf_purge_expired_states(u_int32_t maxcheck, int waslocked)
        int                      locked = waslocked;
 
        while (maxcheck--) {
-               kprintf("PF: pf_purge_expired_states() 1\n");
                /* wrap to start of list when we hit the end */
                if (cur == NULL) {
                        cur = TAILQ_FIRST(&state_list);
@@ -1111,24 +1105,19 @@ pf_purge_expired_states(u_int32_t maxcheck, int waslocked)
 
                if (cur->timeout == PFTM_UNLINKED) {
                        /* free unlinked state */
-                       kprintf("PF: pf_purge_expired_states() 2\n");
                        if (! locked) {
-                               kprintf("PF: pf_purge_expired_states() 3\n");
                                lockmgr(&pf_consistency_lock, LK_EXCLUSIVE);
                                locked = 1;
                        }
                        pf_free_state(cur);
                } else if (pf_state_expires(cur) <= time_second) {
                        /* unlink and free expired state */
-                       kprintf("PF: pf_purge_expired_states() 4\n");
                        pf_unlink_state(cur);
                        if (! locked) {
-                               kprintf("PF: pf_purge_expired_states() 5\n");
                                if (!lockmgr(&pf_consistency_lock, LK_EXCLUSIVE))
                                        return (0);
                                locked = 1;
                        }
-                       kprintf("PF: pf_purge_expired_states() 6\n");
                        pf_free_state(cur);
                }
                cur = next;

diff --git a/sys/net/pf/pf_ioctl.c b/sys/net/pf/pf_ioctl.c
index f170ac4..bfce6e2 100644 (file)
--- a/sys/net/pf/pf_ioctl.c
+++ b/sys/net/pf/pf_ioctl.c
@@ -3019,27 +3019,20 @@ pf_clear_states(void)
 {
        struct pf_state         *state;
 
-       kprintf("PF: pf_clear_states() 1\n");
        RB_FOREACH(state, pf_state_tree_id, &tree_id) {
-               kprintf("PF: pf_Cclear_states() in RB_FOREACH\n");
                state->timeout = PFTM_PURGE;
 #if NPFSYNC
                /* don't send out individual delete messages */
-               kprintf("PF: pf_clear_states() 2\n");
                state->sync_flags = PFSTATE_NOSYNC;
 #endif
                pf_unlink_state(state);
        }
-       kprintf("PF: pf_clear_states() 3\n");
-       kprintf("PF: pf_clear_states() 4\n");
        pf_status.states = 0;
-       kprintf("PF: pf_clear_states() 5\n");
 #if 0 /* NPFSYNC */
 /*
  * XXX This is called on module unload, we do not want to sync that over? */
  */
        pfsync_clear_states(pf_status.hostid, psk->psk_ifname);
-       kprintf("PF: pf_clear_states() 6\n");
 #endif
 }
 
@@ -3090,35 +3083,29 @@ shutdown_pf(void)
 
        pf_status.running = 0;
        do {
-               kprintf("PF: shutdown_pf 1\n");
                if ((error = pf_begin_rules(&t[0], PF_RULESET_SCRUB, &nn)) != 0) {
                        DPFPRINTF(PF_DEBUG_MISC, ("shutdown_pf: SCRUB\n"));
                        break;
                }
-               kprintf("PF: shutdown_pf 2\n");
                if ((error = pf_begin_rules(&t[1], PF_RULESET_FILTER, &nn)) != 0) {
                        DPFPRINTF(PF_DEBUG_MISC, ("shutdown_pf: FILTER\n"));
                        break;          /* XXX: rollback? */
                }
-               kprintf("PF: shutdown_pf 3\n");
                if ((error = pf_begin_rules(&t[2], PF_RULESET_NAT, &nn))    != 0) {
                        DPFPRINTF(PF_DEBUG_MISC, ("shutdown_pf: NAT\n"));
                        break;          /* XXX: rollback? */
                }
-               kprintf("PF: shutdown_pf 4\n");
                if ((error = pf_begin_rules(&t[3], PF_RULESET_BINAT, &nn))
                    != 0) {
                        DPFPRINTF(PF_DEBUG_MISC, ("shutdown_pf: BINAT\n"));
                        break;          /* XXX: rollback? */
                }
-               kprintf("PF: shutdown_pf 5\n");
                if ((error = pf_begin_rules(&t[4], PF_RULESET_RDR, &nn))
                    != 0) {
                        DPFPRINTF(PF_DEBUG_MISC, ("shutdown_pf: RDR\n"));
                        break;          /* XXX: rollback? */
                }
 
-               kprintf("PF: shutdown_pf 6\n");
                /* XXX: these should always succeed here */
                pf_commit_rules(t[0], PF_RULESET_SCRUB, &nn);
                pf_commit_rules(t[1], PF_RULESET_FILTER, &nn);
@@ -3129,7 +3116,6 @@ shutdown_pf(void)
                if ((error = pf_clear_tables()) != 0)
                        break;
 
-               kprintf("PF: shutdown_pf 7\n");
 #ifdef ALTQ
                if ((error = pf_begin_altq(&t[0])) != 0) {
                        DPFPRINTF(PF_DEBUG_MISC, ("shutdown_pf: ALTQ\n"));
@@ -3139,15 +3125,12 @@ shutdown_pf(void)
 #endif
 
                pf_clear_states();
-               kprintf("PF: shutdown_pf 8\n");
 
                pf_clear_srcnodes();
-               kprintf("PF: shutdown_pf 9\n");
 
                /* status does not use malloced mem so no need to cleanup */
                /* fingerprints and interfaces have their own cleanup code */
        } while(0);
-       kprintf("PF: shutdown_pf 10\n");
 
         return (error);
 }
@@ -3316,7 +3299,6 @@ pf_load(void)
 static int
 pf_unload(void)
 {
-       kprintf("PF: Entering pf_unload()\n"); /* XXX */
        int error;
 
        pf_status.running = 0;
@@ -3330,30 +3312,19 @@ pf_unload(void)
                kprintf("pfil unregistration fail\n");
                return error;
        }
-       kprintf("PF: pf_unload() p1\n"); /* XXX */
        shutdown_pf();
-       kprintf("PF: pf_unload() p2\n"); /* XXX */
        pf_end_threads = 1;
        while (pf_end_threads < 2) {
-               kprintf("PF: while-loop, pf_end_threads: %i\n", pf_end_threads);
                wakeup_one(pf_purge_thread);
-               kprintf("PF: while-loop, after wakeup_one\n");
                lksleep(pf_purge_thread, &pf_task_lck, 0, "pftmo", hz);
-               kprintf("PF: while-loop, after lksleep\n");
 
        }
        pfi_cleanup();
-       kprintf("PF: pf_unload() p3\n"); /* XXX */
        pf_osfp_flush();
-       kprintf("PF: pf_unload() p4\n"); /* XXX */
        pf_osfp_cleanup();
-       kprintf("PF: pf_unload() p5\n"); /* XXX */
        cleanup_pf_zone();
-       kprintf("PF: pf_unload() p6\n"); /* XXX */
        dev_ops_remove_all(&pf_ops);
-       kprintf("PF: pf_unload() p7\n"); /* XXX */
        lockuninit(&pf_consistency_lock);
-       kprintf("PF: pf_unload() finished\n"); /* XXX */
        destroy_pf_lck();
        return 0;
 }
@@ -3361,7 +3332,6 @@ pf_unload(void)
 static int
 pf_modevent(module_t mod, int type, void *data)
 {
-       kprintf("PF: Entering pf_modevent()\n"); /* XXX */
        int error = 0;
 
        switch(type) {
@@ -3370,9 +3340,7 @@ pf_modevent(module_t mod, int type, void *data)
                break;
 
        case MOD_UNLOAD:
-               kprintf("PF: CASE MOD_UNLOAD\n"); /* XXX */
                error = pf_unload();
-               kprintf("PF: pf_modevent, pf_unload() finished\n"); /* XXX */
                break;
        default:
                error = EINVAL;