 @@ -1,14 +1,14 @@
-/*	$NetBSD: uipc_mbuf.c,v 1.182 2018/03/09 11:57:38 maxv Exp $	*/
+/*	$NetBSD: uipc_mbuf.c,v 1.183 2018/03/21 16:26:04 maxv Exp $	*/
 /*
  * Copyright (c) 1999, 2001 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -52,27 +52,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)uipc_mbuf.c	8.4 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uipc_mbuf.c,v 1.182 2018/03/09 11:57:38 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uipc_mbuf.c,v 1.183 2018/03/21 16:26:04 maxv Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_mbuftrace.h"
 #include "opt_nmbclusters.h"
 #include "opt_ddb.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/atomic.h>
 #include <sys/cpu.h>
 #include <sys/proc.h>
 #include <sys/mbuf.h>
 @@ -697,28 +697,26 @@ m_prepend(struct mbuf *m, int len, int h
 		if (len < MLEN)
 			M_ALIGN(m, len);
+	}
 	m->m_len = len;
 	return m;
+}
 /*
  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
  * The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller.
  */
 int MCFail;
 struct mbuf *
 m_copym(struct mbuf *m, int off0, int len, int wait)
+{
 	return m_copym0(m, off0, len, wait, false); /* shallow copy on M_EXT */
+}
 struct mbuf *
 m_dup(struct mbuf *m, int off0, int len, int wait)
+{
 	return m_copym0(m, off0, len, wait, true); /* deep copy */
+}
 @@ -802,34 +800,30 @@ m_copym0(struct mbuf *m, int off0, int l
 			len -= n->m_len;
 		off += n->m_len;
 #ifdef DIAGNOSTIC
 		if (off > m->m_len)
 			panic("m_copym0 overrun %d %d", off, m->m_len);
 #endif
 		if (off == m->m_len) {
 			m = m->m_next;
 			off = 0;
+		}
 		np = &n->m_next;
+	}
 	if (top == NULL)
 		MCFail++;
 	return top;
 nospace:
 	m_freem(top);
 	MCFail++;
 	return NULL;
+}
 /*
  * Copy an entire packet, including header (which must be present).
  * An optimization of the common case 'm_copym(m, 0, M_COPYALL, how)'.
  */
 struct mbuf *
 m_copypacket(struct mbuf *m, int how)
+{
 	struct mbuf *top, *n, *o;
 	n = m_get(how, m->m_type);
 @@ -861,27 +855,26 @@ m_copypacket(struct mbuf *m, int how)
 		if (m->m_flags & M_EXT) {
 			n->m_data = m->m_data;
 			MCLADDREFERENCE(m, n);
 		} else {
 			memcpy(mtod(n, char *), mtod(m, char *), n->m_len);
+		}
 		m = m->m_next;
+	}
 	return top;
 nospace:
 	m_freem(top);
 	MCFail++;
 	return NULL;
+}
 /*
  * Copy data from an mbuf chain starting "off" bytes from the beginning,
  * continuing for "len" bytes, into the indicated buffer.
  */
 void
 m_copydata(struct mbuf *m, int off, int len, void *vp)
+{
 	unsigned count;
 	void *cp = vp;
 	struct mbuf *m0 = m;
 @@ -1072,50 +1065,45 @@ m_ensure_contig(struct mbuf **m0, int le
 		else
 			n = m_free(n);
 	} while (len > 0 && n);
 	m->m_next = n;
 	*m0 = m;
 	return len <= 0;
+}
 /*
  * m_pullup: same as m_ensure_contig(), but destroys mbuf chain on error.
  */
 int MPFail;
 struct mbuf *
 m_pullup(struct mbuf *n, int len)
+{
 	struct mbuf *m = n;
 	KASSERT(len != M_COPYALL);
 	if (!m_ensure_contig(&m, len)) {
 		KASSERT(m != NULL);
 		m_freem(m);
 		MPFail++;
 		m = NULL;
+	}
 	return m;
+}
 /*
  * Like m_pullup(), except a new mbuf is always allocated, and we allow
  * the amount of empty space before the data in the new mbuf to be specified
  * (in the event that the caller expects to prepend later).
  */
 int MSFail;
 struct mbuf *
 m_copyup(struct mbuf *n, int len, int dstoff)
+{
 	struct mbuf *m;
 	int count, space;
 	KASSERT(len != M_COPYALL);
 	if (len > (MHLEN - dstoff))
 		goto bad;
 	m = m_get(M_DONTWAIT, n->m_type);
 	if (m == NULL)
 		goto bad;
 	MCLAIM(m, n->m_owner);
 @@ -1135,27 +1123,26 @@ m_copyup(struct mbuf *n, int len, int ds
 		if (n->m_len)
 			n->m_data += count;
 		else
 			n = m_free(n);
 	} while (len > 0 && n);
 	if (len > 0) {
 		(void) m_free(m);
 		goto bad;
+	}
 	m->m_next = n;
 	return (m);
  bad:
 	m_freem(n);
 	MSFail++;
 	return (NULL);
+}
 /*
  * Partition an mbuf chain in two pieces, returning the tail --
  * all but the first len0 bytes.  In case of failure, it returns NULL and
  * attempts to restore the chain to its original state.
  */
 struct mbuf *
 m_split(struct mbuf *m0, int len0, int wait)
+{
 	return m_split0(m0, len0, wait, true);