[NETFILTER]: Convert DEBUGP to pr_debug

Convert DEBUGP to pr_debug and fix lots of non-compiling debug statements.

Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

11 files changed, 160 insertions, 223 deletions

diff --git a/net/ipv6/netfilter/ip6t_LOG.c b/net/ipv6/netfilter/ip6t_LOG.c
index 540bf14b851c..b05327ebd332 100644
--- a/net/ipv6/netfilter/ip6t_LOG.c
+++ b/net/ipv6/netfilter/ip6t_LOG.c
@@ -32,12 +32,6 @@ struct in_device;
 #include <net/route.h>
 #include <linux/netfilter_ipv6/ip6t_LOG.h>
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 /* Use lock to serialize, so printks don't overlap */
 static DEFINE_SPINLOCK(log_lock);
 
@@ -466,12 +460,12 @@ static bool ip6t_log_checkentry(const char *tablename,
         const struct ip6t_log_info *loginfo = targinfo;
 
         if (loginfo->level >= 8) {
-                DEBUGP("LOG: level %u >= 8\n", loginfo->level);
+                pr_debug("LOG: level %u >= 8\n", loginfo->level);
                 return false;
         }
         if (loginfo->prefix[sizeof(loginfo->prefix)-1] != '\0') {
-                DEBUGP("LOG: prefix term %i\n",
-                       loginfo->prefix[sizeof(loginfo->prefix)-1]);
+                pr_debug("LOG: prefix term %i\n",
+                         loginfo->prefix[sizeof(loginfo->prefix)-1]);
                 return false;
         }
         return true;
diff --git a/net/ipv6/netfilter/ip6t_REJECT.c b/net/ipv6/netfilter/ip6t_REJECT.c
index 14008dc6a197..2f487cda3b6b 100644
--- a/net/ipv6/netfilter/ip6t_REJECT.c
+++ b/net/ipv6/netfilter/ip6t_REJECT.c
@@ -34,12 +34,6 @@ MODULE_AUTHOR("Yasuyuki KOZAKAI <yasuyuki.kozakai@toshiba.co.jp>");
 MODULE_DESCRIPTION("IP6 tables REJECT target module");
 MODULE_LICENSE("GPL");
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 /* Send RST reply */
 static void send_reset(struct sk_buff *oldskb)
 {
@@ -54,7 +48,7 @@ static void send_reset(struct sk_buff *oldskb)
 
         if ((!(ipv6_addr_type(&oip6h->saddr) & IPV6_ADDR_UNICAST)) ||
             (!(ipv6_addr_type(&oip6h->daddr) & IPV6_ADDR_UNICAST))) {
-                DEBUGP("ip6t_REJECT: addr is not unicast.\n");
+                pr_debug("ip6t_REJECT: addr is not unicast.\n");
                 return;
         }
 
@@ -62,7 +56,7 @@ static void send_reset(struct sk_buff *oldskb)
         tcphoff = ipv6_skip_exthdr(oldskb, ((u8*)(oip6h+1) - oldskb->data), &proto);
 
         if ((tcphoff < 0) || (tcphoff > oldskb->len)) {
-                DEBUGP("ip6t_REJECT: Can't get TCP header.\n");
+                pr_debug("ip6t_REJECT: Can't get TCP header.\n");
                 return;
         }
 
@@ -70,8 +64,9 @@ static void send_reset(struct sk_buff *oldskb)
 
         /* IP header checks: fragment, too short. */
         if (proto != IPPROTO_TCP || otcplen < sizeof(struct tcphdr)) {
-                DEBUGP("ip6t_REJECT: proto(%d) != IPPROTO_TCP, or too short. otcplen = %d\n",
-                        proto, otcplen);
+                pr_debug("ip6t_REJECT: proto(%d) != IPPROTO_TCP, "
+                         "or too short. otcplen = %d\n",
+                         proto, otcplen);
                 return;
         }
 
@@ -80,14 +75,14 @@ static void send_reset(struct sk_buff *oldskb)
 
         /* No RST for RST. */
         if (otcph.rst) {
-                DEBUGP("ip6t_REJECT: RST is set\n");
+                pr_debug("ip6t_REJECT: RST is set\n");
                 return;
         }
 
         /* Check checksum. */
         if (csum_ipv6_magic(&oip6h->saddr, &oip6h->daddr, otcplen, IPPROTO_TCP,
                             skb_checksum(oldskb, tcphoff, otcplen, 0))) {
-                DEBUGP("ip6t_REJECT: TCP checksum is invalid\n");
+                pr_debug("ip6t_REJECT: TCP checksum is invalid\n");
                 return;
         }
 
@@ -186,7 +181,7 @@ static unsigned int reject6_target(struct sk_buff **pskb,
 {
         const struct ip6t_reject_info *reject = targinfo;
 
-        DEBUGP(KERN_DEBUG "%s: medium point\n", __FUNCTION__);
+        pr_debug("%s: medium point\n", __FUNCTION__);
         /* WARNING: This code causes reentry within ip6tables.
            This means that the ip6tables jump stack is now crap.  We
            must return an absolute verdict. --RR */
@@ -237,7 +232,7 @@ static bool check(const char *tablename,
                 /* Must specify that it's a TCP packet */
                 if (e->ipv6.proto != IPPROTO_TCP
                     || (e->ipv6.invflags & XT_INV_PROTO)) {
-                        DEBUGP("ip6t_REJECT: TCP_RESET illegal for non-tcp\n");
+                        printk("ip6t_REJECT: TCP_RESET illegal for non-tcp\n");
                         return false;
                 }
         }
diff --git a/net/ipv6/netfilter/ip6t_ah.c b/net/ipv6/netfilter/ip6t_ah.c
index a9fe2aa97072..2a25fe25e0e0 100644
--- a/net/ipv6/netfilter/ip6t_ah.c
+++ b/net/ipv6/netfilter/ip6t_ah.c
@@ -23,21 +23,16 @@ MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("IPv6 AH match");
 MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 /* Returns 1 if the spi is matched by the range, 0 otherwise */
 static inline bool
 spi_match(u_int32_t min, u_int32_t max, u_int32_t spi, bool invert)
 {
         bool r;
-        DEBUGP("ah spi_match:%c 0x%x <= 0x%x <= 0x%x",invert? '!':' ',
-               min,spi,max);
+
+        pr_debug("ah spi_match:%c 0x%x <= 0x%x <= 0x%x",
+                 invert ? '!' : ' ', min, spi, max);
         r = (spi >= min && spi <= max) ^ invert;
-        DEBUGP(" result %s\n",r? "PASS\n" : "FAILED\n");
+        pr_debug(" result %s\n", r ? "PASS" : "FAILED");
         return r;
 }
 
@@ -73,22 +68,22 @@ match(const struct sk_buff *skb,
 
         hdrlen = (ah->hdrlen + 2) << 2;
 
-        DEBUGP("IPv6 AH LEN %u %u ", hdrlen, ah->hdrlen);
-        DEBUGP("RES %04X ", ah->reserved);
-        DEBUGP("SPI %u %08X\n", ntohl(ah->spi), ntohl(ah->spi));
-
-        DEBUGP("IPv6 AH spi %02X ",
-               spi_match(ahinfo->spis[0], ahinfo->spis[1],
-                         ntohl(ah->spi),
-                         !!(ahinfo->invflags & IP6T_AH_INV_SPI)));
-        DEBUGP("len %02X %04X %02X ",
-               ahinfo->hdrlen, hdrlen,
-               (!ahinfo->hdrlen ||
-                (ahinfo->hdrlen == hdrlen) ^
-                !!(ahinfo->invflags & IP6T_AH_INV_LEN)));
-        DEBUGP("res %02X %04X %02X\n",
-               ahinfo->hdrres, ah->reserved,
-               !(ahinfo->hdrres && ah->reserved));
+        pr_debug("IPv6 AH LEN %u %u ", hdrlen, ah->hdrlen);
+        pr_debug("RES %04X ", ah->reserved);
+        pr_debug("SPI %u %08X\n", ntohl(ah->spi), ntohl(ah->spi));
+
+        pr_debug("IPv6 AH spi %02X ",
+                 spi_match(ahinfo->spis[0], ahinfo->spis[1],
+                           ntohl(ah->spi),
+                           !!(ahinfo->invflags & IP6T_AH_INV_SPI)));
+        pr_debug("len %02X %04X %02X ",
+                 ahinfo->hdrlen, hdrlen,
+                 (!ahinfo->hdrlen ||
+                  (ahinfo->hdrlen == hdrlen) ^
+                  !!(ahinfo->invflags & IP6T_AH_INV_LEN)));
+        pr_debug("res %02X %04X %02X\n",
+                 ahinfo->hdrres, ah->reserved,
+                 !(ahinfo->hdrres && ah->reserved));
 
         return (ah != NULL)
                &&
@@ -114,7 +109,7 @@ checkentry(const char *tablename,
         const struct ip6t_ah *ahinfo = matchinfo;
 
         if (ahinfo->invflags & ~IP6T_AH_INV_MASK) {
-                DEBUGP("ip6t_ah: unknown flags %X\n", ahinfo->invflags);
+                pr_debug("ip6t_ah: unknown flags %X\n", ahinfo->invflags);
                 return false;
         }
         return true;
diff --git a/net/ipv6/netfilter/ip6t_frag.c b/net/ipv6/netfilter/ip6t_frag.c
index bb1cfa82b47c..968aeba02073 100644
--- a/net/ipv6/netfilter/ip6t_frag.c
+++ b/net/ipv6/netfilter/ip6t_frag.c
@@ -22,21 +22,15 @@ MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("IPv6 FRAG match");
 MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 /* Returns 1 if the id is matched by the range, 0 otherwise */
 static inline bool
 id_match(u_int32_t min, u_int32_t max, u_int32_t id, bool invert)
 {
         bool r;
-        DEBUGP("frag id_match:%c 0x%x <= 0x%x <= 0x%x", invert ? '!' : ' ',
-               min, id, max);
+        pr_debug("frag id_match:%c 0x%x <= 0x%x <= 0x%x", invert ? '!' : ' ',
+                 min, id, max);
         r = (id >= min && id <= max) ^ invert;
-        DEBUGP(" result %s\n", r ? "PASS" : "FAILED");
+        pr_debug(" result %s\n", r ? "PASS" : "FAILED");
         return r;
 }
 
@@ -69,37 +63,37 @@ match(const struct sk_buff *skb,
                 return false;
         }
 
-        DEBUGP("INFO %04X ", fh->frag_off);
-        DEBUGP("OFFSET %04X ", ntohs(fh->frag_off) & ~0x7);
-        DEBUGP("RES %02X %04X", fh->reserved, ntohs(fh->frag_off) & 0x6);
-        DEBUGP("MF %04X ", fh->frag_off & htons(IP6_MF));
-        DEBUGP("ID %u %08X\n", ntohl(fh->identification),
-               ntohl(fh->identification));
-
-        DEBUGP("IPv6 FRAG id %02X ",
-               id_match(fraginfo->ids[0], fraginfo->ids[1],
-                         ntohl(fh->identification),
-                         !!(fraginfo->invflags & IP6T_FRAG_INV_IDS)));
-        DEBUGP("res %02X %02X%04X %02X ",
-               fraginfo->flags & IP6T_FRAG_RES, fh->reserved,
-               ntohs(fh->frag_off) & 0x6,
-               !((fraginfo->flags & IP6T_FRAG_RES)
-                 && (fh->reserved || (ntohs(fh->frag_off) & 0x06))));
-        DEBUGP("first %02X %02X %02X ",
-               fraginfo->flags & IP6T_FRAG_FST,
-               ntohs(fh->frag_off) & ~0x7,
-               !((fraginfo->flags & IP6T_FRAG_FST)
-                 && (ntohs(fh->frag_off) & ~0x7)));
-        DEBUGP("mf %02X %02X %02X ",
-               fraginfo->flags & IP6T_FRAG_MF,
-               ntohs(fh->frag_off) & IP6_MF,
-               !((fraginfo->flags & IP6T_FRAG_MF)
-                 && !((ntohs(fh->frag_off) & IP6_MF))));
-        DEBUGP("last %02X %02X %02X\n",
-               fraginfo->flags & IP6T_FRAG_NMF,
-               ntohs(fh->frag_off) & IP6_MF,
-               !((fraginfo->flags & IP6T_FRAG_NMF)
-                 && (ntohs(fh->frag_off) & IP6_MF)));
+        pr_debug("INFO %04X ", fh->frag_off);
+        pr_debug("OFFSET %04X ", ntohs(fh->frag_off) & ~0x7);
+        pr_debug("RES %02X %04X", fh->reserved, ntohs(fh->frag_off) & 0x6);
+        pr_debug("MF %04X ", fh->frag_off & htons(IP6_MF));
+        pr_debug("ID %u %08X\n", ntohl(fh->identification),
+                 ntohl(fh->identification));
+
+        pr_debug("IPv6 FRAG id %02X ",
+                 id_match(fraginfo->ids[0], fraginfo->ids[1],
+                          ntohl(fh->identification),
+                          !!(fraginfo->invflags & IP6T_FRAG_INV_IDS)));
+        pr_debug("res %02X %02X%04X %02X ",
+                 fraginfo->flags & IP6T_FRAG_RES, fh->reserved,
+                 ntohs(fh->frag_off) & 0x6,
+                 !((fraginfo->flags & IP6T_FRAG_RES)
+                   && (fh->reserved || (ntohs(fh->frag_off) & 0x06))));
+        pr_debug("first %02X %02X %02X ",
+                 fraginfo->flags & IP6T_FRAG_FST,
+                 ntohs(fh->frag_off) & ~0x7,
+                 !((fraginfo->flags & IP6T_FRAG_FST)
+                   && (ntohs(fh->frag_off) & ~0x7)));
+        pr_debug("mf %02X %02X %02X ",
+                 fraginfo->flags & IP6T_FRAG_MF,
+                 ntohs(fh->frag_off) & IP6_MF,
+                 !((fraginfo->flags & IP6T_FRAG_MF)
+                   && !((ntohs(fh->frag_off) & IP6_MF))));
+        pr_debug("last %02X %02X %02X\n",
+                 fraginfo->flags & IP6T_FRAG_NMF,
+                 ntohs(fh->frag_off) & IP6_MF,
+                 !((fraginfo->flags & IP6T_FRAG_NMF)
+                   && (ntohs(fh->frag_off) & IP6_MF)));
 
         return (fh != NULL)
                &&
@@ -131,7 +125,7 @@ checkentry(const char *tablename,
         const struct ip6t_frag *fraginfo = matchinfo;
 
         if (fraginfo->invflags & ~IP6T_FRAG_INV_MASK) {
-                DEBUGP("ip6t_frag: unknown flags %X\n", fraginfo->invflags);
+                pr_debug("ip6t_frag: unknown flags %X\n", fraginfo->invflags);
                 return false;
         }
         return true;
diff --git a/net/ipv6/netfilter/ip6t_hbh.c b/net/ipv6/netfilter/ip6t_hbh.c
index 6247d4cdad99..e6ca6018b1ea 100644
--- a/net/ipv6/netfilter/ip6t_hbh.c
+++ b/net/ipv6/netfilter/ip6t_hbh.c
@@ -25,12 +25,6 @@ MODULE_DESCRIPTION("IPv6 opts match");
 MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 MODULE_ALIAS("ip6t_dst");
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 /*
  *  (Type & 0xC0) >> 6
  *      0       -> ignorable
@@ -90,13 +84,13 @@ match(const struct sk_buff *skb,
                 return false;
         }
 
-        DEBUGP("IPv6 OPTS LEN %u %u ", hdrlen, oh->hdrlen);
+        pr_debug("IPv6 OPTS LEN %u %u ", hdrlen, oh->hdrlen);
 
-        DEBUGP("len %02X %04X %02X ",
-               optinfo->hdrlen, hdrlen,
-               (!(optinfo->flags & IP6T_OPTS_LEN) ||
-                ((optinfo->hdrlen == hdrlen) ^
-                 !!(optinfo->invflags & IP6T_OPTS_INV_LEN))));
+        pr_debug("len %02X %04X %02X ",
+                 optinfo->hdrlen, hdrlen,
+                 (!(optinfo->flags & IP6T_OPTS_LEN) ||
+                  ((optinfo->hdrlen == hdrlen) ^
+                   !!(optinfo->invflags & IP6T_OPTS_INV_LEN))));
 
         ret = (oh != NULL) &&
               (!(optinfo->flags & IP6T_OPTS_LEN) ||
@@ -108,10 +102,10 @@ match(const struct sk_buff *skb,
         if (!(optinfo->flags & IP6T_OPTS_OPTS)) {
                 return ret;
         } else if (optinfo->flags & IP6T_OPTS_NSTRICT) {
-                DEBUGP("Not strict - not implemented");
+                pr_debug("Not strict - not implemented");
         } else {
-                DEBUGP("Strict ");
-                DEBUGP("#%d ", optinfo->optsnr);
+                pr_debug("Strict ");
+                pr_debug("#%d ", optinfo->optsnr);
                 for (temp = 0; temp < optinfo->optsnr; temp++) {
                         /* type field exists ? */
                         if (hdrlen < 1)
@@ -123,12 +117,11 @@ match(const struct sk_buff *skb,
 
                         /* Type check */
                         if (*tp != (optinfo->opts[temp] & 0xFF00) >> 8) {
-                                DEBUGP("Tbad %02X %02X\n",
-                                       *tp,
-                                       (optinfo->opts[temp] & 0xFF00) >> 8);
+                                pr_debug("Tbad %02X %02X\n", *tp,
+                                         (optinfo->opts[temp] & 0xFF00) >> 8);
                                 return false;
                         } else {
-                                DEBUGP("Tok ");
+                                pr_debug("Tok ");
                         }
                         /* Length check */
                         if (*tp) {
@@ -145,23 +138,23 @@ match(const struct sk_buff *skb,
                                 spec_len = optinfo->opts[temp] & 0x00FF;
 
                                 if (spec_len != 0x00FF && spec_len != *lp) {
-                                        DEBUGP("Lbad %02X %04X\n", *lp,
-                                               spec_len);
+                                        pr_debug("Lbad %02X %04X\n", *lp,
+                                                 spec_len);
                                         return false;
                                 }
-                                DEBUGP("Lok ");
+                                pr_debug("Lok ");
                                 optlen = *lp + 2;
                         } else {
-                                DEBUGP("Pad1\n");
+                                pr_debug("Pad1\n");
                                 optlen = 1;
                         }
 
                         /* Step to the next */
-                        DEBUGP("len%04X \n", optlen);
+                        pr_debug("len%04X \n", optlen);
 
                         if ((ptr > skb->len - optlen || hdrlen < optlen) &&
                             temp < optinfo->optsnr - 1) {
-                                DEBUGP("new pointer is too large! \n");
+                                pr_debug("new pointer is too large! \n");
                                 break;
                         }
                         ptr += optlen;
@@ -187,7 +180,7 @@ checkentry(const char *tablename,
         const struct ip6t_opts *optsinfo = matchinfo;
 
         if (optsinfo->invflags & ~IP6T_OPTS_INV_MASK) {
-                DEBUGP("ip6t_opts: unknown flags %X\n", optsinfo->invflags);
+                pr_debug("ip6t_opts: unknown flags %X\n", optsinfo->invflags);
                 return false;
         }
         return true;
diff --git a/net/ipv6/netfilter/ip6t_rt.c b/net/ipv6/netfilter/ip6t_rt.c
index 549deea26418..357cea703bd9 100644
--- a/net/ipv6/netfilter/ip6t_rt.c
+++ b/net/ipv6/netfilter/ip6t_rt.c
@@ -24,21 +24,15 @@ MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("IPv6 RT match");
 MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 /* Returns 1 if the id is matched by the range, 0 otherwise */
 static inline bool
 segsleft_match(u_int32_t min, u_int32_t max, u_int32_t id, bool invert)
 {
         bool r;
-        DEBUGP("rt segsleft_match:%c 0x%x <= 0x%x <= 0x%x",
-               invert ? '!' : ' ', min, id, max);
+        pr_debug("rt segsleft_match:%c 0x%x <= 0x%x <= 0x%x",
+                 invert ? '!' : ' ', min, id, max);
         r = (id >= min && id <= max) ^ invert;
-        DEBUGP(" result %s\n", r ? "PASS" : "FAILED");
+        pr_debug(" result %s\n", r ? "PASS" : "FAILED");
         return r;
 }
 
@@ -82,29 +76,29 @@ match(const struct sk_buff *skb,
                 return false;
         }
 
-        DEBUGP("IPv6 RT LEN %u %u ", hdrlen, rh->hdrlen);
-        DEBUGP("TYPE %04X ", rh->type);
-        DEBUGP("SGS_LEFT %u %02X\n", rh->segments_left, rh->segments_left);
-
-        DEBUGP("IPv6 RT segsleft %02X ",
-               segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
-                              rh->segments_left,
-                              !!(rtinfo->invflags & IP6T_RT_INV_SGS)));
-        DEBUGP("type %02X %02X %02X ",
-               rtinfo->rt_type, rh->type,
-               (!(rtinfo->flags & IP6T_RT_TYP) ||
-                ((rtinfo->rt_type == rh->type) ^
-                 !!(rtinfo->invflags & IP6T_RT_INV_TYP))));
-        DEBUGP("len %02X %04X %02X ",
-               rtinfo->hdrlen, hdrlen,
-               !(rtinfo->flags & IP6T_RT_LEN) ||
-                ((rtinfo->hdrlen == hdrlen) ^
-                 !!(rtinfo->invflags & IP6T_RT_INV_LEN)));
-        DEBUGP("res %02X %02X %02X ",
-               rtinfo->flags & IP6T_RT_RES,
-               ((const struct rt0_hdr *)rh)->reserved,
-               !((rtinfo->flags & IP6T_RT_RES) &&
-                 (((const struct rt0_hdr *)rh)->reserved)));
+        pr_debug("IPv6 RT LEN %u %u ", hdrlen, rh->hdrlen);
+        pr_debug("TYPE %04X ", rh->type);
+        pr_debug("SGS_LEFT %u %02X\n", rh->segments_left, rh->segments_left);
+
+        pr_debug("IPv6 RT segsleft %02X ",
+                 segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
+                                rh->segments_left,
+                                !!(rtinfo->invflags & IP6T_RT_INV_SGS)));
+        pr_debug("type %02X %02X %02X ",
+                 rtinfo->rt_type, rh->type,
+                 (!(rtinfo->flags & IP6T_RT_TYP) ||
+                  ((rtinfo->rt_type == rh->type) ^
+                   !!(rtinfo->invflags & IP6T_RT_INV_TYP))));
+        pr_debug("len %02X %04X %02X ",
+                 rtinfo->hdrlen, hdrlen,
+                 !(rtinfo->flags & IP6T_RT_LEN) ||
+                  ((rtinfo->hdrlen == hdrlen) ^
+                   !!(rtinfo->invflags & IP6T_RT_INV_LEN)));
+        pr_debug("res %02X %02X %02X ",
+                 rtinfo->flags & IP6T_RT_RES,
+                 ((const struct rt0_hdr *)rh)->reserved,
+                 !((rtinfo->flags & IP6T_RT_RES) &&
+                   (((const struct rt0_hdr *)rh)->reserved)));
 
         ret = (rh != NULL)
               &&
@@ -131,18 +125,18 @@ match(const struct sk_buff *skb,
                 ret = (*rp == 0);
         }
 
-        DEBUGP("#%d ", rtinfo->addrnr);
+        pr_debug("#%d ", rtinfo->addrnr);
         if (!(rtinfo->flags & IP6T_RT_FST)) {
                 return ret;
         } else if (rtinfo->flags & IP6T_RT_FST_NSTRICT) {
-                DEBUGP("Not strict ");
+                pr_debug("Not strict ");
                 if (rtinfo->addrnr > (unsigned int)((hdrlen - 8) / 16)) {
-                        DEBUGP("There isn't enough space\n");
+                        pr_debug("There isn't enough space\n");
                         return false;
                 } else {
                         unsigned int i = 0;
 
-                        DEBUGP("#%d ", rtinfo->addrnr);
+                        pr_debug("#%d ", rtinfo->addrnr);
                         for (temp = 0;
                              temp < (unsigned int)((hdrlen - 8) / 16);
                              temp++) {
@@ -156,25 +150,25 @@ match(const struct sk_buff *skb,
                                 BUG_ON(ap == NULL);
 
                                 if (ipv6_addr_equal(ap, &rtinfo->addrs[i])) {
-                                        DEBUGP("i=%d temp=%d;\n", i, temp);
+                                        pr_debug("i=%d temp=%d;\n", i, temp);
                                         i++;
                                 }
                                 if (i == rtinfo->addrnr)
                                         break;
                         }
-                        DEBUGP("i=%d #%d\n", i, rtinfo->addrnr);
+                        pr_debug("i=%d #%d\n", i, rtinfo->addrnr);
                         if (i == rtinfo->addrnr)
                                 return ret;
                         else
                                 return false;
                 }
         } else {
-                DEBUGP("Strict ");
+                pr_debug("Strict ");
                 if (rtinfo->addrnr > (unsigned int)((hdrlen - 8) / 16)) {
-                        DEBUGP("There isn't enough space\n");
+                        pr_debug("There isn't enough space\n");
                         return false;
                 } else {
-                        DEBUGP("#%d ", rtinfo->addrnr);
+                        pr_debug("#%d ", rtinfo->addrnr);
                         for (temp = 0; temp < rtinfo->addrnr; temp++) {
                                 ap = skb_header_pointer(skb,
                                                         ptr
@@ -187,7 +181,7 @@ match(const struct sk_buff *skb,
                                 if (!ipv6_addr_equal(ap, &rtinfo->addrs[temp]))
                                         break;
                         }
-                        DEBUGP("temp=%d #%d\n", temp, rtinfo->addrnr);
+                        pr_debug("temp=%d #%d\n", temp, rtinfo->addrnr);
                         if (temp == rtinfo->addrnr &&
                             temp == (unsigned int)((hdrlen - 8) / 16))
                                 return ret;
@@ -210,14 +204,14 @@ checkentry(const char *tablename,
         const struct ip6t_rt *rtinfo = matchinfo;
 
         if (rtinfo->invflags & ~IP6T_RT_INV_MASK) {
-                DEBUGP("ip6t_rt: unknown flags %X\n", rtinfo->invflags);
+                pr_debug("ip6t_rt: unknown flags %X\n", rtinfo->invflags);
                 return false;
         }
         if ((rtinfo->flags & (IP6T_RT_RES | IP6T_RT_FST_MASK)) &&
             (!(rtinfo->flags & IP6T_RT_TYP) ||
              (rtinfo->rt_type != 0) ||
              (rtinfo->invflags & IP6T_RT_INV_TYP))) {
-                DEBUGP("`--rt-type 0' required before `--rt-0-*'");
+                pr_debug("`--rt-type 0' required before `--rt-0-*'");
                 return false;
         }
 
diff --git a/net/ipv6/netfilter/ip6table_mangle.c b/net/ipv6/netfilter/ip6table_mangle.c
index f2d26495f413..f0a9efa67fb5 100644
--- a/net/ipv6/netfilter/ip6table_mangle.c
+++ b/net/ipv6/netfilter/ip6table_mangle.c
@@ -21,12 +21,6 @@ MODULE_DESCRIPTION("ip6tables mangle table");
                             (1 << NF_IP6_LOCAL_OUT) | \
                             (1 << NF_IP6_POST_ROUTING))
 
-#if 0
-#define DEBUGP(x, args...)      printk(KERN_DEBUG x, ## args)
-#else
-#define DEBUGP(x, args...)
-#endif
-
 static struct
 {
         struct ip6t_replace repl;
diff --git a/net/ipv6/netfilter/ip6table_raw.c b/net/ipv6/netfilter/ip6table_raw.c
index 0acda45d455d..ec290e4ebdd8 100644
--- a/net/ipv6/netfilter/ip6table_raw.c
+++ b/net/ipv6/netfilter/ip6table_raw.c
@@ -8,12 +8,6 @@
 
 #define RAW_VALID_HOOKS ((1 << NF_IP6_PRE_ROUTING) | (1 << NF_IP6_LOCAL_OUT))
 
-#if 0
-#define DEBUGP(x, args...)      printk(KERN_DEBUG x, ## args)
-#else
-#define DEBUGP(x, args...)
-#endif
-
 static struct
 {
         struct ip6t_replace repl;
diff --git a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
index 747b01e53132..89e20ab494b8 100644
--- a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
+++ b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
@@ -26,12 +26,6 @@
 #include <net/netfilter/nf_conntrack_l3proto.h>
 #include <net/netfilter/nf_conntrack_core.h>
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 static int ipv6_pkt_to_tuple(const struct sk_buff *skb, unsigned int nhoff,
                              struct nf_conntrack_tuple *tuple)
 {
@@ -136,7 +130,7 @@ ipv6_prepare(struct sk_buff **pskb, unsigned int hooknum, unsigned int *dataoff,
          * except of IPv6 & ext headers. but it's tracked anyway. - YK
          */
         if ((protoff < 0) || (protoff > (*pskb)->len)) {
-                DEBUGP("ip6_conntrack_core: can't find proto in pkt\n");
+                pr_debug("ip6_conntrack_core: can't find proto in pkt\n");
                 NF_CT_STAT_INC_ATOMIC(error);
                 NF_CT_STAT_INC_ATOMIC(invalid);
                 return -NF_ACCEPT;
@@ -178,7 +172,7 @@ static unsigned int ipv6_confirm(unsigned int hooknum,
         protoff = nf_ct_ipv6_skip_exthdr(*pskb, extoff, &pnum,
                                          (*pskb)->len - extoff);
         if (protoff > (*pskb)->len || pnum == NEXTHDR_FRAGMENT) {
-                DEBUGP("proto header not found\n");
+                pr_debug("proto header not found\n");
                 return NF_ACCEPT;
         }
 
diff --git a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
index a514661d25dd..9defc7e14554 100644
--- a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
+++ b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
@@ -27,12 +27,6 @@
 
 static unsigned long nf_ct_icmpv6_timeout __read_mostly = 30*HZ;
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 static int icmpv6_pkt_to_tuple(const struct sk_buff *skb,
                                unsigned int dataoff,
                                struct nf_conntrack_tuple *tuple)
@@ -125,8 +119,8 @@ static int icmpv6_new(struct nf_conn *conntrack,
 
         if (type < 0 || type >= sizeof(valid_new) || !valid_new[type]) {
                 /* Can't create a new ICMPv6 `conn' with this. */
-                DEBUGP("icmpv6: can't create new conn with type %u\n",
-                       type + 128);
+                pr_debug("icmpv6: can't create new conn with type %u\n",
+                         type + 128);
                 NF_CT_DUMP_TUPLE(&conntrack->tuplehash[0].tuple);
                 return 0;
         }
@@ -152,14 +146,15 @@ icmpv6_error_message(struct sk_buff *skb,
 
         hp = skb_header_pointer(skb, icmp6off, sizeof(_hdr), &_hdr);
         if (hp == NULL) {
-                DEBUGP("icmpv6_error: Can't get ICMPv6 hdr.\n");
+                pr_debug("icmpv6_error: Can't get ICMPv6 hdr.\n");
                 return -NF_ACCEPT;
         }
 
         inip6off = icmp6off + sizeof(_hdr);
         if (skb_copy_bits(skb, inip6off+offsetof(struct ipv6hdr, nexthdr),
                           &inprotonum, sizeof(inprotonum)) != 0) {
-                DEBUGP("icmpv6_error: Can't get nexthdr in inner IPv6 header.\n");
+                pr_debug("icmpv6_error: Can't get nexthdr in inner IPv6 "
+                         "header.\n");
                 return -NF_ACCEPT;
         }
         inprotoff = nf_ct_ipv6_skip_exthdr(skb,
@@ -169,7 +164,8 @@ icmpv6_error_message(struct sk_buff *skb,
                                                     - sizeof(struct ipv6hdr));
 
         if ((inprotoff > skb->len) || (inprotonum == NEXTHDR_FRAGMENT)) {
-                DEBUGP("icmpv6_error: Can't get protocol header in ICMPv6 payload.\n");
+                pr_debug("icmpv6_error: Can't get protocol header in ICMPv6 "
+                         "payload.\n");
                 return -NF_ACCEPT;
         }
 
@@ -179,7 +175,7 @@ icmpv6_error_message(struct sk_buff *skb,
         /* Are they talking about one of our connections? */
         if (!nf_ct_get_tuple(skb, inip6off, inprotoff, PF_INET6, inprotonum,
                              &origtuple, &nf_conntrack_l3proto_ipv6, inproto)) {
-                DEBUGP("icmpv6_error: Can't get tuple\n");
+                pr_debug("icmpv6_error: Can't get tuple\n");
                 return -NF_ACCEPT;
         }
 
@@ -187,7 +183,7 @@ icmpv6_error_message(struct sk_buff *skb,
            been preserved inside the ICMP. */
         if (!nf_ct_invert_tuple(&intuple, &origtuple,
                                 &nf_conntrack_l3proto_ipv6, inproto)) {
-                DEBUGP("icmpv6_error: Can't invert tuple\n");
+                pr_debug("icmpv6_error: Can't invert tuple\n");
                 return -NF_ACCEPT;
         }
 
@@ -195,7 +191,7 @@ icmpv6_error_message(struct sk_buff *skb,
 
         h = nf_conntrack_find_get(&intuple);
         if (!h) {
-                DEBUGP("icmpv6_error: no match\n");
+                pr_debug("icmpv6_error: no match\n");
                 return -NF_ACCEPT;
         } else {
                 if (NF_CT_DIRECTION(h) == IP_CT_DIR_REPLY)
diff --git a/net/ipv6/netfilter/nf_conntrack_reasm.c b/net/ipv6/netfilter/nf_conntrack_reasm.c
index 347ab7608231..25442a8c1ba8 100644
--- a/net/ipv6/netfilter/nf_conntrack_reasm.c
+++ b/net/ipv6/netfilter/nf_conntrack_reasm.c
@@ -44,12 +44,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(format, args...)
-#endif
-
 #define NF_CT_FRAG6_HIGH_THRESH 262144 /* == 256*1024 */
 #define NF_CT_FRAG6_LOW_THRESH 196608  /* == 192*1024 */
 #define NF_CT_FRAG6_TIMEOUT IPV6_FRAG_TIMEOUT
@@ -343,7 +337,7 @@ nf_ct_frag6_create(unsigned int hash, __be32 id, struct in6_addr *src,				   str
         struct nf_ct_frag6_queue *fq;
 
         if ((fq = frag_alloc_queue()) == NULL) {
-                DEBUGP("Can't alloc new queue\n");
+                pr_debug("Can't alloc new queue\n");
                 goto oom;
         }
 
@@ -393,7 +387,7 @@ static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb,
         int offset, end;
 
         if (fq->last_in & COMPLETE) {
-                DEBUGP("Allready completed\n");
+                pr_debug("Allready completed\n");
                 goto err;
         }
 
@@ -402,7 +396,7 @@ static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb,
                         ((u8 *)(fhdr + 1) - (u8 *)(ipv6_hdr(skb) + 1)));
 
         if ((unsigned int)end > IPV6_MAXPLEN) {
-                DEBUGP("offset is too large.\n");
+                pr_debug("offset is too large.\n");
                 return -1;
         }
 
@@ -420,7 +414,7 @@ static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb,
                  */
                 if (end < fq->len ||
                     ((fq->last_in & LAST_IN) && end != fq->len)) {
-                        DEBUGP("already received last fragment\n");
+                        pr_debug("already received last fragment\n");
                         goto err;
                 }
                 fq->last_in |= LAST_IN;
@@ -433,13 +427,13 @@ static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb,
                         /* RFC2460 says always send parameter problem in
                          * this case. -DaveM
                          */
-                        DEBUGP("the end of this fragment is not rounded to 8 bytes.\n");
+                        pr_debug("end of fragment not rounded to 8 bytes.\n");
                         return -1;
                 }
                 if (end > fq->len) {
                         /* Some bits beyond end -> corruption. */
                         if (fq->last_in & LAST_IN) {
-                                DEBUGP("last packet already reached.\n");
+                                pr_debug("last packet already reached.\n");
                                 goto err;
                         }
                         fq->len = end;
@@ -451,11 +445,11 @@ static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb,
 
         /* Point into the IP datagram 'data' part. */
         if (!pskb_pull(skb, (u8 *) (fhdr + 1) - skb->data)) {
-                DEBUGP("queue: message is too short.\n");
+                pr_debug("queue: message is too short.\n");
                 goto err;
         }
         if (pskb_trim_rcsum(skb, end - offset)) {
-                DEBUGP("Can't trim\n");
+                pr_debug("Can't trim\n");
                 goto err;
         }
 
@@ -480,11 +474,11 @@ static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb,
                 if (i > 0) {
                         offset += i;
                         if (end <= offset) {
-                                DEBUGP("overlap\n");
+                                pr_debug("overlap\n");
                                 goto err;
                         }
                         if (!pskb_pull(skb, i)) {
-                                DEBUGP("Can't pull\n");
+                                pr_debug("Can't pull\n");
                                 goto err;
                         }
                         if (skb->ip_summed != CHECKSUM_UNNECESSARY)
@@ -503,7 +497,7 @@ static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb,
                         /* Eat head of the next overlapped fragment
                          * and leave the loop. The next ones cannot overlap.
                          */
-                        DEBUGP("Eat head of the overlapped parts.: %d", i);
+                        pr_debug("Eat head of the overlapped parts.: %d", i);
                         if (!pskb_pull(next, i))
                                 goto err;
 
@@ -586,13 +580,13 @@ nf_ct_frag6_reasm(struct nf_ct_frag6_queue *fq, struct net_device *dev)
                        sizeof(struct ipv6hdr) + fq->len -
                        sizeof(struct frag_hdr));
         if (payload_len > IPV6_MAXPLEN) {
-                DEBUGP("payload len is too large.\n");
+                pr_debug("payload len is too large.\n");
                 goto out_oversize;
         }
 
         /* Head of list must not be cloned. */
         if (skb_cloned(head) && pskb_expand_head(head, 0, 0, GFP_ATOMIC)) {
-                DEBUGP("skb is cloned but can't expand head");
+                pr_debug("skb is cloned but can't expand head");
                 goto out_oom;
         }
 
@@ -604,7 +598,7 @@ nf_ct_frag6_reasm(struct nf_ct_frag6_queue *fq, struct net_device *dev)
                 int i, plen = 0;
 
                 if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL) {
-                        DEBUGP("Can't alloc skb\n");
+                        pr_debug("Can't alloc skb\n");
                         goto out_oom;
                 }
                 clone->next = head->next;
@@ -719,11 +713,11 @@ find_prev_fhdr(struct sk_buff *skb, u8 *prevhdrp, int *prevhoff, int *fhoff)
                         return -1;
                 }
                 if (len < (int)sizeof(struct ipv6_opt_hdr)) {
-                        DEBUGP("too short\n");
+                        pr_debug("too short\n");
                         return -1;
                 }
                 if (nexthdr == NEXTHDR_NONE) {
-                        DEBUGP("next header is none\n");
+                        pr_debug("next header is none\n");
                         return -1;
                 }
                 if (skb_copy_bits(skb, start, &hdr, sizeof(hdr)))
@@ -764,7 +758,7 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
 
         /* Jumbo payload inhibits frag. header */
         if (ipv6_hdr(skb)->payload_len == 0) {
-                DEBUGP("payload len = 0\n");
+                pr_debug("payload len = 0\n");
                 return skb;
         }
 
@@ -773,14 +767,14 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
 
         clone = skb_clone(skb, GFP_ATOMIC);
         if (clone == NULL) {
-                DEBUGP("Can't clone skb\n");
+                pr_debug("Can't clone skb\n");
                 return skb;
         }
 
         NFCT_FRAG6_CB(clone)->orig = skb;
 
         if (!pskb_may_pull(clone, fhoff + sizeof(*fhdr))) {
-                DEBUGP("message is too short.\n");
+                pr_debug("message is too short.\n");
                 goto ret_orig;
         }
 
@@ -789,7 +783,7 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
         fhdr = (struct frag_hdr *)skb_transport_header(clone);
 
         if (!(fhdr->frag_off & htons(0xFFF9))) {
-                DEBUGP("Invalid fragment offset\n");
+                pr_debug("Invalid fragment offset\n");
                 /* It is not a fragmented frame */
                 goto ret_orig;
         }
@@ -799,7 +793,7 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
 
         fq = fq_find(fhdr->identification, &hdr->saddr, &hdr->daddr);
         if (fq == NULL) {
-                DEBUGP("Can't find and can't create new queue\n");
+                pr_debug("Can't find and can't create new queue\n");
                 goto ret_orig;
         }
 
@@ -807,7 +801,7 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
 
         if (nf_ct_frag6_queue(fq, clone, fhdr, nhoff) < 0) {
                 spin_unlock(&fq->lock);
-                DEBUGP("Can't insert skb to queue\n");
+                pr_debug("Can't insert skb to queue\n");
                 fq_put(fq, NULL);
                 goto ret_orig;
         }
@@ -815,7 +809,7 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
         if (fq->last_in == (FIRST_IN|LAST_IN) && fq->meat == fq->len) {
                 ret_skb = nf_ct_frag6_reasm(fq, dev);
                 if (ret_skb == NULL)
-                        DEBUGP("Can't reassemble fragmented packets\n");
+                        pr_debug("Can't reassemble fragmented packets\n");
         }
         spin_unlock(&fq->lock);