From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <dev-bounces@dpdk.org>
Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124])
	by inbox.dpdk.org (Postfix) with ESMTP id 5A38241C37;
	Wed,  8 Feb 2023 05:48:37 +0100 (CET)
Received: from mails.dpdk.org (localhost [127.0.0.1])
	by mails.dpdk.org (Postfix) with ESMTP id F390D42670;
	Wed,  8 Feb 2023 05:48:32 +0100 (CET)
Received: from mail-pl1-f182.google.com (mail-pl1-f182.google.com
 [209.85.214.182])
 by mails.dpdk.org (Postfix) with ESMTP id A0B0D40DFD
 for <dev@dpdk.org>; Wed,  8 Feb 2023 05:48:30 +0100 (CET)
Received: by mail-pl1-f182.google.com with SMTP id b5so18017452plz.5
 for <dev@dpdk.org>; Tue, 07 Feb 2023 20:48:30 -0800 (PST)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=networkplumber-org.20210112.gappssmtp.com; s=20210112;
 h=content-transfer-encoding:mime-version:references:in-reply-to
 :message-id:date:subject:cc:to:from:from:to:cc:subject:date
 :message-id:reply-to;
 bh=lxYBgKYHivB14vgMEspcEY/s/olMDIM4FPLYiSlXqNc=;
 b=e+djYLHrz38+ylqoG3FOELEUi/TtMuWhSZ+MZp0/ixprlwWL68G8RDhrFoUVgtk1e9
 Ugdszd8eoYskDhvo9MK6MyU5qX/trmCct/9jB55ud2n5hEwtBX+SDAI0f8/TxcpUwBmu
 gFxdtH3AAfVHJc2Ia8FJqZFyhamvNJeNNkUJ/U6ik8txAypBjtM30hKWnImgyjPG4GX4
 KuTUS+XtlIGGD4/iaUL4sEvP8TuXvD5tywh4z0XIHD/0vn8uo1u/o9vI3ZbBhahuMBsu
 VokEoBo+/a1cnRhoXGO2Z+fjhcaPEjDawJzPy6IKvQwHKrcvcBs73u1Elc4Rdttyg2lW
 4kHw==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=1e100.net; s=20210112;
 h=content-transfer-encoding:mime-version:references:in-reply-to
 :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc
 :subject:date:message-id:reply-to;
 bh=lxYBgKYHivB14vgMEspcEY/s/olMDIM4FPLYiSlXqNc=;
 b=qEibXRfGVu/JbYpLhfxIMFnDbE15Vhax2GkC6vkdsDbgELq8ZhHetWU6+5Yc6sHPUR
 rhLbQw7P2Y5N0D5S0QBKlvXib/peRsL3ddQYKjoKEy5NqWYHm/qgORfz41FloPDceMGC
 N4VnzzviRderbSYjYFsJy6vNcrBro2okig/DM7gPRKuHtJEY88dqPXWnmX3zwSSXvPhL
 0aLguCLceDJdEM6blsSTxRKN7eP6HBFsZazvsSGrBSm6aLiR4U1kV5q8vbqPuSWkTpxo
 7CjBpvbPewJt5BXyeumw+43019oFXL4vXqp/MCiPbX2GzT96/QYIwWFEX62ZWE3JB4GZ
 aY7Q==
X-Gm-Message-State: AO0yUKWQPAsHWPh1+QufYw5xl8nOCEtKcvptHiTdjR94mXtnHfDfBd4D
 DuX53py/Vu+TVTfuTFv50Su3T+qXbXmQ5WHAKPc=
X-Google-Smtp-Source: AK7set/7KbosnO25L6DjKSOAyCTmMS/VEotO7Jdev8BsENf1e7QwLpAmvTrIT+C04t6dJeMkiOr/Vw==
X-Received: by 2002:a05:6a20:699d:b0:be:d389:7abf with SMTP id
 t29-20020a056a20699d00b000bed3897abfmr6338850pzk.3.1675831709287; 
 Tue, 07 Feb 2023 20:48:29 -0800 (PST)
