From mboxrd@z Thu Jan 1 00:00:00 1970 From: Vlad Yasevich Subject: Re: [PATCH net-next 2/2] net: sctp: rework debugging framework to use pr_debug and friends Date: Wed, 26 Jun 2013 22:32:34 -0400 Message-ID: <51CBA442.2090400@gmail.com> References: <1372266073-11998-1-git-send-email-dborkman@redhat.com> <1372266073-11998-3-git-send-email-dborkman@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Cc: davem@davemloft.net, netdev@vger.kernel.org, linux-sctp@vger.kernel.org To: Daniel Borkmann Return-path: Received: from mail-qc0-f178.google.com ([209.85.216.178]:57254 "EHLO mail-qc0-f178.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751744Ab3F0Cck (ORCPT ); Wed, 26 Jun 2013 22:32:40 -0400 In-Reply-To: <1372266073-11998-3-git-send-email-dborkman@redhat.com> Sender: netdev-owner@vger.kernel.org List-ID: On 06/26/2013 01:01 PM, Daniel Borkmann wrote: > We should get rid of all own SCTP debug printk macros and use the ones > that the kernel offers anyway instead. This makes the code more readable > and conform to the kernel code, and offers all the features of dynamic > debbuging that pr_debug() et al has, such as only turning on/off portions > of debug messages at runtime through debugfs. The runtime cost of having > CONFIG_DYNAMIC_DEBUG enabled, but none of the debug statements printing, > is negligible [1]. If kernel debugging is completly turned off, then these > statements will also compile into "empty" functions. > > While we're at it, we also need to change the Kconfig option as it /now/ > only refers to the ifdef'ed code portions in outqueue.c that enable further > debugging/tracing of SCTP transaction fields. Also, since SCTP_ASSERT code > was enabled with this Kconfig option and has now been removed, we > transform those code parts into WARNs resp. where appropriate BUG_ONs so > that those bugs can be more easily detected as probably not many people > have SCTP debugging permanently turned on. > > To turn on all SCTP debugging, the following steps are needed: > > # mount -t debugfs none /sys/kernel/debug > # echo -n 'module sctp +p' > /sys/kernel/debug/dynamic_debug/control > > This can be done more fine-grained on a per file, per line basis and others > as described in [2]. > > [1] https://www.kernel.org/doc/ols/2009/ols2009-pages-39-46.pdf > [2] Documentation/dynamic-debug-howto.txt > > Signed-off-by: Daniel Borkmann > --- > Vlad, Neil, if you think some of those WARN() calls are unnecessary, I can > remove them and submit a v2. Thanks ! Some of them are. I've commented below. This was a bit of a pain to review and it has some changes that are not streight forward conversions to use pr_debug (sctp_sendmsg() changes). It would have been better if you took an incremental approach to changing SCTP_DEBUG_PRINTK to use pr_debug first, and then possibly switch to direct usage of pr_debug per file. Would have been much easier to reivew. > > include/net/sctp/sctp.h | 75 --------------------- > net/sctp/Kconfig | 12 ++-- > net/sctp/associola.c | 69 +++++++++---------- > net/sctp/chunk.c | 5 +- > net/sctp/debug.c | 4 -- > net/sctp/endpointola.c | 5 +- > net/sctp/input.c | 6 +- > net/sctp/inqueue.c | 9 ++- > net/sctp/ipv6.c | 21 +++--- > net/sctp/output.c | 40 +++++------ > net/sctp/outqueue.c | 160 ++++++++++++++++++++------------------------ > net/sctp/protocol.c | 48 +++++++------- > net/sctp/sm_make_chunk.c | 25 +++---- > net/sctp/sm_sideeffect.c | 97 ++++++++++++--------------- > net/sctp/sm_statefuns.c | 77 +++++++++++++--------- > net/sctp/socket.c | 168 ++++++++++++++++++++++------------------------- > net/sctp/transport.c | 51 +++++++------- > 17 files changed, 389 insertions(+), 483 deletions(-) > > diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h > index e6b95bc..d8e37ec 100644 > --- a/include/net/sctp/sctp.h > +++ b/include/net/sctp/sctp.h > @@ -83,16 +83,6 @@ > #include > #include > > - > -/* Set SCTP_DEBUG flag via config if not already set. */ > -#ifndef SCTP_DEBUG > -#ifdef CONFIG_SCTP_DBG_MSG > -#define SCTP_DEBUG 1 > -#else > -#define SCTP_DEBUG 0 > -#endif /* CONFIG_SCTP_DBG */ > -#endif /* SCTP_DEBUG */ > - > #ifdef CONFIG_IP_SCTP_MODULE > #define SCTP_PROTOSW_FLAG 0 > #else /* static! */ > @@ -270,61 +260,6 @@ static inline void sctp_max_rto(struct sctp_association *asoc, > } > } > > -/* Print debugging messages. */ > -#if SCTP_DEBUG > -extern int sctp_debug_flag; > -#define SCTP_DEBUG_PRINTK(fmt, args...) \ > -do { \ > - if (sctp_debug_flag) \ > - printk(KERN_DEBUG pr_fmt(fmt), ##args); \ > -} while (0) > -#define SCTP_DEBUG_PRINTK_CONT(fmt, args...) \ > -do { \ > - if (sctp_debug_flag) \ > - pr_cont(fmt, ##args); \ > -} while (0) > -#define SCTP_DEBUG_PRINTK_IPADDR(fmt_lead, fmt_trail, \ > - args_lead, addr, args_trail...) \ > -do { \ > - const union sctp_addr *_addr = (addr); \ > - if (sctp_debug_flag) { \ > - if (_addr->sa.sa_family == AF_INET6) { \ > - printk(KERN_DEBUG \ > - pr_fmt(fmt_lead "%pI6" fmt_trail), \ > - args_lead, \ > - &_addr->v6.sin6_addr, \ > - args_trail); \ > - } else { \ > - printk(KERN_DEBUG \ > - pr_fmt(fmt_lead "%pI4" fmt_trail), \ > - args_lead, \ > - &_addr->v4.sin_addr.s_addr, \ > - args_trail); \ > - } \ > - } \ > -} while (0) > -#define SCTP_ENABLE_DEBUG { sctp_debug_flag = 1; } > -#define SCTP_DISABLE_DEBUG { sctp_debug_flag = 0; } > - > -#define SCTP_ASSERT(expr, str, func) \ > - if (!(expr)) { \ > - SCTP_DEBUG_PRINTK("Assertion Failed: %s(%s) at %s:%s:%d\n", \ > - str, (#expr), __FILE__, __func__, __LINE__); \ > - func; \ > - } > - > -#else /* SCTP_DEBUG */ > - > -#define SCTP_DEBUG_PRINTK(whatever...) > -#define SCTP_DEBUG_PRINTK_CONT(fmt, args...) > -#define SCTP_DEBUG_PRINTK_IPADDR(whatever...) > -#define SCTP_ENABLE_DEBUG > -#define SCTP_DISABLE_DEBUG > -#define SCTP_ASSERT(expr, str, func) > - > -#endif /* SCTP_DEBUG */ > - > - > /* > * Macros for keeping a global reference of object allocations. > */ > @@ -597,16 +532,6 @@ static inline int param_type2af(__be16 type) > } > } > > -/* Perform some sanity checks. */ > -static inline int sctp_sanity_check(void) > -{ > - SCTP_ASSERT(sizeof(struct sctp_ulpevent) <= > - sizeof(((struct sk_buff *)0)->cb), > - "SCTP: ulpevent does not fit in skb!\n", return 0); > - > - return 1; > -} > - > /* Warning: The following hash functions assume a power of two 'size'. */ > /* This is the hash function for the SCTP port hash table. */ > static inline int sctp_phashfn(struct net *net, __u16 lport) > diff --git a/net/sctp/Kconfig b/net/sctp/Kconfig > index cf48528..d80bf1a 100644 > --- a/net/sctp/Kconfig > +++ b/net/sctp/Kconfig > @@ -30,7 +30,8 @@ menuconfig IP_SCTP > homing at either or both ends of an association." > > To compile this protocol support as a module, choose M here: the > - module will be called sctp. > + module will be called sctp. Debug messages are handeled by the > + kernel's dynamic debugging framework. > > If in doubt, say N. > > @@ -48,13 +49,14 @@ config NET_SCTPPROBE > To compile this code as a module, choose M here: the > module will be called sctp_probe. > > -config SCTP_DBG_MSG > - bool "SCTP: Debug messages" > +config SCTP_DBG_TSNS > + bool "SCTP: Debug transactions" > help > - If you say Y, this will enable verbose debugging messages. > + If you say Y, this will enable transaction debugging, visible > + from the kernel's dynamic debugging framework. This doesn't really describe what this functionality turns on. I am hoping that we can get rid of this wart in the future. > > If unsure, say N. However, if you are running into problems, use > - this option to gather detailed trace information > + this option to gather outqueue trace information. > > config SCTP_DBG_OBJCNT > bool "SCTP: Debug object counts" > diff --git a/net/sctp/associola.c b/net/sctp/associola.c > index 9a383a8..6554b87 100644 > --- a/net/sctp/associola.c > +++ b/net/sctp/associola.c > @@ -357,7 +357,8 @@ struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep, > goto fail_init; > > SCTP_DBG_OBJCNT_INC(assoc); > - SCTP_DEBUG_PRINTK("Created asoc %p\n", asoc); > + > + pr_debug("Created asoc %p\n", asoc); > > return asoc; > > @@ -455,7 +456,10 @@ void sctp_association_free(struct sctp_association *asoc) > /* Cleanup and free up an association. */ > static void sctp_association_destroy(struct sctp_association *asoc) > { > - SCTP_ASSERT(asoc->base.dead, "Assoc is not dead", return); > + if (unlikely(!asoc->base.dead)) { > + WARN(1, "Attempt to destroy undead association %p!\n", asoc); > + return; > + } > > sctp_endpoint_put(asoc->ep); > sock_put(asoc->base.sk); > @@ -536,11 +540,9 @@ void sctp_assoc_rm_peer(struct sctp_association *asoc, > struct list_head *pos; > struct sctp_transport *transport; > > - SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_rm_peer:association %p addr: ", > - " port: %d\n", > - asoc, > - (&peer->ipaddr), > - ntohs(peer->ipaddr.v4.sin_port)); > + pr_debug("%s: association:%p addr:%pIg port:%d\n", > + __func__, asoc, &peer->ipaddr.sa, > + ntohs(peer->ipaddr.v4.sin_port)); > > /* If we are to remove the current retran_path, update it > * to the next peer before removing this peer from the list. > @@ -636,12 +638,8 @@ struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc, > /* AF_INET and AF_INET6 share common port field. */ > port = ntohs(addr->v4.sin_port); > > - SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_add_peer:association %p addr: ", > - " port: %d state:%d\n", > - asoc, > - addr, > - port, > - peer_state); > + pr_debug("%s: association:%p addr:%pIg port:%d state:%d\n", __func__, > + asoc, &addr->sa, port, peer_state); > > /* Set the port if it has not been set yet. */ > if (0 == asoc->peer.port) > @@ -708,8 +706,9 @@ struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc, > else > asoc->pathmtu = peer->pathmtu; > > - SCTP_DEBUG_PRINTK("sctp_assoc_add_peer:association %p PMTU set to " > - "%d\n", asoc, asoc->pathmtu); > + pr_debug("%s: association:%p PMTU set to %d\n", __func__, asoc, > + asoc->pathmtu); > + > peer->pmtu_pending = 0; > > asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu); > @@ -1349,12 +1348,8 @@ void sctp_assoc_update_retran_path(struct sctp_association *asoc) > else > t = asoc->peer.retran_path; > > - SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association" > - " %p addr: ", > - " port: %d\n", > - asoc, > - (&t->ipaddr), > - ntohs(t->ipaddr.v4.sin_port)); > + pr_debug("%s: association:%p addr:%pIg port:%d\n", __func__, asoc, > + &t->ipaddr.sa, ntohs(t->ipaddr.v4.sin_port)); > } > > /* Choose the transport for sending retransmit packet. */ > @@ -1401,8 +1396,8 @@ void sctp_assoc_sync_pmtu(struct sock *sk, struct sctp_association *asoc) > asoc->frag_point = sctp_frag_point(asoc, pmtu); > } > > - SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n", > - __func__, asoc, asoc->pathmtu, asoc->frag_point); > + pr_debug("%s: asoc:%p, pmtu:%d, frag_point:%d\n", __func__, asoc, > + asoc->pathmtu, asoc->frag_point); > } > > /* Should we send a SACK to update our peer? */ > @@ -1454,9 +1449,9 @@ void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len) > asoc->rwnd_press -= change; > } > > - SCTP_DEBUG_PRINTK("%s: asoc %p rwnd increased by %d to (%u, %u) " > - "- %u\n", __func__, asoc, len, asoc->rwnd, > - asoc->rwnd_over, asoc->a_rwnd); > + pr_debug("%s: asoc:%p rwnd increased by %d to (%u, %u) - %u\n", > + __func__, asoc, len, asoc->rwnd, asoc->rwnd_over, > + asoc->a_rwnd); > > /* Send a window update SACK if the rwnd has increased by at least the > * minimum of the association's PMTU and half of the receive buffer. > @@ -1465,9 +1460,11 @@ void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len) > */ > if (sctp_peer_needs_update(asoc)) { > asoc->a_rwnd = asoc->rwnd; > - SCTP_DEBUG_PRINTK("%s: Sending window update SACK- asoc: %p " > - "rwnd: %u a_rwnd: %u\n", __func__, > - asoc, asoc->rwnd, asoc->a_rwnd); > + > + pr_debug("%s: sending window update SACK- asoc:%p rwnd:%u " > + "a_rwnd:%u\n", __func__, asoc, asoc->rwnd, > + asoc->a_rwnd); > + > sack = sctp_make_sack(asoc); > if (!sack) > return; > @@ -1489,8 +1486,11 @@ void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned int len) > int rx_count; > int over = 0; > > - SCTP_ASSERT(asoc->rwnd, "rwnd zero", return); > - SCTP_ASSERT(!asoc->rwnd_over, "rwnd_over not zero", return); > + if (unlikely(!asoc->rwnd || asoc->rwnd_over)) { > + WARN(1, "Association %p has asoc->rwnd:%u, asoc->rwnd_over:%u!\n", > + asoc, asoc->rwnd, asoc->rwnd_over); > + return; > + } I think this warning is likely to kick under heavy usage. I think converting it to pr_debug should be sufficient. > > if (asoc->ep->rcvbuf_policy) > rx_count = atomic_read(&asoc->rmem_alloc); > @@ -1515,9 +1515,10 @@ void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned int len) > asoc->rwnd_over = len - asoc->rwnd; > asoc->rwnd = 0; > } > - SCTP_DEBUG_PRINTK("%s: asoc %p rwnd decreased by %d to (%u, %u, %u)\n", > - __func__, asoc, len, asoc->rwnd, > - asoc->rwnd_over, asoc->rwnd_press); > + > + pr_debug("%s: asoc:%p rwnd decreased by %d to (%u, %u, %u)\n", > + __func__, asoc, len, asoc->rwnd, asoc->rwnd_over, > + asoc->rwnd_press); > } > > /* Build the bind address list for the association based on info from the > diff --git a/net/sctp/chunk.c b/net/sctp/chunk.c > index 7135fc0..5780565 100644 > --- a/net/sctp/chunk.c > +++ b/net/sctp/chunk.c > @@ -193,8 +193,9 @@ struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc, > msg->expires_at = jiffies + > msecs_to_jiffies(sinfo->sinfo_timetolive); > msg->can_abandon = 1; > - SCTP_DEBUG_PRINTK("%s: msg:%p expires_at: %ld jiffies:%ld\n", > - __func__, msg, msg->expires_at, jiffies); > + > + pr_debug("%s: msg:%p expires_at:%ld jiffies:%ld\n", __func__, > + msg, msg->expires_at, jiffies); > } > > /* This is the biggest possible DATA chunk that can fit into > diff --git a/net/sctp/debug.c b/net/sctp/debug.c > index ec997cf..f499878 100644 > --- a/net/sctp/debug.c > +++ b/net/sctp/debug.c > @@ -47,10 +47,6 @@ > > #include > > -#if SCTP_DEBUG > -int sctp_debug_flag = 1; /* Initially enable DEBUG */ > -#endif /* SCTP_DEBUG */ > - > /* These are printable forms of Chunk ID's from section 3.1. */ > static const char *const sctp_cid_tbl[SCTP_NUM_BASE_CHUNK_TYPES] = { > "DATA", > diff --git a/net/sctp/endpointola.c b/net/sctp/endpointola.c > index b26999d..9e3d257 100644 > --- a/net/sctp/endpointola.c > +++ b/net/sctp/endpointola.c > @@ -249,7 +249,10 @@ static void sctp_endpoint_destroy(struct sctp_endpoint *ep) > { > struct sock *sk; > > - SCTP_ASSERT(ep->base.dead, "Endpoint is not dead", return); > + if (unlikely(!ep->base.dead)) { > + WARN(1, "Attempt to destroy undead endpoint %p!\n", ep); > + return; > + } > > /* Free the digest buffer */ > kfree(ep->digest); > diff --git a/net/sctp/input.c b/net/sctp/input.c > index 4cfc746..3fa4d85 100644 > --- a/net/sctp/input.c > +++ b/net/sctp/input.c > @@ -454,8 +454,6 @@ void sctp_icmp_proto_unreachable(struct sock *sk, > struct sctp_association *asoc, > struct sctp_transport *t) > { > - SCTP_DEBUG_PRINTK("%s\n", __func__); > - > if (sock_owned_by_user(sk)) { > if (timer_pending(&t->proto_unreach_timer)) > return; > @@ -464,10 +462,12 @@ void sctp_icmp_proto_unreachable(struct sock *sk, > jiffies + (HZ/20))) > sctp_association_hold(asoc); > } > - > } else { > struct net *net = sock_net(sk); > > + pr_debug("%s: unrecognized next header type " > + "encountered!\n", __func__); > + > if (del_timer(&t->proto_unreach_timer)) > sctp_association_put(asoc); > > diff --git a/net/sctp/inqueue.c b/net/sctp/inqueue.c > index 3221d07..8bbc8cc 100644 > --- a/net/sctp/inqueue.c > +++ b/net/sctp/inqueue.c > @@ -219,10 +219,10 @@ struct sctp_chunk *sctp_inq_pop(struct sctp_inq *queue) > chunk->end_of_packet = 1; > } > > - SCTP_DEBUG_PRINTK("+++sctp_inq_pop+++ chunk %p[%s]," > - " length %d, skb->len %d\n",chunk, > - sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)), > - ntohs(chunk->chunk_hdr->length), chunk->skb->len); > + pr_debug("+++sctp_inq_pop+++ chunk:%p[%s], length:%d, skb->len:%d\n", > + chunk, sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)), > + ntohs(chunk->chunk_hdr->length), chunk->skb->len); > + > return chunk; > } > > @@ -238,4 +238,3 @@ void sctp_inq_set_th_handler(struct sctp_inq *q, work_func_t callback) > { > INIT_WORK(&q->immediate, callback); > } > - > diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c > index adeaa0e..09ffcc9 100644 > --- a/net/sctp/ipv6.c > +++ b/net/sctp/ipv6.c > @@ -239,9 +239,8 @@ static int sctp_v6_xmit(struct sk_buff *skb, struct sctp_transport *transport) > fl6.daddr = *rt0->addr; > } > > - SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, src:%pI6 dst:%pI6\n", > - __func__, skb, skb->len, > - &fl6.saddr, &fl6.daddr); > + pr_debug("%s: skb:%p, len:%d, src:%pI6 dst:%pI6\n", __func__, skb, > + skb->len, &fl6.saddr, &fl6.daddr); > > SCTP_INC_STATS(sock_net(sk), SCTP_MIB_OUTSCTPPACKS); > > @@ -276,7 +275,7 @@ static void sctp_v6_get_dst(struct sctp_transport *t, union sctp_addr *saddr, > if (ipv6_addr_type(&daddr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL) > fl6->flowi6_oif = daddr->v6.sin6_scope_id; > > - SCTP_DEBUG_PRINTK("%s: DST=%pI6 ", __func__, &fl6->daddr); > + pr_debug("%s: dst=%pI6 ", __func__, &fl6->daddr); > > if (asoc) > fl6->fl6_sport = htons(asoc->base.bind_addr.port); > @@ -284,7 +283,8 @@ static void sctp_v6_get_dst(struct sctp_transport *t, union sctp_addr *saddr, > if (saddr) { > fl6->saddr = saddr->v6.sin6_addr; > fl6->fl6_sport = saddr->v6.sin6_port; > - SCTP_DEBUG_PRINTK("SRC=%pI6 - ", &fl6->saddr); > + > + pr_debug("src=%pI6 - ", &fl6->saddr); > } > > dst = ip6_dst_lookup_flow(sk, fl6, NULL, false); > @@ -348,13 +348,16 @@ static void sctp_v6_get_dst(struct sctp_transport *t, union sctp_addr *saddr, > out: > if (!IS_ERR_OR_NULL(dst)) { > struct rt6_info *rt; > + > rt = (struct rt6_info *)dst; > t->dst = dst; > - SCTP_DEBUG_PRINTK("rt6_dst:%pI6 rt6_src:%pI6\n", > - &rt->rt6i_dst.addr, &fl6->saddr); > + > + pr_debug("rt6_dst:%pI6 rt6_src:%pI6\n", &rt->rt6i_dst.addr, > + &fl6->saddr); > } else { > t->dst = NULL; > - SCTP_DEBUG_PRINTK("NO ROUTE\n"); > + > + pr_debug("no route\n"); > } > } > > @@ -377,7 +380,7 @@ static void sctp_v6_get_saddr(struct sctp_sock *sk, > struct flowi6 *fl6 = &fl->u.ip6; > union sctp_addr *saddr = &t->saddr; > > - SCTP_DEBUG_PRINTK("%s: asoc:%p dst:%p\n", __func__, t->asoc, t->dst); > + pr_debug("%s: asoc:%p dst:%p\n", __func__, t->asoc, t->dst); > > if (t->dst) { > saddr->v6.sin6_family = AF_INET6; > diff --git a/net/sctp/output.c b/net/sctp/output.c > index bbef4a7..f07e533 100644 > --- a/net/sctp/output.c > +++ b/net/sctp/output.c > @@ -93,8 +93,7 @@ struct sctp_packet *sctp_packet_config(struct sctp_packet *packet, > { > struct sctp_chunk *chunk = NULL; > > - SCTP_DEBUG_PRINTK("%s: packet:%p vtag:0x%x\n", __func__, > - packet, vtag); > + pr_debug("%s: packet:%p vtag:0x%x\n", __func__, packet, vtag); > > packet->vtag = vtag; > > @@ -119,8 +118,7 @@ struct sctp_packet *sctp_packet_init(struct sctp_packet *packet, > struct sctp_association *asoc = transport->asoc; > size_t overhead; > > - SCTP_DEBUG_PRINTK("%s: packet:%p transport:%p\n", __func__, > - packet, transport); > + pr_debug("%s: packet:%p transport:%p\n", __func__, packet, transport); > > packet->transport = transport; > packet->source_port = sport; > @@ -145,7 +143,7 @@ void sctp_packet_free(struct sctp_packet *packet) > { > struct sctp_chunk *chunk, *tmp; > > - SCTP_DEBUG_PRINTK("%s: packet:%p\n", __func__, packet); > + pr_debug("%s: packet:%p\n", __func__, packet); > > list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) { > list_del_init(&chunk->list); > @@ -167,8 +165,7 @@ sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet, > sctp_xmit_t retval; > int error = 0; > > - SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__, > - packet, chunk); > + pr_debug("%s: packet:%p chunk:%p\n", __func__, packet, chunk); > > switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) { > case SCTP_XMIT_PMTU_FULL: > @@ -334,8 +331,7 @@ sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet, > { > sctp_xmit_t retval = SCTP_XMIT_OK; > > - SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__, packet, > - chunk); > + pr_debug("%s: packet:%p chunk:%p\n", __func__, packet, chunk); > > /* Data chunks are special. Before seeing what else we can > * bundle into this packet, check to see if we are allowed to > @@ -402,7 +398,7 @@ int sctp_packet_transmit(struct sctp_packet *packet) > unsigned char *auth = NULL; /* pointer to auth in skb data */ > __u32 cksum_buf_len = sizeof(struct sctphdr); > > - SCTP_DEBUG_PRINTK("%s: packet:%p\n", __func__, packet); > + pr_debug("%s: packet:%p\n", __func__, packet); > > /* Do NOT generate a chunkless packet. */ > if (list_empty(&packet->chunk_list)) > @@ -472,7 +468,9 @@ int sctp_packet_transmit(struct sctp_packet *packet) > * > * [This whole comment explains WORD_ROUND() below.] > */ > - SCTP_DEBUG_PRINTK("***sctp_transmit_packet***\n"); > + > + pr_debug("***sctp_transmit_packet***\n"); > + > list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) { > list_del_init(&chunk->list); > if (sctp_chunk_is_data(chunk)) { > @@ -505,16 +503,13 @@ int sctp_packet_transmit(struct sctp_packet *packet) > memcpy(skb_put(nskb, chunk->skb->len), > chunk->skb->data, chunk->skb->len); > > - SCTP_DEBUG_PRINTK("%s %p[%s] %s 0x%x, %s %d, %s %d, %s %d\n", > - "*** Chunk", chunk, > - sctp_cname(SCTP_ST_CHUNK( > - chunk->chunk_hdr->type)), > - chunk->has_tsn ? "TSN" : "No TSN", > - chunk->has_tsn ? > - ntohl(chunk->subh.data_hdr->tsn) : 0, > - "length", ntohs(chunk->chunk_hdr->length), > - "chunk->skb->len", chunk->skb->len, > - "rtt_in_progress", chunk->rtt_in_progress); > + pr_debug("*** Chunk:%p[%s] %s 0x%x, length:%d, chunk->skb->len:%d, " > + "rtt_in_progress %d\n", chunk, > + sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)), > + chunk->has_tsn ? "TSN" : "No TSN", > + chunk->has_tsn ? ntohl(chunk->subh.data_hdr->tsn) : 0, > + ntohs(chunk->chunk_hdr->length), chunk->skb->len, > + chunk->rtt_in_progress); > > /* > * If this is a control chunk, this is our last > @@ -606,8 +601,7 @@ int sctp_packet_transmit(struct sctp_packet *packet) > } > } > > - SCTP_DEBUG_PRINTK("***sctp_transmit_packet*** skb len %d\n", > - nskb->len); > + pr_debug("***sctp_transmit_packet*** skb->len:%d\n", nskb->len); > > nskb->local_df = packet->ipfragok; > (*tp->af_specific->sctp_xmit)(nskb, tp); > diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c > index be35e2d..f3d92cf 100644 > --- a/net/sctp/outqueue.c > +++ b/net/sctp/outqueue.c > @@ -299,10 +299,10 @@ int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk) > struct net *net = sock_net(q->asoc->base.sk); > int error = 0; > > - SCTP_DEBUG_PRINTK("sctp_outq_tail(%p, %p[%s])\n", > - q, chunk, chunk && chunk->chunk_hdr ? > - sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) > - : "Illegal Chunk"); > + pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk, > + chunk && chunk->chunk_hdr ? > + sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) : > + "illegal chunk"); > > /* If it is data, queue it up, otherwise, send it > * immediately. > @@ -328,10 +328,10 @@ int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk) > break; > > default: > - SCTP_DEBUG_PRINTK("outqueueing (%p, %p[%s])\n", > - q, chunk, chunk && chunk->chunk_hdr ? > - sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) > - : "Illegal Chunk"); > + pr_debug("%s: outqueueing: outq:%p, chunk:%p[%s])\n", > + __func__, q, chunk, chunk && chunk->chunk_hdr ? > + sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) : > + "illegal chunk"); > > sctp_outq_tail_data(q, chunk); > if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) > @@ -460,14 +460,10 @@ void sctp_retransmit_mark(struct sctp_outq *q, > } > } > > - SCTP_DEBUG_PRINTK("%s: transport: %p, reason: %d, " > - "cwnd: %d, ssthresh: %d, flight_size: %d, " > - "pba: %d\n", __func__, > - transport, reason, > - transport->cwnd, transport->ssthresh, > - transport->flight_size, > - transport->partial_bytes_acked); > - > + pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d, " > + "flight_size:%d, pba:%d\n", __func__, transport, reason, > + transport->cwnd, transport->ssthresh, transport->flight_size, > + transport->partial_bytes_acked); > } > > /* Mark all the eligible packets on a transport for retransmission and force > @@ -1014,19 +1010,13 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout) > sctp_transport_burst_limited(transport); > } > > - SCTP_DEBUG_PRINTK("sctp_outq_flush(%p, %p[%s]), ", > - q, chunk, > - chunk && chunk->chunk_hdr ? > - sctp_cname(SCTP_ST_CHUNK( > - chunk->chunk_hdr->type)) > - : "Illegal Chunk"); > - > - SCTP_DEBUG_PRINTK("TX TSN 0x%x skb->head " > - "%p skb->users %d.\n", > - ntohl(chunk->subh.data_hdr->tsn), > - chunk->skb ?chunk->skb->head : NULL, > - chunk->skb ? > - atomic_read(&chunk->skb->users) : -1); > + pr_debug("%s: outq:%p, chunk:%p[%s], tx-tsn:0x%x skb->head:%p " > + "skb->users:%d\n", > + __func__, q, chunk, chunk && chunk->chunk_hdr ? > + sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) : > + "illegal chunk", ntohl(chunk->subh.data_hdr->tsn), > + chunk->skb ?chunk->skb->head : NULL, chunk->skb ? > + atomic_read(&chunk->skb->users) : -1); > > /* Add the chunk to the packet. */ > status = sctp_packet_transmit_chunk(packet, chunk, 0); > @@ -1038,10 +1028,10 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout) > /* We could not append this chunk, so put > * the chunk back on the output queue. > */ > - SCTP_DEBUG_PRINTK("sctp_outq_flush: could " > - "not transmit TSN: 0x%x, status: %d\n", > - ntohl(chunk->subh.data_hdr->tsn), > - status); > + pr_debug("%s: could not transmit tsn:0x%x, status:%d\n", > + __func__, ntohl(chunk->subh.data_hdr->tsn), > + status); > + > sctp_outq_head_data(q, chunk); > goto sctp_flush_out; > break; > @@ -1284,11 +1274,10 @@ int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk) > > sctp_generate_fwdtsn(q, sack_ctsn); > > - SCTP_DEBUG_PRINTK("%s: sack Cumulative TSN Ack is 0x%x.\n", > - __func__, sack_ctsn); > - SCTP_DEBUG_PRINTK("%s: Cumulative TSN Ack of association, " > - "%p is 0x%x. Adv peer ack point: 0x%x\n", > - __func__, asoc, ctsn, asoc->adv_peer_ack_point); > + pr_debug("%s: sack cumulative tsn ack:0x%x\n", __func__, sack_ctsn); > + pr_debug("%s: cumulative tsn ack of assoc:%p is 0x%x, " > + "advertised peer ack point:0x%x\n", __func__, asoc, ctsn, > + asoc->adv_peer_ack_point); > > /* See if all chunks are acked. > * Make sure the empty queue handler will get run later. > @@ -1304,7 +1293,7 @@ int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk) > goto finish; > } > > - SCTP_DEBUG_PRINTK("sack queue is empty.\n"); > + pr_debug("%s: sack queue is empty.\n", __func__); > finish: > return q->empty; > } > @@ -1348,7 +1337,7 @@ static void sctp_check_transmitted(struct sctp_outq *q, > > /* These state variables are for coherent debug output. --xguo */ > > -#if SCTP_DEBUG > +#ifdef CONFIG_SCTP_DBG_TSNS > __u32 dbg_ack_tsn = 0; /* An ACKed TSN range starts here... */ > __u32 dbg_last_ack_tsn = 0; /* ...and finishes here. */ > __u32 dbg_kept_tsn = 0; /* An un-ACKed range starts here... */ > @@ -1359,7 +1348,7 @@ static void sctp_check_transmitted(struct sctp_outq *q, > * -1: We need to initialize. > */ > int dbg_prt_state = -1; > -#endif /* SCTP_DEBUG */ > +#endif /* CONFIG_SCTP_DBG_TSNS */ > > sack_ctsn = ntohl(sack->cum_tsn_ack); > > @@ -1483,7 +1472,7 @@ static void sctp_check_transmitted(struct sctp_outq *q, > list_add_tail(lchunk, &tlist); > } > > -#if SCTP_DEBUG > +#ifdef CONFIG_SCTP_DBG_TSNS > switch (dbg_prt_state) { > case 0: /* last TSN was ACKed */ > if (dbg_last_ack_tsn + 1 == tsn) { > @@ -1497,42 +1486,39 @@ static void sctp_check_transmitted(struct sctp_outq *q, > /* Display the end of the > * current range. > */ > - SCTP_DEBUG_PRINTK_CONT("-%08x", > - dbg_last_ack_tsn); > + pr_cont("-%08x", dbg_last_ack_tsn); > } > > /* Start a new range. */ > - SCTP_DEBUG_PRINTK_CONT(",%08x", tsn); > + pr_cont(",%08x", tsn); > dbg_ack_tsn = tsn; > break; > > case 1: /* The last TSN was NOT ACKed. */ > if (dbg_last_kept_tsn != dbg_kept_tsn) { > /* Display the end of current range. */ > - SCTP_DEBUG_PRINTK_CONT("-%08x", > - dbg_last_kept_tsn); > + pr_cont("-%08x", dbg_last_kept_tsn); > } > > - SCTP_DEBUG_PRINTK_CONT("\n"); > - > + pr_cont("\n"); > /* FALL THROUGH... */ > default: > /* This is the first-ever TSN we examined. */ > /* Start a new range of ACK-ed TSNs. */ > - SCTP_DEBUG_PRINTK("ACKed: %08x", tsn); > + pr_debug("ACKed: %08x", tsn); > + > dbg_prt_state = 0; > dbg_ack_tsn = tsn; > } > > dbg_last_ack_tsn = tsn; > -#endif /* SCTP_DEBUG */ > +#endif /* CONFIG_SCTP_DBG_TSNS */ > > } else { > if (tchunk->tsn_gap_acked) { > - SCTP_DEBUG_PRINTK("%s: Receiver reneged on " > - "data TSN: 0x%x\n", > - __func__, > - tsn); > + pr_debug("%s: receiver reneged on data TSN:0x%x\n", > + __func__, tsn); > + > tchunk->tsn_gap_acked = 0; > > if (tchunk->transport) > @@ -1552,7 +1538,7 @@ static void sctp_check_transmitted(struct sctp_outq *q, > > list_add_tail(lchunk, &tlist); > > -#if SCTP_DEBUG > +#ifdef CONFIG_SCTP_DBG_TSNS > /* See the above comments on ACK-ed TSNs. */ > switch (dbg_prt_state) { > case 1: > @@ -1560,50 +1546,47 @@ static void sctp_check_transmitted(struct sctp_outq *q, > break; > > if (dbg_last_kept_tsn != dbg_kept_tsn) > - SCTP_DEBUG_PRINTK_CONT("-%08x", > - dbg_last_kept_tsn); > + pr_cont("-%08x", dbg_last_kept_tsn); > > - SCTP_DEBUG_PRINTK_CONT(",%08x", tsn); > + pr_cont(",%08x", tsn); > dbg_kept_tsn = tsn; > break; > > case 0: > if (dbg_last_ack_tsn != dbg_ack_tsn) > - SCTP_DEBUG_PRINTK_CONT("-%08x", > - dbg_last_ack_tsn); > - SCTP_DEBUG_PRINTK_CONT("\n"); > + pr_cont("-%08x", dbg_last_ack_tsn); > > + pr_cont("\n"); > /* FALL THROUGH... */ > default: > - SCTP_DEBUG_PRINTK("KEPT: %08x",tsn); > + pr_debug("KEPT: %08x", tsn); > + > dbg_prt_state = 1; > dbg_kept_tsn = tsn; > } > > dbg_last_kept_tsn = tsn; > -#endif /* SCTP_DEBUG */ > +#endif /* CONFIG_SCTP_DBG_TSNS */ > } > } > > -#if SCTP_DEBUG > +#ifdef CONFIG_SCTP_DBG_TSNS > /* Finish off the last range, displaying its ending TSN. */ > switch (dbg_prt_state) { > case 0: > - if (dbg_last_ack_tsn != dbg_ack_tsn) { > - SCTP_DEBUG_PRINTK_CONT("-%08x\n", dbg_last_ack_tsn); > - } else { > - SCTP_DEBUG_PRINTK_CONT("\n"); > - } > - break; > - > + if (dbg_last_ack_tsn != dbg_ack_tsn) > + pr_cont("-%08x\n", dbg_last_ack_tsn); > + else > + pr_cont("\n"); > + break; > case 1: > - if (dbg_last_kept_tsn != dbg_kept_tsn) { > - SCTP_DEBUG_PRINTK_CONT("-%08x\n", dbg_last_kept_tsn); > - } else { > - SCTP_DEBUG_PRINTK_CONT("\n"); > - } > + if (dbg_last_kept_tsn != dbg_kept_tsn) > + pr_cont("-%08x\n", dbg_last_kept_tsn); > + else > + pr_cont("\n"); > + break; > } > -#endif /* SCTP_DEBUG */ > +#endif /* CONFIG_SCTP_DBG_TSNS */ > if (transport) { > if (bytes_acked) { > struct sctp_association *asoc = transport->asoc; > @@ -1676,9 +1659,9 @@ static void sctp_check_transmitted(struct sctp_outq *q, > !list_empty(&tlist) && > (sack_ctsn+2 == q->asoc->next_tsn) && > q->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) { > - SCTP_DEBUG_PRINTK("%s: SACK received for zero " > - "window probe: %u\n", > - __func__, sack_ctsn); > + pr_debug("%s: sack received for zero window " > + "probe:%u\n", __func__, sack_ctsn); > + > q->asoc->overall_error_count = 0; > transport->error_count = 0; > } > @@ -1739,10 +1722,8 @@ static void sctp_mark_missing(struct sctp_outq *q, > count_of_newacks, tsn)) { > chunk->tsn_missing_report++; > > - SCTP_DEBUG_PRINTK( > - "%s: TSN 0x%x missing counter: %d\n", > - __func__, tsn, > - chunk->tsn_missing_report); > + pr_debug("%s: tsn:0x%x missing counter:%d\n", > + __func__, tsn, chunk->tsn_missing_report); > } > } > /* > @@ -1762,11 +1743,10 @@ static void sctp_mark_missing(struct sctp_outq *q, > if (do_fast_retransmit) > sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX); > > - SCTP_DEBUG_PRINTK("%s: transport: %p, cwnd: %d, " > - "ssthresh: %d, flight_size: %d, pba: %d\n", > - __func__, transport, transport->cwnd, > - transport->ssthresh, transport->flight_size, > - transport->partial_bytes_acked); > + pr_debug("%s: transport:%p, cwnd:%d, ssthresh:%d, " > + "flight_size:%d, pba:%d\n", __func__, transport, > + transport->cwnd, transport->ssthresh, > + transport->flight_size, transport->partial_bytes_acked); > } > } > > diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c > index 1de49c8..f193d4e 100644 > --- a/net/sctp/protocol.c > +++ b/net/sctp/protocol.c > @@ -451,8 +451,8 @@ static void sctp_v4_get_dst(struct sctp_transport *t, union sctp_addr *saddr, > fl4->fl4_sport = saddr->v4.sin_port; > } > > - SCTP_DEBUG_PRINTK("%s: DST:%pI4, SRC:%pI4 - ", > - __func__, &fl4->daddr, &fl4->saddr); > + pr_debug("%s: dst:%pI4, src:%pI4 - ", __func__, &fl4->daddr, > + &fl4->saddr); > > rt = ip_route_output_key(sock_net(sk), fl4); > if (!IS_ERR(rt)) > @@ -513,10 +513,10 @@ out_unlock: > out: > t->dst = dst; > if (dst) > - SCTP_DEBUG_PRINTK("rt_dst:%pI4, rt_src:%pI4\n", > - &fl4->daddr, &fl4->saddr); > + pr_debug("rt_dst:%pI4, rt_src:%pI4\n", > + &fl4->daddr, &fl4->saddr); > else > - SCTP_DEBUG_PRINTK("NO ROUTE\n"); > + pr_debug("no route\n"); > } > > /* For v4, the source address is cached in the route entry(dst). So no need > @@ -604,9 +604,9 @@ static void sctp_addr_wq_timeout_handler(unsigned long arg) > spin_lock_bh(&net->sctp.addr_wq_lock); > > list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) { > - SCTP_DEBUG_PRINTK_IPADDR("sctp_addrwq_timo_handler: the first ent in wq %p is ", > - " for cmd %d at entry %p\n", &net->sctp.addr_waitq, &addrw->a, addrw->state, > - addrw); > + pr_debug("%s: the first ent in wq:%p is addr:%pIg for cmd:%d at " > + "entry:%p\n", __func__, &net->sctp.addr_waitq, &addrw->a.sa, > + addrw->state, addrw); > > #if IS_ENABLED(CONFIG_IPV6) > /* Now we send an ASCONF for each association */ > @@ -623,8 +623,10 @@ static void sctp_addr_wq_timeout_handler(unsigned long arg) > addrw->state == SCTP_ADDR_NEW) { > unsigned long timeo_val; > > - SCTP_DEBUG_PRINTK("sctp_timo_handler: this is on DAD, trying %d sec later\n", > - SCTP_ADDRESS_TICK_DELAY); > + pr_debug("%s: this is on DAD, trying %d sec " > + "later\n", __func__, > + SCTP_ADDRESS_TICK_DELAY); > + > timeo_val = jiffies; > timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY); > mod_timer(&net->sctp.addr_wq_timer, timeo_val); > @@ -641,7 +643,7 @@ static void sctp_addr_wq_timeout_handler(unsigned long arg) > continue; > sctp_bh_lock_sock(sk); > if (sctp_asconf_mgmt(sp, addrw) < 0) > - SCTP_DEBUG_PRINTK("sctp_addrwq_timo_handler: sctp_asconf_mgmt failed\n"); > + pr_debug("%s: sctp_asconf_mgmt failed\n", __func__); > sctp_bh_unlock_sock(sk); > } > #if IS_ENABLED(CONFIG_IPV6) > @@ -707,9 +709,10 @@ void sctp_addr_wq_mgmt(struct net *net, struct sctp_sockaddr_entry *addr, int cm > addrw = sctp_addr_wq_lookup(net, addr); > if (addrw) { > if (addrw->state != cmd) { > - SCTP_DEBUG_PRINTK_IPADDR("sctp_addr_wq_mgmt offsets existing entry for %d ", > - " in wq %p\n", addrw->state, &addrw->a, > - &net->sctp.addr_waitq); > + pr_debug("%s: offsets existing entry for %d, addr:%pIg " > + "in wq:%p\n", __func__, addrw->state, &addrw->a.sa, > + &net->sctp.addr_waitq); > + > list_del(&addrw->list); > kfree(addrw); > } > @@ -725,8 +728,9 @@ void sctp_addr_wq_mgmt(struct net *net, struct sctp_sockaddr_entry *addr, int cm > } > addrw->state = cmd; > list_add_tail(&addrw->list, &net->sctp.addr_waitq); > - SCTP_DEBUG_PRINTK_IPADDR("sctp_addr_wq_mgmt add new entry for cmd:%d ", > - " in wq %p\n", addrw->state, &addrw->a, &net->sctp.addr_waitq); > + > + pr_debug("%s: add new entry for cmd:%d, addr:%pIg in wq:%p\n", > + __func__, addrw->state, &addrw->a.sa, &net->sctp.addr_waitq); > > if (!timer_pending(&net->sctp.addr_wq_timer)) { > timeo_val = jiffies; > @@ -952,15 +956,14 @@ static inline int sctp_v4_xmit(struct sk_buff *skb, > { > struct inet_sock *inet = inet_sk(skb->sk); > > - SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n", > - __func__, skb, skb->len, > - &transport->fl.u.ip4.saddr, > - &transport->fl.u.ip4.daddr); > + pr_debug("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n", __func__, skb, > + skb->len, &transport->fl.u.ip4.saddr, &transport->fl.u.ip4.daddr); > > inet->pmtudisc = transport->param_flags & SPP_PMTUD_ENABLE ? > IP_PMTUDISC_DO : IP_PMTUDISC_DONT; > > SCTP_INC_STATS(sock_net(&inet->sk), SCTP_MIB_OUTSCTPPACKS); > + > return ip_queue_xmit(skb, &transport->fl); > } > > @@ -1321,9 +1324,8 @@ static __init int sctp_init(void) > int max_share; > int order; > > - /* SCTP_DEBUG sanity check. */ > - if (!sctp_sanity_check()) > - goto out; > + BUILD_BUG_ON(sizeof(struct sctp_ulpevent) > > + sizeof(((struct sk_buff *) 0)->cb)); > > /* Allocate bind_bucket and chunk caches. */ > status = -ENOBUFS; > diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c > index dd71f1f..781a848 100644 > --- a/net/sctp/sm_make_chunk.c > +++ b/net/sctp/sm_make_chunk.c > @@ -741,7 +741,8 @@ struct sctp_chunk *sctp_make_sack(const struct sctp_association *asoc) > > memset(gabs, 0, sizeof(gabs)); > ctsn = sctp_tsnmap_get_ctsn(map); > - SCTP_DEBUG_PRINTK("sackCTSNAck sent: 0x%x.\n", ctsn); > + > + pr_debug("%s: sackCTSNAck sent:0x%x\n", __func__, ctsn); > > /* How much room is needed in the chunk? */ > num_gabs = sctp_tsnmap_num_gabs(map, gabs); > @@ -1287,10 +1288,8 @@ struct sctp_chunk *sctp_chunkify(struct sk_buff *skb, > > if (!retval) > goto nodata; > - > - if (!sk) { > - SCTP_DEBUG_PRINTK("chunkifying skb %p w/o an sk\n", skb); > - } > + if (!sk) > + pr_debug("%s: chunkifying skb:%p w/o an sk\n", __func__, skb); > > INIT_LIST_HEAD(&retval->list); > retval->skb = skb; > @@ -2191,8 +2190,9 @@ static sctp_ierror_t sctp_verify_param(struct net *net, > break; > fallthrough: > default: > - SCTP_DEBUG_PRINTK("Unrecognized param: %d for chunk %d.\n", > - ntohs(param.p->type), cid); > + pr_debug("%s: unrecognized param:%d for chunk:%d\n", > + __func__, ntohs(param.p->type), cid); > + > retval = sctp_process_unk_param(asoc, param, chunk, err_chunk); > break; > } > @@ -2516,7 +2516,7 @@ do_addr_param: > break; > > case SCTP_PARAM_HOST_NAME_ADDRESS: > - SCTP_DEBUG_PRINTK("unimplemented SCTP_HOST_NAME_ADDRESS\n"); > + pr_debug("%s: unimplemented SCTP_HOST_NAME_ADDRESS\n", __func__); > break; > > case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES: > @@ -2662,8 +2662,8 @@ fall_through: > * called prior to this routine. Simply log the error > * here. > */ > - SCTP_DEBUG_PRINTK("Ignoring param: %d for association %p.\n", > - ntohs(param.p->type), asoc); > + pr_debug("%s: ignoring param:%d for association:%p.\n", > + __func__, ntohs(param.p->type), asoc); > break; > } > > @@ -2805,7 +2805,10 @@ struct sctp_chunk *sctp_make_asconf_update_ip(struct sctp_association *asoc, > totallen += paramlen; > totallen += addr_param_len; > del_pickup = 1; > - SCTP_DEBUG_PRINTK("mkasconf_update_ip: picked same-scope del_pending addr, totallen for all addresses is %d\n", totallen); > + > + pr_debug("%s: picked same-scope del_pending addr, " > + "totallen for all addresses is %d\n", > + __func__, totallen); > } > } > > diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c > index ff91f47..f79be42 100644 > --- a/net/sctp/sm_sideeffect.c > +++ b/net/sctp/sm_sideeffect.c > @@ -257,7 +257,7 @@ void sctp_generate_t3_rtx_event(unsigned long peer) > > sctp_bh_lock_sock(asoc->base.sk); > if (sock_owned_by_user(asoc->base.sk)) { > - SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__); > + pr_debug("%s: sock is busy\n", __func__); > > /* Try again later. */ > if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20))) > @@ -297,9 +297,8 @@ static void sctp_generate_timeout_event(struct sctp_association *asoc, > > sctp_bh_lock_sock(asoc->base.sk); > if (sock_owned_by_user(asoc->base.sk)) { > - SCTP_DEBUG_PRINTK("%s:Sock is busy: timer %d\n", > - __func__, > - timeout_type); > + pr_debug("%s: sock is busy: timer %d\n", __func__, > + timeout_type); > > /* Try again later. */ > if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20))) > @@ -377,7 +376,7 @@ void sctp_generate_heartbeat_event(unsigned long data) > > sctp_bh_lock_sock(asoc->base.sk); > if (sock_owned_by_user(asoc->base.sk)) { > - SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__); > + pr_debug("%s: sock is busy\n", __func__); > > /* Try again later. */ > if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20))) > @@ -415,7 +414,7 @@ void sctp_generate_proto_unreach_event(unsigned long data) > > sctp_bh_lock_sock(asoc->base.sk); > if (sock_owned_by_user(asoc->base.sk)) { > - SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__); > + pr_debug("%s: sock is busy\n", __func__); > > /* Try again later. */ > if (!mod_timer(&transport->proto_unreach_timer, > @@ -521,11 +520,10 @@ static void sctp_do_8_2_transport_strike(sctp_cmd_seq_t *commands, > > if (transport->state != SCTP_INACTIVE && > (transport->error_count > transport->pathmaxrxt)) { > - SCTP_DEBUG_PRINTK_IPADDR("transport_strike:association %p", > - " transport IP: port:%d failed.\n", > - asoc, > - (&transport->ipaddr), > - ntohs(transport->ipaddr.v4.sin_port)); > + pr_debug("%s: association:%p transport addr:%pIg port:%d " > + "failed.\n", __func__, asoc, &transport->ipaddr.sa, > + ntohs(transport->ipaddr.v4.sin_port)); > + > sctp_assoc_control_transport(asoc, transport, > SCTP_TRANSPORT_DOWN, > SCTP_FAILED_THRESHOLD); > @@ -804,8 +802,7 @@ static void sctp_cmd_new_state(sctp_cmd_seq_t *cmds, > > asoc->state = state; > > - SCTP_DEBUG_PRINTK("sctp_cmd_new_state: asoc %p[%s]\n", > - asoc, sctp_state_tbl[state]); > + pr_debug("%s: asoc:%p[%s]\n", __func__, asoc, sctp_state_tbl[state]); > > if (sctp_style(sk, TCP)) { > /* Change the sk->sk_state of a TCP-style socket that has > @@ -1017,15 +1014,11 @@ static void sctp_cmd_t1_timer_update(struct sctp_association *asoc, > asoc->timeouts[timer] = asoc->max_init_timeo; > } > asoc->init_cycle++; > - SCTP_DEBUG_PRINTK( > - "T1 %s Timeout adjustment" > - " init_err_counter: %d" > - " cycle: %d" > - " timeout: %ld\n", > - name, > - asoc->init_err_counter, > - asoc->init_cycle, > - asoc->timeouts[timer]); > + > + pr_debug("%s: T1[%s] timeout adjustment init_err_counter:%d" > + " cycle:%d timeout:%ld\n", __func__, name, > + asoc->init_err_counter, asoc->init_cycle, > + asoc->timeouts[timer]); > } > > } > @@ -1080,23 +1073,19 @@ static void sctp_cmd_send_asconf(struct sctp_association *asoc) > * main flow of sctp_do_sm() to keep attention focused on the real > * functionality there. > */ > -#define DEBUG_PRE \ > - SCTP_DEBUG_PRINTK("sctp_do_sm prefn: " \ > - "ep %p, %s, %s, asoc %p[%s], %s\n", \ > - ep, sctp_evttype_tbl[event_type], \ > - (*debug_fn)(subtype), asoc, \ > - sctp_state_tbl[state], state_fn->name) > - > -#define DEBUG_POST \ > - SCTP_DEBUG_PRINTK("sctp_do_sm postfn: " \ > - "asoc %p, status: %s\n", \ > - asoc, sctp_status_tbl[status]) > - > -#define DEBUG_POST_SFX \ > - SCTP_DEBUG_PRINTK("sctp_do_sm post sfx: error %d, asoc %p[%s]\n", \ > - error, asoc, \ > - sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \ > - sctp_assoc2id(asoc)))?asoc->state:SCTP_STATE_CLOSED]) > +#define debug_pre_sfn() \ > + pr_debug("%s[pre-fn]: ep:%p, %s, %s, asoc:%p[%s], %s\n", __func__, \ > + ep, sctp_evttype_tbl[event_type], (*debug_fn)(subtype), \ > + asoc, sctp_state_tbl[state], state_fn->name) > + > +#define debug_post_sfn() \ > + pr_debug("%s[post-fn]: asoc:%p, status:%s\n", __func__, asoc, \ > + sctp_status_tbl[status]) > + > +#define debug_post_sfx() \ > + pr_debug("%s[post-sfx]: error:%d, asoc:%p[%s]\n", __func__, error, \ > + asoc, sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \ > + sctp_assoc2id(asoc))) ? asoc->state : SCTP_STATE_CLOSED]) > > /* > * This is the master state machine processing function. > @@ -1116,7 +1105,6 @@ int sctp_do_sm(struct net *net, sctp_event_t event_type, sctp_subtype_t subtype, > sctp_disposition_t status; > int error = 0; > typedef const char *(printfn_t)(sctp_subtype_t); > - > static printfn_t *table[] = { > NULL, sctp_cname, sctp_tname, sctp_oname, sctp_pname, > }; > @@ -1129,21 +1117,18 @@ int sctp_do_sm(struct net *net, sctp_event_t event_type, sctp_subtype_t subtype, > > sctp_init_cmd_seq(&commands); > > - DEBUG_PRE; > + debug_pre_sfn(); > status = (*state_fn->fn)(net, ep, asoc, subtype, event_arg, &commands); > - DEBUG_POST; > + debug_post_sfn(); > > error = sctp_side_effects(event_type, subtype, state, > ep, asoc, event_arg, status, > &commands, gfp); > - DEBUG_POST_SFX; > + debug_post_sfx(); > > return error; > } > > -#undef DEBUG_PRE > -#undef DEBUG_POST > - > /***************************************************************** > * This the master state function side effect processing function. > *****************************************************************/ > @@ -1172,9 +1157,9 @@ static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype, > > switch (status) { > case SCTP_DISPOSITION_DISCARD: > - SCTP_DEBUG_PRINTK("Ignored sctp protocol event - state %d, " > - "event_type %d, event_id %d\n", > - state, event_type, subtype.chunk); > + pr_debug("%s: ignored sctp protocol event - state:%d, " > + "event_type:%d, event_id:%d\n", __func__, state, > + event_type, subtype.chunk); > break; > > case SCTP_DISPOSITION_NOMEM: > @@ -1425,18 +1410,18 @@ static int sctp_cmd_interpreter(sctp_event_t event_type, > > case SCTP_CMD_CHUNK_ULP: > /* Send a chunk to the sockets layer. */ > - SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n", > - "chunk_up:", cmd->obj.chunk, > - "ulpq:", &asoc->ulpq); > + pr_debug("%s: sm_sideff: chunk_up:%p, ulpq:%p\n", > + __func__, cmd->obj.chunk, &asoc->ulpq); > + > sctp_ulpq_tail_data(&asoc->ulpq, cmd->obj.chunk, > GFP_ATOMIC); > break; > > case SCTP_CMD_EVENT_ULP: > /* Send a notification to the sockets layer. */ > - SCTP_DEBUG_PRINTK("sm_sideff: %s %p, %s %p.\n", > - "event_up:",cmd->obj.ulpevent, > - "ulpq:",&asoc->ulpq); > + pr_debug("%s: sm_sideff: event_up:%p, ulpq:%p\n", > + __func__, cmd->obj.ulpevent, &asoc->ulpq); > + > sctp_ulpq_tail_event(&asoc->ulpq, cmd->obj.ulpevent); > break; > > @@ -1601,7 +1586,7 @@ static int sctp_cmd_interpreter(sctp_event_t event_type, > break; > > case SCTP_CMD_REPORT_BAD_TAG: > - SCTP_DEBUG_PRINTK("vtag mismatch!\n"); > + pr_debug("%s: vtag mismatch!\n", __func__); > break; > > case SCTP_CMD_STRIKE: > diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c > index b3d1868..f6b7109 100644 > --- a/net/sctp/sm_statefuns.c > +++ b/net/sctp/sm_statefuns.c > @@ -1179,9 +1179,9 @@ sctp_disposition_t sctp_sf_backbeat_8_3(struct net *net, > /* Check if the timestamp looks valid. */ > if (time_after(hbinfo->sent_at, jiffies) || > time_after(jiffies, hbinfo->sent_at + max_interval)) { > - SCTP_DEBUG_PRINTK("%s: HEARTBEAT ACK with invalid timestamp " > - "received for transport: %p\n", > - __func__, link); > + pr_debug("%s: HEARTBEAT ACK with invalid timestamp received " > + "for transport:%p\n", __func__, link); > + > return SCTP_DISPOSITION_DISCARD; > } > > @@ -2562,7 +2562,8 @@ static sctp_disposition_t sctp_stop_t1_and_abort(struct net *net, > const struct sctp_association *asoc, > struct sctp_transport *transport) > { > - SCTP_DEBUG_PRINTK("ABORT received (INIT).\n"); > + pr_debug("%s: ABORT received (INIT)\n", __func__); > + > sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE, > SCTP_STATE(SCTP_STATE_CLOSED)); > SCTP_INC_STATS(net, SCTP_MIB_ABORTEDS); > @@ -2572,6 +2573,7 @@ static sctp_disposition_t sctp_stop_t1_and_abort(struct net *net, > /* CMD_INIT_FAILED will DELETE_TCB. */ > sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED, > SCTP_PERR(error)); > + > return SCTP_DISPOSITION_ABORT; > } > > @@ -2637,8 +2639,9 @@ sctp_disposition_t sctp_sf_do_9_2_shutdown(struct net *net, > ctsn = ntohl(sdh->cum_tsn_ack); > > if (TSN_lt(ctsn, asoc->ctsn_ack_point)) { > - SCTP_DEBUG_PRINTK("ctsn %x\n", ctsn); > - SCTP_DEBUG_PRINTK("ctsn_ack_point %x\n", asoc->ctsn_ack_point); > + pr_debug("%s: ctsn:%x, ctsn_ack_point:%x\n", __func__, ctsn, > + asoc->ctsn_ack_point); > + > return SCTP_DISPOSITION_DISCARD; > } > > @@ -2721,8 +2724,9 @@ sctp_disposition_t sctp_sf_do_9_2_shut_ctsn(struct net *net, > ctsn = ntohl(sdh->cum_tsn_ack); > > if (TSN_lt(ctsn, asoc->ctsn_ack_point)) { > - SCTP_DEBUG_PRINTK("ctsn %x\n", ctsn); > - SCTP_DEBUG_PRINTK("ctsn_ack_point %x\n", asoc->ctsn_ack_point); > + pr_debug("%s: ctsn:%x, ctsn_ack_point:%x\n", __func__, ctsn, > + asoc->ctsn_ack_point); > + > return SCTP_DISPOSITION_DISCARD; > } > > @@ -3174,8 +3178,9 @@ sctp_disposition_t sctp_sf_eat_sack_6_2(struct net *net, > * Point indicates an out-of-order SACK. > */ > if (TSN_lt(ctsn, asoc->ctsn_ack_point)) { > - SCTP_DEBUG_PRINTK("ctsn %x\n", ctsn); > - SCTP_DEBUG_PRINTK("ctsn_ack_point %x\n", asoc->ctsn_ack_point); > + pr_debug("%s: ctsn:%x, ctsn_ack_point:%x\n", __func__, ctsn, > + asoc->ctsn_ack_point); > + > return SCTP_DISPOSITION_DISCARD; > } > > @@ -3859,7 +3864,7 @@ sctp_disposition_t sctp_sf_eat_fwd_tsn(struct net *net, > skb_pull(chunk->skb, len); > > tsn = ntohl(fwdtsn_hdr->new_cum_tsn); > - SCTP_DEBUG_PRINTK("%s: TSN 0x%x.\n", __func__, tsn); > + pr_debug("%s: TSN 0x%x\n", __func__, tsn); > > /* The TSN is too high--silently discard the chunk and count on it > * getting retransmitted later. > @@ -3927,7 +3932,7 @@ sctp_disposition_t sctp_sf_eat_fwd_tsn_fast( > skb_pull(chunk->skb, len); > > tsn = ntohl(fwdtsn_hdr->new_cum_tsn); > - SCTP_DEBUG_PRINTK("%s: TSN 0x%x.\n", __func__, tsn); > + pr_debug("%s: TSN 0x%x\n", __func__, tsn); > > /* The TSN is too high--silently discard the chunk and count on it > * getting retransmitted later. > @@ -4166,7 +4171,7 @@ sctp_disposition_t sctp_sf_unk_chunk(struct net *net, > struct sctp_chunk *err_chunk; > sctp_chunkhdr_t *hdr; > > - SCTP_DEBUG_PRINTK("Processing the unknown chunk id %d.\n", type.chunk); > + pr_debug("%s: processing unknown chunk id:%d\n", __func__, type.chunk); > > if (!sctp_vtag_verify(unk_chunk, asoc)) > return sctp_sf_pdiscard(net, ep, asoc, type, arg, commands); > @@ -4256,7 +4261,8 @@ sctp_disposition_t sctp_sf_discard_chunk(struct net *net, > return sctp_sf_violation_chunklen(net, ep, asoc, type, arg, > commands); > > - SCTP_DEBUG_PRINTK("Chunk %d is discarded\n", type.chunk); > + pr_debug("%s: chunk:%d is discarded\n", __func__, type.chunk); > + > return SCTP_DISPOSITION_DISCARD; > } > > @@ -5184,7 +5190,9 @@ sctp_disposition_t sctp_sf_ignore_primitive( > void *arg, > sctp_cmd_seq_t *commands) > { > - SCTP_DEBUG_PRINTK("Primitive type %d is ignored.\n", type.primitive); > + pr_debug("%s: primitive type:%d is ignored\n", __func__, > + type.primitive); > + > return SCTP_DISPOSITION_DISCARD; > } > > @@ -5379,7 +5387,9 @@ sctp_disposition_t sctp_sf_ignore_other(struct net *net, > void *arg, > sctp_cmd_seq_t *commands) > { > - SCTP_DEBUG_PRINTK("The event other type %d is ignored\n", type.other); > + pr_debug("%s: the event other type:%d is ignored\n", > + __func__, type.other); > + > return SCTP_DISPOSITION_DISCARD; > } > > @@ -5527,7 +5537,8 @@ sctp_disposition_t sctp_sf_t1_init_timer_expire(struct net *net, > struct sctp_bind_addr *bp; > int attempts = asoc->init_err_counter + 1; > > - SCTP_DEBUG_PRINTK("Timer T1 expired (INIT).\n"); > + pr_debug("%s: timer T1 expired (INIT)\n", __func__); > + > SCTP_INC_STATS(net, SCTP_MIB_T1_INIT_EXPIREDS); > > if (attempts <= asoc->max_init_attempts) { > @@ -5546,9 +5557,10 @@ sctp_disposition_t sctp_sf_t1_init_timer_expire(struct net *net, > > sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl)); > } else { > - SCTP_DEBUG_PRINTK("Giving up on INIT, attempts: %d" > - " max_init_attempts: %d\n", > - attempts, asoc->max_init_attempts); > + pr_debug("%s: giving up on INIT, attempts:%d " > + "max_init_attempts:%d\n", __func__, attempts, > + asoc->max_init_attempts); > + > sctp_add_cmd_sf(commands, SCTP_CMD_SET_SK_ERR, > SCTP_ERROR(ETIMEDOUT)); > sctp_add_cmd_sf(commands, SCTP_CMD_INIT_FAILED, > @@ -5588,7 +5600,8 @@ sctp_disposition_t sctp_sf_t1_cookie_timer_expire(struct net *net, > struct sctp_chunk *repl = NULL; > int attempts = asoc->init_err_counter + 1; > > - SCTP_DEBUG_PRINTK("Timer T1 expired (COOKIE-ECHO).\n"); > + pr_debug("%s: timer T1 expired (COOKIE-ECHO)\n", __func__); > + > SCTP_INC_STATS(net, SCTP_MIB_T1_COOKIE_EXPIREDS); > > if (attempts <= asoc->max_init_attempts) { > @@ -5636,7 +5649,8 @@ sctp_disposition_t sctp_sf_t2_timer_expire(struct net *net, > { > struct sctp_chunk *reply = NULL; > > - SCTP_DEBUG_PRINTK("Timer T2 expired.\n"); > + pr_debug("%s: timer T2 expired\n", __func__); > + > SCTP_INC_STATS(net, SCTP_MIB_T2_SHUTDOWN_EXPIREDS); > > ((struct sctp_association *)asoc)->shutdown_retries++; > @@ -5777,7 +5791,8 @@ sctp_disposition_t sctp_sf_t5_timer_expire(struct net *net, > { > struct sctp_chunk *reply = NULL; > > - SCTP_DEBUG_PRINTK("Timer T5 expired.\n"); > + pr_debug("%s: timer T5 expired\n", __func__); > + > SCTP_INC_STATS(net, SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS); > > reply = sctp_make_abort(asoc, NULL, 0); > @@ -5892,7 +5907,8 @@ sctp_disposition_t sctp_sf_timer_ignore(struct net *net, > void *arg, > sctp_cmd_seq_t *commands) > { > - SCTP_DEBUG_PRINTK("Timer %d ignored.\n", type.chunk); > + pr_debug("%s: timer %d ignored\n", __func__, type.chunk); > + > return SCTP_DISPOSITION_CONSUME; > } > > @@ -6102,7 +6118,7 @@ static int sctp_eat_data(const struct sctp_association *asoc, > skb_pull(chunk->skb, sizeof(sctp_datahdr_t)); > > tsn = ntohl(data_hdr->tsn); > - SCTP_DEBUG_PRINTK("eat_data: TSN 0x%x.\n", tsn); > + pr_debug("%s: TSN 0x%x\n", __func__, tsn); > > /* ASSERT: Now skb->data is really the user data. */ > > @@ -6179,12 +6195,12 @@ static int sctp_eat_data(const struct sctp_association *asoc, > */ > if (sctp_tsnmap_has_gap(map) && > (sctp_tsnmap_get_ctsn(map) + 1) == tsn) { > - SCTP_DEBUG_PRINTK("Reneging for tsn:%u\n", tsn); > + pr_debug("%s: reneging for tsn:%u\n", __func__, tsn); > deliver = SCTP_CMD_RENEGE; > } else { > - SCTP_DEBUG_PRINTK("Discard tsn: %u len: %Zd, " > - "rwnd: %d\n", tsn, datalen, > - asoc->rwnd); > + pr_debug("%s: discard tsn:%u len:%zu, rwnd:%d\n", > + __func__, tsn, datalen, asoc->rwnd); > + > return SCTP_IERROR_IGNORE_TSN; > } > } > @@ -6199,7 +6215,8 @@ static int sctp_eat_data(const struct sctp_association *asoc, > if (*sk->sk_prot_creator->memory_pressure) { > if (sctp_tsnmap_has_gap(map) && > (sctp_tsnmap_get_ctsn(map) + 1) == tsn) { > - SCTP_DEBUG_PRINTK("Under Pressure! Reneging for tsn:%u\n", tsn); > + pr_debug("%s: under pressure, reneging for tsn:%u\n", > + __func__, tsn); > deliver = SCTP_CMD_RENEGE; > } > } > diff --git a/net/sctp/socket.c b/net/sctp/socket.c > index 66fcdcf..9b1c74a 100644 > --- a/net/sctp/socket.c > +++ b/net/sctp/socket.c > @@ -281,8 +281,8 @@ static int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len) > > sctp_lock_sock(sk); > > - SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, addr: %p, addr_len: %d)\n", > - sk, addr, addr_len); > + pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__, sk, > + addr, addr_len); > > /* Disallow binding twice. */ > if (!sctp_sk(sk)->ep->base.bind_addr.port) > @@ -342,19 +342,15 @@ static int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len) > /* Common sockaddr verification. */ > af = sctp_sockaddr_af(sp, addr, len); > if (!af) { > - SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d) EINVAL\n", > - sk, addr, len); > + pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n", > + __func__, sk, addr, len); > return -EINVAL; > } > > snum = ntohs(addr->v4.sin_port); > > - SCTP_DEBUG_PRINTK_IPADDR("sctp_do_bind(sk: %p, new addr: ", > - ", port: %d, new port: %d, len: %d)\n", > - sk, > - addr, > - bp->port, snum, > - len); > + pr_debug("%s: sk:%p, new addr:%pIg, port:%d, new port:%d, len:%d\n", > + __func__, sk, &addr->sa, bp->port, snum, len); > > /* PF specific bind() address verification. */ > if (!sp->pf->bind_verify(sp, addr)) > @@ -368,9 +364,8 @@ static int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len) > if (!snum) > snum = bp->port; > else if (snum != bp->port) { > - SCTP_DEBUG_PRINTK("sctp_do_bind:" > - " New port %d does not match existing port " > - "%d.\n", snum, bp->port); > + pr_debug("%s: new port %d doesn't match existing port " > + "%d\n", __func__, snum, bp->port); > return -EINVAL; > } > } > @@ -468,8 +463,8 @@ static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt) > struct sockaddr *sa_addr; > struct sctp_af *af; > > - SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n", > - sk, addrs, addrcnt); > + pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__, sk, > + addrs, addrcnt); > > addr_buf = addrs; > for (cnt = 0; cnt < addrcnt; cnt++) { > @@ -535,11 +530,10 @@ static int sctp_send_asconf_add_ip(struct sock *sk, > sp = sctp_sk(sk); > ep = sp->ep; > > - SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n", > - __func__, sk, addrs, addrcnt); > + pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", > + __func__, sk, addrs, addrcnt); > > list_for_each_entry(asoc, &ep->asocs, asocs) { > - > if (!asoc->peer.asconf_capable) > continue; > > @@ -646,8 +640,8 @@ static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt) > union sctp_addr *sa_addr; > struct sctp_af *af; > > - SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n", > - sk, addrs, addrcnt); > + pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", > + __func__, sk, addrs, addrcnt); > > addr_buf = addrs; > for (cnt = 0; cnt < addrcnt; cnt++) { > @@ -740,8 +734,8 @@ static int sctp_send_asconf_del_ip(struct sock *sk, > sp = sctp_sk(sk); > ep = sp->ep; > > - SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n", > - __func__, sk, addrs, addrcnt); > + pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", > + __func__, sk, addrs, addrcnt); > > list_for_each_entry(asoc, &ep->asocs, asocs) { > > @@ -808,9 +802,11 @@ static int sctp_send_asconf_del_ip(struct sock *sk, > sin6 = (struct sockaddr_in6 *)addrs; > asoc->asconf_addr_del_pending->v6.sin6_addr = sin6->sin6_addr; > } > - SCTP_DEBUG_PRINTK_IPADDR("send_asconf_del_ip: keep the last address asoc: %p ", > - " at %p\n", asoc, asoc->asconf_addr_del_pending, > - asoc->asconf_addr_del_pending); > + > + pr_debug("%s: keep the last address asoc:%p %pIg at %p\n", > + __func__, asoc, &asoc->asconf_addr_del_pending->sa, > + asoc->asconf_addr_del_pending); > + > asoc->src_out_of_asoc_ok = 1; > stored = 1; > goto skip_mkasconf; > @@ -972,8 +968,8 @@ static int sctp_setsockopt_bindx(struct sock* sk, > void *addr_buf; > struct sctp_af *af; > > - SCTP_DEBUG_PRINTK("sctp_setsockopt_bindx: sk %p addrs %p" > - " addrs_size %d opt %d\n", sk, addrs, addrs_size, op); > + pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n", > + __func__, sk, addrs, addrs_size, op); > > if (unlikely(addrs_size <= 0)) > return -EINVAL; > @@ -1231,10 +1227,9 @@ static int __sctp_connect(struct sock* sk, > asoc = NULL; > > out_free: > + pr_debug("%s: exiting and free asoc:%p kaddrs:%p err:%d\n", > + __func__, asoc, kaddrs, err); > > - SCTP_DEBUG_PRINTK("About to exit __sctp_connect() free asoc: %p" > - " kaddrs: %p err: %d\n", > - asoc, kaddrs, err); > if (asoc) { > /* sctp_primitive_ASSOCIATE may have added this association > * To the hash table, try to unhash it, just in case, its a noop > @@ -1316,8 +1311,8 @@ static int __sctp_setsockopt_connectx(struct sock* sk, > int err = 0; > struct sockaddr *kaddrs; > > - SCTP_DEBUG_PRINTK("%s - sk %p addrs %p addrs_size %d\n", > - __func__, sk, addrs, addrs_size); > + pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n", > + __func__, sk, addrs, addrs_size); > > if (unlikely(addrs_size <= 0)) > return -EINVAL; > @@ -1468,7 +1463,7 @@ static void sctp_close(struct sock *sk, long timeout) > struct list_head *pos, *temp; > unsigned int data_was_unread; > > - SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk, timeout); > + pr_debug("%s: sk:%p, timeout:%ld\n", __func__, sk, timeout); > > sctp_lock_sock(sk); > sk->sk_shutdown = SHUTDOWN_MASK; > @@ -1594,14 +1589,12 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > struct sctp_datamsg *datamsg; > int msg_flags = msg->msg_flags; > > - SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n", > - sk, msg, msg_len); > - > err = 0; > sp = sctp_sk(sk); > ep = sp->ep; > > - SCTP_DEBUG_PRINTK("Using endpoint: %p.\n", ep); > + pr_debug("%s: sk:%p, msg:%p, msg_len:%zu ep:%p\n", __func__, sk, > + msg, msg_len, ep); > > /* We cannot send a message over a TCP-style listening socket. */ > if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) { > @@ -1611,9 +1604,8 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > > /* Parse out the SCTP CMSGs. */ > err = sctp_msghdr_parse(msg, &cmsgs); > - > if (err) { > - SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err); > + pr_debug("msghdr parse err = %x\n", err); > goto out_nounlock; > } > > @@ -1645,8 +1637,8 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > associd = sinfo->sinfo_assoc_id; > } > > - SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n", > - msg_len, sinfo_flags); > + pr_debug("%s: msg_len:%zu, sinfo_flags:0x%x\n", __func__, > + msg_len, sinfo_flags); > > /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */ > if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF | SCTP_ABORT))) { > @@ -1675,7 +1667,7 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > > transport = NULL; > > - SCTP_DEBUG_PRINTK("About to look up association.\n"); > + pr_debug("%s: about to look up association.\n", __func__); > > sctp_lock_sock(sk); > > @@ -1705,7 +1697,7 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > } > > if (asoc) { > - SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc); > + pr_debug("%s: just looked up association:%p.\n", __func__, asoc); > > /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED > * socket that has an association in CLOSED state. This can > @@ -1718,8 +1710,9 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > } > > if (sinfo_flags & SCTP_EOF) { > - SCTP_DEBUG_PRINTK("Shutting down association: %p\n", > - asoc); > + pr_debug("%s: shutting down association:%p\n", > + __func__, asoc); > + > sctp_primitive_SHUTDOWN(net, asoc, NULL); > err = 0; > goto out_unlock; > @@ -1732,7 +1725,9 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > goto out_unlock; > } > > - SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc); > + pr_debug("%s: aborting association:%p\n", > + __func__, asoc); > + > sctp_primitive_ABORT(net, asoc, chunk); > err = 0; > goto out_unlock; > @@ -1741,7 +1736,7 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > > /* Do we need to create the association? */ > if (!asoc) { > - SCTP_DEBUG_PRINTK("There is no association yet.\n"); > + pr_debug("%s: there is no association yet\n", __func__); > > if (sinfo_flags & (SCTP_EOF | SCTP_ABORT)) { > err = -EINVAL; > @@ -1840,7 +1835,7 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > } > > /* ASSERT: we have a valid association at this point. */ > - SCTP_DEBUG_PRINTK("We have a valid association.\n"); > + pr_debug("%s: we have a valid association\n", __func__); > > if (!sinfo) { > /* If the user didn't specify SNDRCVINFO, make up one with > @@ -1909,7 +1904,8 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > err = sctp_primitive_ASSOCIATE(net, asoc, NULL); > if (err < 0) > goto out_free; > - SCTP_DEBUG_PRINTK("We associated primitively.\n"); > + > + pr_debug("%s: we associated primitively\n", __func__); > } > > /* Break the message into multiple chunks of maximum size. */ > @@ -1936,17 +1932,15 @@ static int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, > */ > err = sctp_primitive_SEND(net, asoc, datamsg); > /* Did the lower layer accept the chunk? */ > - if (err) > + if (err) { > sctp_datamsg_free(datamsg); > - else > - sctp_datamsg_put(datamsg); > + goto out_free; > + } > > - SCTP_DEBUG_PRINTK("We sent primitively.\n"); > + pr_debug("%s: we sent primitively\n", __func__); > > - if (err) > - goto out_free; > - else > - err = msg_len; > + sctp_datamsg_put(datamsg); > + err = msg_len; Doesn't strictly belong in this patch although I see how this makes for better code. > > /* If we are already past ASSOCIATE, the lower > * layers are responsible for association cleanup. > @@ -2041,10 +2035,9 @@ static int sctp_recvmsg(struct kiocb *iocb, struct sock *sk, > int err = 0; > int skb_len; > > - SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: " > - "0x%x, %s: %p)\n", "sk", sk, "msghdr", msg, > - "len", len, "knoblauch", noblock, > - "flags", flags, "addr_len", addr_len); > + pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, " > + "addr_len:%p)\n", __func__, sk, msg, len, noblock, flags, > + addr_len); > > sctp_lock_sock(sk); > > @@ -3086,7 +3079,7 @@ static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optva > > err = sctp_send_asconf(asoc, chunk); > > - SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n"); > + pr_debug("%s: we set peer primary addr primitively\n", __func__); > > return err; > } > @@ -3561,8 +3554,7 @@ static int sctp_setsockopt(struct sock *sk, int level, int optname, > { > int retval = 0; > > - SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n", > - sk, optname); > + pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname); > > /* I can hardly begin to describe how wrong this is. This is > * so broken as to be worse than useless. The API draft > @@ -3724,8 +3716,8 @@ static int sctp_connect(struct sock *sk, struct sockaddr *addr, > > sctp_lock_sock(sk); > > - SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d\n", > - __func__, sk, addr, addr_len); > + pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__, sk, > + addr, addr_len); > > /* Validate addr_len before calling common connect/connectx routine. */ > af = sctp_get_af_specific(addr->sa_family); > @@ -3855,7 +3847,7 @@ static int sctp_init_sock(struct sock *sk) > struct net *net = sock_net(sk); > struct sctp_sock *sp; > > - SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk); > + pr_debug("%s: sk:%p\n", __func__, sk); > > sp = sctp_sk(sk); > > @@ -3990,7 +3982,7 @@ static void sctp_destroy_sock(struct sock *sk) > { > struct sctp_sock *sp; > > - SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk); > + pr_debug("%s: sk:%p\n", __func__, sk); > > /* Release our hold on the endpoint. */ > sp = sctp_sk(sk); > @@ -4123,9 +4115,9 @@ static int sctp_getsockopt_sctp_status(struct sock *sk, int len, > goto out; > } > > - SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n", > - len, status.sstat_state, status.sstat_rwnd, > - status.sstat_assoc_id); > + pr_debug("%s: len:%d state:%d rwnd:%d assoc_id:%d\n", > + __func__, len, status.sstat_state, status.sstat_rwnd, > + status.sstat_assoc_id); > > if (copy_to_user(optval, &status, len)) { > retval = -EFAULT; > @@ -4333,8 +4325,8 @@ static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval > return PTR_ERR(newfile); > } > > - SCTP_DEBUG_PRINTK("%s: sk: %p newsk: %p sd: %d\n", > - __func__, sk, newsock->sk, retval); > + pr_debug("%s: sk:%p newsk:%p sd:%d\n", __func__, sk, newsock->sk, > + retval); > > /* Return the fd mapped to the new socket. */ > if (put_user(len, optlen)) { > @@ -4467,7 +4459,7 @@ static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len, > trans = sctp_addr_id2transport(sk, ¶ms.spp_address, > params.spp_assoc_id); > if (!trans) { > - SCTP_DEBUG_PRINTK("Failed no transport\n"); > + pr_debug("%s: failed no transport\n", __func__); > return -EINVAL; > } > } > @@ -4478,7 +4470,7 @@ static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len, > */ > asoc = sctp_id2assoc(sk, params.spp_assoc_id); > if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) { > - SCTP_DEBUG_PRINTK("Failed no association\n"); > + pr_debug("%s: failed no association\n", __func__); > return -EINVAL; > } > > @@ -5698,8 +5690,7 @@ static int sctp_getsockopt_assoc_stats(struct sock *sk, int len, > if (put_user(len, optlen)) > return -EFAULT; > > - SCTP_DEBUG_PRINTK("sctp_getsockopt_assoc_stat(%d): %d\n", > - len, sas.sas_assoc_id); > + pr_debug("%s: len:%d assoc_id:%d\n", __func__, len, sas.sas_assoc_id); > > if (copy_to_user(optval, &sas, len)) > return -EFAULT; > @@ -5713,8 +5704,7 @@ static int sctp_getsockopt(struct sock *sk, int level, int optname, > int retval = 0; > int len; > > - SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p... optname: %d)\n", > - sk, optname); > + pr_debug("%s: sk:%p optname:%d\n", __func__, sk, optname); > > /* I can hardly begin to describe how wrong this is. This is > * so broken as to be worse than useless. The API draft > @@ -5894,7 +5884,8 @@ static long sctp_get_port_local(struct sock *sk, union sctp_addr *addr) > > snum = ntohs(addr->v4.sin_port); > > - SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum); > + pr_debug("%s: begins, snum:%d\n", __func__, snum); > + > sctp_local_bh_disable(); > > if (snum == 0) { > @@ -5960,7 +5951,8 @@ pp_found: > int reuse = sk->sk_reuse; > struct sock *sk2; > > - SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n"); > + pr_debug("%s: found a possible match\n", __func__); > + > if (pp->fastreuse && sk->sk_reuse && > sk->sk_state != SCTP_SS_LISTENING) > goto success; > @@ -5990,7 +5982,8 @@ pp_found: > goto fail_unlock; > } > } > - SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n"); > + > + pr_debug("%s: found a match\n", __func__); > } > pp_not_found: > /* If there was a hash table miss, create a new port. */ > @@ -6479,8 +6472,8 @@ static struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags, > > timeo = sock_rcvtimeo(sk, noblock); > > - SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n", > - timeo, MAX_SCHEDULE_TIMEOUT); > + pr_debug("%s: timeo:%ld, max:%ld\n", __func__, timeo, > + MAX_SCHEDULE_TIMEOUT); > > do { > /* Again only user level code calls this function, > @@ -6611,8 +6604,8 @@ static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p, > long current_timeo = *timeo_p; > DEFINE_WAIT(wait); > > - SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n", > - asoc, (long)(*timeo_p), msg_len); > + pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__, asoc, > + *timeo_p, msg_len); > > /* Increment the association's refcnt. */ > sctp_association_hold(asoc); > @@ -6718,8 +6711,7 @@ static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p) > long current_timeo = *timeo_p; > DEFINE_WAIT(wait); > > - SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __func__, asoc, > - (long)(*timeo_p)); > + pr_debug("%s: asoc:%p, timeo:%ld\n", __func__, asoc, *timeo_p); > > /* Increment the association's refcnt. */ > sctp_association_hold(asoc); > diff --git a/net/sctp/transport.c b/net/sctp/transport.c > index 5d3c71b..0c564ac 100644 > --- a/net/sctp/transport.c > +++ b/net/sctp/transport.c > @@ -176,7 +176,10 @@ static void sctp_transport_destroy_rcu(struct rcu_head *head) > */ > static void sctp_transport_destroy(struct sctp_transport *transport) > { > - SCTP_ASSERT(transport->dead, "Transport is not dead", return); > + if (unlikely(!transport->dead)) { > + WARN(1, "Attempt to destroy undead transport %p!\n", transport); > + return; > + } > > call_rcu(&transport->rcu, sctp_transport_destroy_rcu); > > @@ -317,11 +320,13 @@ void sctp_transport_put(struct sctp_transport *transport) > /* Update transport's RTO based on the newly calculated RTT. */ > void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt) > { > - /* Check for valid transport. */ > - SCTP_ASSERT(tp, "NULL transport", return); > + BUG_ON(tp == NULL); > > - /* We should not be doing any RTO updates unless rto_pending is set. */ > - SCTP_ASSERT(tp->rto_pending, "rto_pending not set", return); > + if (unlikely(!tp->rto_pending)) { > + /* We should not be doing any RTO updates unless rto_pending is set. */ > + WARN(1, "rto_pending not set on transport %p!\n", tp); > + return; > + } > > if (tp->rttvar || tp->srtt) { > struct net *net = sock_net(tp->asoc->base.sk); > @@ -377,9 +382,8 @@ void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt) > */ > tp->rto_pending = 0; > > - SCTP_DEBUG_PRINTK("%s: transport: %p, rtt: %d, srtt: %d " > - "rttvar: %d, rto: %ld\n", __func__, > - tp, rtt, tp->srtt, tp->rttvar, tp->rto); > + pr_debug("%s: transport:%p, rtt:%d, srtt:%d rttvar:%d, rto:%ld\n", > + __func__, tp, rtt, tp->srtt, tp->rttvar, tp->rto); > } > > /* This routine updates the transport's cwnd and partial_bytes_acked > @@ -433,12 +437,11 @@ void sctp_transport_raise_cwnd(struct sctp_transport *transport, > cwnd += pmtu; > else > cwnd += bytes_acked; > - SCTP_DEBUG_PRINTK("%s: SLOW START: transport: %p, " > - "bytes_acked: %d, cwnd: %d, ssthresh: %d, " > - "flight_size: %d, pba: %d\n", > - __func__, > - transport, bytes_acked, cwnd, > - ssthresh, flight_size, pba); > + > + pr_debug("%s: slow start: transport:%p, bytes_acked:%d, " > + "cwnd:%d, ssthresh:%d, flight_size:%d, pba:%d\n", > + __func__, transport, bytes_acked, cwnd, ssthresh, > + flight_size, pba); > } else { > /* RFC 2960 7.2.2 Whenever cwnd is greater than ssthresh, > * upon each SACK arrival that advances the Cumulative TSN Ack > @@ -459,12 +462,12 @@ void sctp_transport_raise_cwnd(struct sctp_transport *transport, > cwnd += pmtu; > pba = ((cwnd < pba) ? (pba - cwnd) : 0); > } > - SCTP_DEBUG_PRINTK("%s: CONGESTION AVOIDANCE: " > - "transport: %p, bytes_acked: %d, cwnd: %d, " > - "ssthresh: %d, flight_size: %d, pba: %d\n", > - __func__, > - transport, bytes_acked, cwnd, > - ssthresh, flight_size, pba); > + > + pr_debug("%s: congestion avoidance: transport:%p, " > + "bytes_acked:%d, cwnd:%d, ssthresh:%d, " > + "flight_size:%d, pba:%d\n", __func__, > + transport, bytes_acked, cwnd, ssthresh, > + flight_size, pba); > } > > transport->cwnd = cwnd; > @@ -558,10 +561,10 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport, > } > > transport->partial_bytes_acked = 0; > - SCTP_DEBUG_PRINTK("%s: transport: %p reason: %d cwnd: " > - "%d ssthresh: %d\n", __func__, > - transport, reason, > - transport->cwnd, transport->ssthresh); > + > + pr_debug("%s: transport:%p reason:%d cwnd:%d ssthresh:%d\n", > + __func__, transport, reason, transport->cwnd, > + transport->ssthresh); > } > > /* Apply Max.Burst limit to the congestion window: >