Received: from hermes.local (204-195-120-218.wavecable.com. [204.195.120.218])
 by smtp.gmail.com with ESMTPSA id
 bu14-20020a63294e000000b004dff15fc121sm8838641pgb.36.2023.02.07.20.48.28
 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);
 Tue, 07 Feb 2023 20:48:28 -0800 (PST)
From: Stephen Hemminger <stephen@networkplumber.org>
To: dev@dpdk.org
Cc: Stephen Hemminger <stephen@networkplumber.org>,
 Konstantin Ananyev <konstantin.v.ananyev@yandex.ru>,
 Anatoly Burakov <anatoly.burakov@intel.com>,
 Thomas Monjalon <thomas@monjalon.net>
Subject: [PATCH 1/5] ip_frag: use a dynamic logtype
Date: Tue,  7 Feb 2023 20:48:21 -0800
Message-Id: <20230208044825.1682620-2-stephen@networkplumber.org>
X-Mailer: git-send-email 2.39.1
In-Reply-To: <20230208044825.1682620-1-stephen@networkplumber.org>
References: <20230208044825.1682620-1-stephen@networkplumber.org>
MIME-Version: 1.0
Content-Transfer-Encoding: 8bit
X-BeenThere: dev@dpdk.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: DPDK patches and discussions <dev.dpdk.org>
List-Unsubscribe: <https://mails.dpdk.org/options/dev>,
 <mailto:dev-request@dpdk.org?subject=unsubscribe>
List-Archive: <http://mails.dpdk.org/archives/dev/>
List-Post: <mailto:dev@dpdk.org>
List-Help: <mailto:dev-request@dpdk.org?subject=help>
List-Subscribe: <https://mails.dpdk.org/listinfo/dev>,
 <mailto:dev-request@dpdk.org?subject=subscribe>
Errors-To: dev-bounces@dpdk.org

DPDK libraries should not be reusing RTE_LOGTYPE_USER1 in
lieu of doing proper logtype registration.

Fixes: 416707812c03 ("ip_frag: refactor reassembly code into a proper library")
Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/ip_frag/ip_frag_common.h      |  16 ++-
 lib/ip_frag/ip_frag_internal.c    | 174 +++++++++++++++---------------
 lib/ip_frag/rte_ip_frag_common.c  |  13 +--
 lib/ip_frag/rte_ipv4_reassembly.c |  14 ++-
 lib/ip_frag/rte_ipv6_reassembly.c |  59 +++++-----
 5 files changed, 138 insertions(+), 138 deletions(-)

diff --git a/lib/ip_frag/ip_frag_common.h b/lib/ip_frag/ip_frag_common.h
index 9c0dbdeb6eb9..134072f3e810 100644
--- a/lib/ip_frag/ip_frag_common.h
+++ b/lib/ip_frag/ip_frag_common.h
@@ -9,8 +9,16 @@
 #include "ip_reassembly.h"
 
 /* logging macros. */
+extern int ipfrag_logtype;
+
+#define IP_FRAG_ERR(fmt, args...) \
+	rte_log(RTE_LOG_ERR, ipfrag_logtype, \
+		"%s: " fmt "\n", __func__, ## args)
+
 #ifdef RTE_LIBRTE_IP_FRAG_DEBUG
-#define	IP_FRAG_LOG(lvl, fmt, args...)	RTE_LOG(lvl, USER1, fmt, ##args)
+#define	IP_FRAG_LOG(lvl, fmt, args...)	\
+	rte_log(RTE_LOG ## lvl, ipfrag_logtype, \
+		"%s: " fmt "\n", __func__, ## args)
 #else
 #define	IP_FRAG_LOG(lvl, fmt, args...)	do {} while(0)
 #endif /* IP_FRAG_DEBUG */
@@ -111,9 +119,9 @@ ip_frag_free_immediate(struct ip_frag_pkt *fp)
 
 	for (i = 0; i < fp->last_idx; i++) {
 		if (fp->frags[i].mb != NULL) {
-			IP_FRAG_LOG(DEBUG, "%s:%d\n"
-			    "mbuf: %p, tms: %" PRIu64", key: <%" PRIx64 ", %#x>\n",
-			    __func__, __LINE__, fp->frags[i].mb, fp->start,
+			IP_FRAG_LOG(DEBUG,
+			    "mbuf: %p, tms: %" PRIu64", key: <%" PRIx64 ", %#x>",
+			    fp->frags[i].mb, fp->start,
 			    fp->key.src_dst[0], fp->key.id);
 			rte_pktmbuf_free(fp->frags[i].mb);
 			fp->frags[i].mb = NULL;
diff --git a/lib/ip_frag/ip_frag_internal.c b/lib/ip_frag/ip_frag_internal.c
index b436a4c9313b..c633216419a2 100644
--- a/lib/ip_frag/ip_frag_internal.c
+++ b/lib/ip_frag/ip_frag_internal.c
@@ -89,7 +89,7 @@ ipv6_frag_hash(const struct ip_frag_key *key, uint32_t *v1, uint32_t *v2)
 
 struct rte_mbuf *
 ip_frag_process(struct ip_frag_pkt *fp, struct rte_ip_frag_death_row *dr,
-	struct rte_mbuf *mb, uint16_t ofs, uint16_t len, uint16_t more_frags)
+		struct rte_mbuf *mb, uint16_t ofs, uint16_t len, uint16_t more_frags)
 {
 	uint32_t idx;
 
@@ -98,15 +98,15 @@ ip_frag_process(struct ip_frag_pkt *fp, struct rte_ip_frag_death_row *dr,
 	/* this is the first fragment. */
 	if (ofs == 0) {
 		idx = (fp->frags[IP_FIRST_FRAG_IDX].mb == NULL) ?
-				IP_FIRST_FRAG_IDX : UINT32_MAX;
+			IP_FIRST_FRAG_IDX : UINT32_MAX;
 
-	/* this is the last fragment. */
+		/* this is the last fragment. */
 	} else if (more_frags == 0) {
 		fp->total_size = ofs + len;
 		idx = (fp->frags[IP_LAST_FRAG_IDX].mb == NULL) ?
-				IP_LAST_FRAG_IDX : UINT32_MAX;
+			IP_LAST_FRAG_IDX : UINT32_MAX;
 
-	/* this is the intermediate fragment. */
+		/* this is the intermediate fragment. */
 	} else if ((idx = fp->last_idx) < RTE_DIM(fp->frags)) {
 		fp->last_idx++;
 	}
@@ -119,31 +119,31 @@ ip_frag_process(struct ip_frag_pkt *fp, struct rte_ip_frag_death_row *dr,
 
 		/* report an error. */
 		if (fp->key.key_len == IPV4_KEYLEN)
-			IP_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n"
-				"ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, "
-				"total_size: %u, frag_size: %u, last_idx: %u\n"
-				"first fragment: ofs: %u, len: %u\n"
-				"last fragment: ofs: %u, len: %u\n\n",
-				__func__, __LINE__,
-				fp, fp->key.src_dst[0], fp->key.id,
-				fp->total_size, fp->frag_size, fp->last_idx,
-				fp->frags[IP_FIRST_FRAG_IDX].ofs,
-				fp->frags[IP_FIRST_FRAG_IDX].len,
-				fp->frags[IP_LAST_FRAG_IDX].ofs,
-				fp->frags[IP_LAST_FRAG_IDX].len);
+			IP_FRAG_LOG(DEBUG,
+				    "invalid fragmented packet:\n"
+				    "ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, "
+				    "total_size: %u, frag_size: %u, last_idx: %u\n"
+				    "first fragment: ofs: %u, len: %u\n"
+				    "last fragment: ofs: %u, len: %u\n",
+				    fp, fp->key.src_dst[0], fp->key.id,
+				    fp->total_size, fp->frag_size, fp->last_idx,
+				    fp->frags[IP_FIRST_FRAG_IDX].ofs,
+				    fp->frags[IP_FIRST_FRAG_IDX].len,
+				    fp->frags[IP_LAST_FRAG_IDX].ofs,
+				    fp->frags[IP_LAST_FRAG_IDX].len);
 		else
-			IP_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n"
-				"ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, "
-				"total_size: %u, frag_size: %u, last_idx: %u\n"
-				"first fragment: ofs: %u, len: %u\n"
-				"last fragment: ofs: %u, len: %u\n\n",
-				__func__, __LINE__,
-				fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id,
-				fp->total_size, fp->frag_size, fp->last_idx,
-				fp->frags[IP_FIRST_FRAG_IDX].ofs,
-				fp->frags[IP_FIRST_FRAG_IDX].len,
-				fp->frags[IP_LAST_FRAG_IDX].ofs,
-				fp->frags[IP_LAST_FRAG_IDX].len);
+			IP_FRAG_LOG(DEBUG,
+				    "invalid fragmented packet:\n"
+				    "ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, "
+				    "total_size: %u, frag_size: %u, last_idx: %u\n"
+				    "first fragment: ofs: %u, len: %u\n"
+				    "last fragment: ofs: %u, len: %u\n",
+				    fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id,
+				    fp->total_size, fp->frag_size, fp->last_idx,
+				    fp->frags[IP_FIRST_FRAG_IDX].ofs,
+				    fp->frags[IP_FIRST_FRAG_IDX].len,
+				    fp->frags[IP_LAST_FRAG_IDX].ofs,
+				    fp->frags[IP_LAST_FRAG_IDX].len);
 
 		/* free all fragments, invalidate the entry. */
 		ip_frag_free(fp, dr);
@@ -163,9 +163,9 @@ ip_frag_process(struct ip_frag_pkt *fp, struct rte_ip_frag_death_row *dr,
 	if (likely (fp->frag_size < fp->total_size)) {
 		return mb;
 
-	/* if we collected all fragments, then try to reassemble. */
+		/* if we collected all fragments, then try to reassemble. */
 	} else if (fp->frag_size == fp->total_size &&
-			fp->frags[IP_FIRST_FRAG_IDX].mb != NULL) {
+		   fp->frags[IP_FIRST_FRAG_IDX].mb != NULL) {
 		if (fp->key.key_len == IPV4_KEYLEN)
 			mb = ipv4_frag_reassemble(fp);
 		else
@@ -177,31 +177,31 @@ ip_frag_process(struct ip_frag_pkt *fp, struct rte_ip_frag_death_row *dr,
 
 		/* report an error. */
 		if (fp->key.key_len == IPV4_KEYLEN)
-			IP_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n"
-				"ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, "
-				"total_size: %u, frag_size: %u, last_idx: %u\n"
-				"first fragment: ofs: %u, len: %u\n"
-				"last fragment: ofs: %u, len: %u\n\n",
-				__func__, __LINE__,
-				fp, fp->key.src_dst[0], fp->key.id,
-				fp->total_size, fp->frag_size, fp->last_idx,
-				fp->frags[IP_FIRST_FRAG_IDX].ofs,
-				fp->frags[IP_FIRST_FRAG_IDX].len,
-				fp->frags[IP_LAST_FRAG_IDX].ofs,
-				fp->frags[IP_LAST_FRAG_IDX].len);
+			IP_FRAG_LOG(DEBUG,
+				    "invalid fragmented packet:\n"
+				    "ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, "
+				    "total_size: %u, frag_size: %u, last_idx: %u\n"
+				    "first fragment: ofs: %u, len: %u\n"
+				    "last fragment: ofs: %u, len: %u\n,
+				    fp, fp->key.src_dst[0], fp->key.id,
+				    fp->total_size, fp->frag_size, fp->last_idx,
+				    fp->frags[IP_FIRST_FRAG_IDX].ofs,
+				    fp->frags[IP_FIRST_FRAG_IDX].len,
+				    fp->frags[IP_LAST_FRAG_IDX].ofs,
+				    fp->frags[IP_LAST_FRAG_IDX].len);
 		else
-			IP_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n"
-				"ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, "
-				"total_size: %u, frag_size: %u, last_idx: %u\n"
-				"first fragment: ofs: %u, len: %u\n"
-				"last fragment: ofs: %u, len: %u\n\n",
-				__func__, __LINE__,
-				fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id,
-				fp->total_size, fp->frag_size, fp->last_idx,
-				fp->frags[IP_FIRST_FRAG_IDX].ofs,
-				fp->frags[IP_FIRST_FRAG_IDX].len,
-				fp->frags[IP_LAST_FRAG_IDX].ofs,
-				fp->frags[IP_LAST_FRAG_IDX].len);
+			IP_FRAG_LOG(DEBUG,
+				    "invalid fragmented packet:\n"
+				    "ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, "
+				    "total_size: %u, frag_size: %u, last_idx: %u\n"
+				    "first fragment: ofs: %u, len: %u\n"
+				    "last fragment: ofs: %u, len: %u\n",
+				    fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id,
+				    fp->total_size, fp->frag_size, fp->last_idx,
+				    fp->frags[IP_FIRST_FRAG_IDX].ofs,
+				    fp->frags[IP_FIRST_FRAG_IDX].len,
+				    fp->frags[IP_LAST_FRAG_IDX].ofs,
+				    fp->frags[IP_LAST_FRAG_IDX].len);
 
 		/* free associated resources. */
 		ip_frag_free(fp, dr);
@@ -282,8 +282,8 @@ ip_frag_find(struct rte_ip_frag_tbl *tbl, struct rte_ip_frag_death_row *dr,
 
 struct ip_frag_pkt *
 ip_frag_lookup(struct rte_ip_frag_tbl *tbl,
-	const struct ip_frag_key *key, uint64_t tms,
-	struct ip_frag_pkt **free, struct ip_frag_pkt **stale)
+	       const struct ip_frag_key *key, uint64_t tms,
+	       struct ip_frag_pkt **free, struct ip_frag_pkt **stale)
 {
 	struct ip_frag_pkt *p1, *p2;
 	struct ip_frag_pkt *empty, *old;
@@ -310,23 +310,21 @@ ip_frag_lookup(struct rte_ip_frag_tbl *tbl,
 
 	for (i = 0; i != assoc; i++) {
 		if (p1->key.key_len == IPV4_KEYLEN)
-			IP_FRAG_LOG(DEBUG, "%s:%d:\n"
-					"tbl: %p, max_entries: %u, use_entries: %u\n"
-					"ipv4_frag_pkt line0: %p, index: %u from %u\n"
-			"key: <%" PRIx64 ", %#x>, start: %" PRIu64 "\n",
-					__func__, __LINE__,
-					tbl, tbl->max_entries, tbl->use_entries,
-					p1, i, assoc,
-			p1[i].key.src_dst[0], p1[i].key.id, p1[i].start);
+			IP_FRAG_LOG(DEBUG,
+				    "tbl: %p, max_entries: %u, use_entries: %u\n"
+				    "ipv4_frag_pkt line0: %p, index: %u from %u\n"
+				    "key: <%" PRIx64 ", %#x>, start: %" PRIu64,
+				    tbl, tbl->max_entries, tbl->use_entries,
+				    p1, i, assoc,
+				    p1[i].key.src_dst[0], p1[i].key.id, p1[i].start);
 		else
-			IP_FRAG_LOG(DEBUG, "%s:%d:\n"
-					"tbl: %p, max_entries: %u, use_entries: %u\n"
-					"ipv6_frag_pkt line0: %p, index: %u from %u\n"
-			"key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64 "\n",
-					__func__, __LINE__,
-					tbl, tbl->max_entries, tbl->use_entries,
-					p1, i, assoc,
-			IPv6_KEY_BYTES(p1[i].key.src_dst), p1[i].key.id, p1[i].start);
+			IP_FRAG_LOG(DEBUG,
+				    "tbl: %p, max_entries: %u, use_entries: %u\n"
+				    "ipv6_frag_pkt line0: %p, index: %u from %u\n"
+				    "key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64,
+				    tbl, tbl->max_entries, tbl->use_entries,
+				    p1, i, assoc,
+				    IPv6_KEY_BYTES(p1[i].key.src_dst), p1[i].key.id, p1[i].start);
 
 		if (ip_frag_key_cmp(key, &p1[i].key) == 0)
 			return p1 + i;
@@ -336,23 +334,21 @@ ip_frag_lookup(struct rte_ip_frag_tbl *tbl,
 			old = (old == NULL) ? (p1 + i) : old;
 
 		if (p2->key.key_len == IPV4_KEYLEN)
-			IP_FRAG_LOG(DEBUG, "%s:%d:\n"
-					"tbl: %p, max_entries: %u, use_entries: %u\n"
-					"ipv4_frag_pkt line1: %p, index: %u from %u\n"
-			"key: <%" PRIx64 ", %#x>, start: %" PRIu64 "\n",
-					__func__, __LINE__,
-					tbl, tbl->max_entries, tbl->use_entries,
-					p2, i, assoc,
-			p2[i].key.src_dst[0], p2[i].key.id, p2[i].start);
+			IP_FRAG_LOG(DEBUG,
+				    "tbl: %p, max_entries: %u, use_entries: %u\n"
+				    "ipv4_frag_pkt line1: %p, index: %u from %u\n"
+				    "key: <%" PRIx64 ", %#x>, start: %" PRIu64,
+				    tbl, tbl->max_entries, tbl->use_entries,
+				    p2, i, assoc,
+				    p2[i].key.src_dst[0], p2[i].key.id, p2[i].start);
 		else
-			IP_FRAG_LOG(DEBUG, "%s:%d:\n"
-					"tbl: %p, max_entries: %u, use_entries: %u\n"
-					"ipv6_frag_pkt line1: %p, index: %u from %u\n"
-			"key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64 "\n",
-					__func__, __LINE__,
-					tbl, tbl->max_entries, tbl->use_entries,
-					p2, i, assoc,
-			IPv6_KEY_BYTES(p2[i].key.src_dst), p2[i].key.id, p2[i].start);
+			IP_FRAG_LOG(DEBUG,
+				    "tbl: %p, max_entries: %u, use_entries: %u\n"
+				    "ipv6_frag_pkt line1: %p, index: %u from %u\n"
+				    "key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64,
+				    tbl, tbl->max_entries, tbl->use_entries,
+				    p2, i, assoc,
+				    IPv6_KEY_BYTES(p2[i].key.src_dst), p2[i].key.id, p2[i].start);
 
 		if (ip_frag_key_cmp(key, &p2[i].key) == 0)
 			return p2 + i;
diff --git a/lib/ip_frag/rte_ip_frag_common.c b/lib/ip_frag/rte_ip_frag_common.c
index c1de2e81b6d0..b8ca9e019c54 100644
--- a/lib/ip_frag/rte_ip_frag_common.c
+++ b/lib/ip_frag/rte_ip_frag_common.c
@@ -52,21 +52,20 @@ rte_ip_frag_table_create(uint32_t bucket_num, uint32_t bucket_entries,
 	if (rte_is_power_of_2(bucket_entries) == 0 ||
 			nb_entries > UINT32_MAX || nb_entries == 0 ||
 			nb_entries < max_entries) {
-		RTE_LOG(ERR, USER1, "%s: invalid input parameter\n", __func__);
+		IP_FRAG_ERR("invalid input parameter");
 		return NULL;
 	}
 
 	sz = sizeof (*tbl) + nb_entries * sizeof (tbl->pkt[0]);
 	if ((tbl = rte_zmalloc_socket(__func__, sz, RTE_CACHE_LINE_SIZE,
 			socket_id)) == NULL) {
-		RTE_LOG(ERR, USER1,
-			"%s: allocation of %zu bytes at socket %d failed do\n",
-			__func__, sz, socket_id);
+		IP_FRAG_ERR("allocation of %zu bytes at socket %d failed do",
+			sz, socket_id);
 		return NULL;
 	}
 
-	RTE_LOG(INFO, USER1, "%s: allocated of %zu bytes at socket %d\n",
-		__func__, sz, socket_id);
+	IP_FRAG_LOG(INFO, "allocated of %zu bytes at socket %d",
+		    sz, socket_id);
 
 	tbl->max_cycles = max_cycles;
 	tbl->max_entries = max_entries;
@@ -142,3 +141,5 @@ rte_ip_frag_table_del_expired_entries(struct rte_ip_frag_tbl *tbl,
 		} else
 			return;
 }
+
+RTE_LOG_REGISTER_DEFAULT(ipfrag_logtype, INFO);
diff --git a/lib/ip_frag/rte_ipv4_reassembly.c b/lib/ip_frag/rte_ipv4_reassembly.c
index 4a89a5f5365a..2cdbdc4ee87f 100644
--- a/lib/ip_frag/rte_ipv4_reassembly.c
+++ b/lib/ip_frag/rte_ipv4_reassembly.c
@@ -120,12 +120,11 @@ rte_ipv4_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 	ip_len = rte_be_to_cpu_16(ip_hdr->total_length) - mb->l3_len;
 	trim = mb->pkt_len - (ip_len + mb->l3_len + mb->l2_len);
 
-	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
+	IP_FRAG_LOG(DEBUG,
 		"mbuf: %p, tms: %" PRIu64 ", key: <%" PRIx64 ", %#x>"
 		"ofs: %u, len: %d, padding: %d, flags: %#x\n"
 		"tbl: %p, max_cycles: %" PRIu64 ", entry_mask: %#x, "
-		"max_entries: %u, use_entries: %u\n\n",
-		__func__, __LINE__,
+		"max_entries: %u, use_entries: %u\n",
 		mb, tms, key.src_dst[0], key.id, ip_ofs, ip_len, trim, ip_flag,
 		tbl, tbl->max_cycles, tbl->entry_mask, tbl->max_entries,
 		tbl->use_entries);
@@ -145,11 +144,10 @@ rte_ipv4_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 		return NULL;
 	}
 
-	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
+	IP_FRAG_LOG(DEBUG,
 		"tbl: %p, max_entries: %u, use_entries: %u\n"
 		"ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, start: %" PRIu64
-		", total_size: %u, frag_size: %u, last_idx: %u\n\n",
-		__func__, __LINE__,
+		", total_size: %u, frag_size: %u, last_idx: %u\n",
 		tbl, tbl->max_entries, tbl->use_entries,
 		fp, fp->key.src_dst[0], fp->key.id, fp->start,
 		fp->total_size, fp->frag_size, fp->last_idx);
@@ -159,11 +157,11 @@ rte_ipv4_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 	mb = ip_frag_process(fp, dr, mb, ip_ofs, ip_len, ip_flag);
 	ip_frag_inuse(tbl, fp);
 
-	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
+	IP_FRAG_LOG(DEBUG,
 		"mbuf: %p\n"
 		"tbl: %p, max_entries: %u, use_entries: %u\n"
 		"ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, start: %" PRIu64
-		", total_size: %u, frag_size: %u, last_idx: %u\n\n",
+		", total_size: %u, frag_size: %u, last_idx: %u\n",
 		__func__, __LINE__, mb,
 		tbl, tbl->max_entries, tbl->use_entries,
 		fp, fp->key.src_dst[0], fp->key.id, fp->start,
diff --git a/lib/ip_frag/rte_ipv6_reassembly.c b/lib/ip_frag/rte_ipv6_reassembly.c
index d4019e87e63a..c3e369f4ce42 100644
--- a/lib/ip_frag/rte_ipv6_reassembly.c
+++ b/lib/ip_frag/rte_ipv6_reassembly.c
@@ -135,8 +135,8 @@ ipv6_frag_reassemble(struct ip_frag_pkt *fp)
 #define FRAG_OFFSET(x) (rte_cpu_to_be_16(x) >> 3)
 struct rte_mbuf *
 rte_ipv6_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
-	struct rte_ip_frag_death_row *dr, struct rte_mbuf *mb, uint64_t tms,
-	struct rte_ipv6_hdr *ip_hdr, struct rte_ipv6_fragment_ext *frag_hdr)
+				struct rte_ip_frag_death_row *dr, struct rte_mbuf *mb, uint64_t tms,
+				struct rte_ipv6_hdr *ip_hdr, struct rte_ipv6_fragment_ext *frag_hdr)
 {
 	struct ip_frag_pkt *fp;
 	struct ip_frag_key key;
@@ -161,17 +161,16 @@ rte_ipv6_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 	ip_len = rte_be_to_cpu_16(ip_hdr->payload_len) - sizeof(*frag_hdr);
 	trim = mb->pkt_len - (ip_len + mb->l3_len + mb->l2_len);
 
-	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
-		"mbuf: %p, tms: %" PRIu64
-		", key: <" IPv6_KEY_BYTES_FMT ", %#x>, "
-		"ofs: %u, len: %d, padding: %d, flags: %#x\n"
-		"tbl: %p, max_cycles: %" PRIu64 ", entry_mask: %#x, "
-		"max_entries: %u, use_entries: %u\n\n",
-		__func__, __LINE__,
-		mb, tms, IPv6_KEY_BYTES(key.src_dst), key.id, ip_ofs, ip_len,
-		trim, RTE_IPV6_GET_MF(frag_hdr->frag_data),
-		tbl, tbl->max_cycles, tbl->entry_mask, tbl->max_entries,
-		tbl->use_entries);
+	IP_FRAG_LOG(DEBUG,
+		    "mbuf: %p, tms: %" PRIu64
+		    ", key: <" IPv6_KEY_BYTES_FMT ", %#x>, "
+		    "ofs: %u, len: %d, padding: %d, flags: %#x\n"
+		    "tbl: %p, max_cycles: %" PRIu64 ", entry_mask: %#x, "
+		    "max_entries: %u, use_entries: %u\n",
+		    mb, tms, IPv6_KEY_BYTES(key.src_dst), key.id, ip_ofs, ip_len,
+		    trim, RTE_IPV6_GET_MF(frag_hdr->frag_data),
+		    tbl, tbl->max_cycles, tbl->entry_mask, tbl->max_entries,
+		    tbl->use_entries);
 
 	/* check that fragment length is greater then zero. */
 	if (ip_len <= 0) {
@@ -189,30 +188,28 @@ rte_ipv6_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 		return NULL;
 	}
 
-	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
-		"tbl: %p, max_entries: %u, use_entries: %u\n"
-		"ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64
-		", total_size: %u, frag_size: %u, last_idx: %u\n\n",
-		__func__, __LINE__,
-		tbl, tbl->max_entries, tbl->use_entries,
-		fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id, fp->start,
-		fp->total_size, fp->frag_size, fp->last_idx);
+	IP_FRAG_LOG(DEBUG,
+		    "tbl: %p, max_entries: %u, use_entries: %u\n"
+		    "ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64
+		    ", total_size: %u, frag_size: %u, last_idx: %u\n",
+		    tbl, tbl->max_entries, tbl->use_entries,
+		    fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id, fp->start,
+		    fp->total_size, fp->frag_size, fp->last_idx);
 
 
 	/* process the fragmented packet. */
 	mb = ip_frag_process(fp, dr, mb, ip_ofs, ip_len,
-			MORE_FRAGS(frag_hdr->frag_data));
+			     MORE_FRAGS(frag_hdr->frag_data));
 	ip_frag_inuse(tbl, fp);
 
-	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
-		"mbuf: %p\n"
-		"tbl: %p, max_entries: %u, use_entries: %u\n"
-		"ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64
-		", total_size: %u, frag_size: %u, last_idx: %u\n\n",
-		__func__, __LINE__, mb,
-		tbl, tbl->max_entries, tbl->use_entries,
-		fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id, fp->start,
-		fp->total_size, fp->frag_size, fp->last_idx);
+	IP_FRAG_LOG(DEBUG,
+		    "mbuf: %p\n"
+		    "tbl: %p, max_entries: %u, use_entries: %u\n"
+		    "ipv6_frag_pkt: %p, key: <" IPv6_KEY_BYTES_FMT ", %#x>, start: %" PRIu64
+		    ", total_size: %u, frag_size: %u, last_idx: %u\n",
+		    mb, tbl, tbl->max_entries, tbl->use_entries,
+		    fp, IPv6_KEY_BYTES(fp->key.src_dst), fp->key.id, fp->start,
+		    fp->total_size, fp->frag_size, fp->last_idx);
 
 	return mb;
 }
-- 
2.39.1