 @@ -1,14 +1,14 @@
-/*	$NetBSD: key.c,v 1.222 2017/08/09 08:30:54 ozaki-r Exp $	*/
+/*	$NetBSD: key.c,v 1.223 2017/08/09 09:48:11 ozaki-r Exp $	*/
 /*	$FreeBSD: src/sys/netipsec/key.c,v 1.3.2.3 2004/02/14 22:23:23 bms Exp $	*/
 /*	$KAME: key.c,v 1.191 2001/06/27 10:46:49 sakane Exp $	*/
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  * All rights reserved.
+ *
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -22,27 +22,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: key.c,v 1.222 2017/08/09 08:30:54 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: key.c,v 1.223 2017/08/09 09:48:11 ozaki-r Exp $");
 /*
  * This code is referd to RFC 2367
  */
 #if defined(_KERNEL_OPT)
 #include "opt_inet.h"
 #include "opt_ipsec.h"
 #include "opt_gateway.h"
 #include "opt_net_mpsafe.h"
 #endif
 #include <sys/types.h>
 @@ -192,42 +192,54 @@ static u_int32_t acq_seq = 0;
  *     setsockopt(IP_IPSEC_POLICY)
  *   - Such policies (SPs) are set to a socket (PCB) and also inserted to
  *     the key_spd.socksplist list (not the key_spd.splist)
  *   - Such a policy is destroyed when a corresponding socket is destroed,
  *     however, a socket can be destroyed in softint so we cannot destroy
  *     it directly instead we just mark it DEAD and delay the destruction
  *     until GC by the timer
  */
 /*
  * Locking notes on SAD:
  * - Data structures
  *   - SAs are managed by the list called key_sad.sahlist and sav lists of sah
  *     entries
  *     - An sav is supposed to be an SA from a viewpoint of users
  *   - A sah has sav lists for each SA state
  *   - Multiple sahs with the same saidx can exist
  *     - Only one entry has MATURE state and others should be DEAD
  *     - DEAD entries are just ignored from searching
- * - Modifications to the key_sad.sahlist must be done with holding key_sad.lock
+ * - Modifications to the key_sad.sahlist and sah.savlist must be done with
- *   which is a adaptive mutex
+ *   holding key_sad.lock which is a adaptive mutex
- * - Read accesses to the key_sad.sahlist must be in pserialize(9) read sections
+ * - Read accesses to the key_sad.sahlist and sah.savlist must be in
  *   pserialize(9) read sections
  * - sah's lifetime is managed by localcount(9)
  * - Getting an sah entry
  *   - We get an sah from the key_sad.sahlist
  *     - Must iterate the list and increment the reference count of a found sah
  *       (by key_sah_ref) in a pserialize read section
  *   - A gotten sah must be released after use by key_sah_unref
  * - An sah is destroyed when its state become DEAD and no sav is
  *   listed to the sah
  *   - The destruction is done only in the timer (see key_timehandler_sad)
  * - sav's lifetime is managed by localcount(9)
  * - Getting an sav entry
  *   - First get an sah by saidx and get an sav from either of sah's savlists
  *     - Must iterate the list and increment the reference count of a found sav
  *       (by key_sa_ref) in a pserialize read section
  *   - We can gain another reference from a held SA only if we check its state
  *     and take its reference in a pserialize read section
  *     (see esp_output for example)
  *   - A gotten sav must be released after use by key_sa_unref
  * - An sav is destroyed when its state become DEAD
  */
 /*
  * Locking notes on misc data:
  * - All lists of key_misc are protected by key_misc.lock
  *   - key_misc.lock must be held even for read accesses
  */
 static pserialize_t key_spd_psz __read_mostly;
 static pserialize_t key_sad_psz __read_mostly;
 /* SPD */
 static struct {
 	kmutex_t lock;
 @@ -633,26 +645,29 @@ static struct mbuf * key_setspddump (int
 static struct mbuf * key_setspddump_chain (int *errorp, int *lenp, pid_t pid);
 static int key_api_nat_map(struct socket *, struct mbuf *,
 	const struct sadb_msghdr *);
 static struct mbuf *key_setdumpsp (struct secpolicy *,
 	u_int8_t, u_int32_t, pid_t);
 static u_int key_getspreqmsglen (const struct secpolicy *);
 static int key_spdexpire (struct secpolicy *);
 static struct secashead *key_newsah (const struct secasindex *);
 static void key_unlink_sah(struct secashead *);
 static void key_destroy_sah(struct secashead *);
 static bool key_sah_has_sav(struct secashead *);
 static void key_sah_ref(struct secashead *);
 static void key_sah_unref(struct secashead *);
 static void key_init_sav(struct secasvar *);
 static void key_destroy_sav(struct secasvar *);
 static void key_destroy_sav_with_ref(struct secasvar *);
 static struct secasvar *key_newsav(struct mbuf *,
 	const struct sadb_msghdr *, int *, const char*, int);
 #define	KEY_NEWSAV(m, sadb, e)				\
 	key_newsav(m, sadb, e, __func__, __LINE__)
 static void key_delsav (struct secasvar *);
 static struct secashead *key_getsah(const struct secasindex *, int);
 static struct secashead *key_getsah_ref(const struct secasindex *, int);
 static bool key_checkspidup(const struct secasindex *, u_int32_t);
 static struct secasvar *key_getsavbyspi (struct secashead *, u_int32_t);
 static int key_setsaval (struct secasvar *, struct mbuf *,
 	const struct sadb_msghdr *);
 static void key_freesaval(struct secasvar *);
 static int key_init_xform(struct secasvar *);
 @@ -766,55 +781,26 @@ static int key_align (struct mbuf *, str
 static const char *key_getfqdn (void);
 static const char *key_getuserfqdn (void);
 #endif
 static void key_sa_chgstate (struct secasvar *, u_int8_t);
 static struct mbuf *key_alloc_mbuf (int);
 static void key_timehandler(void *);
 static void key_timehandler_work(struct work *, void *);
 static struct callout	key_timehandler_ch;
 static struct workqueue	*key_timehandler_wq;
 static struct work	key_timehandler_wk;
 #ifdef IPSEC_REF_DEBUG
 #define REFLOG(label, p, where, tag)					\
 	log(LOG_DEBUG, "%s:%d: " label " : refcnt=%d (%p)\n.",		\
 	    (where), (tag), (p)->refcnt, (p))
 #else
 #define REFLOG(label, p, where, tag)	do {} while (0)
 #endif
 #define	SA_ADDREF(p) do {						\
 	atomic_inc_uint(&(p)->refcnt);					\
 	REFLOG("SA_ADDREF", (p), __func__, __LINE__);			\
 	KASSERTMSG((p)->refcnt != 0, "SA refcnt overflow");		\
 } while (0)
 #define	SA_ADDREF2(p, where, tag) do {					\
 	atomic_inc_uint(&(p)->refcnt);					\
 	REFLOG("SA_ADDREF", (p), (where), (tag));			\
 	KASSERTMSG((p)->refcnt != 0, "SA refcnt overflow");		\
 } while (0)
 #define	SA_DELREF(p) do {						\
 	KASSERTMSG((p)->refcnt > 0, "SA refcnt underflow");		\
 	atomic_dec_uint(&(p)->refcnt);					\
 	REFLOG("SA_DELREF", (p), __func__, __LINE__);			\
 } while (0)
 #define	SA_DELREF2(p, nv, where, tag) do {				\
 	KASSERTMSG((p)->refcnt > 0, "SA refcnt underflow");		\
 	nv = atomic_dec_uint_nv(&(p)->refcnt);				\
 	REFLOG("SA_DELREF", (p), (where), (tag));			\
 } while (0)
 u_int
 key_sp_refcnt(const struct secpolicy *sp)
+{
 	/* FIXME */
 	return 0;
+}
 /*
  * Remove the sp from the key_spd.splist and wait for references to the sp
  * to be released. key_spd.lock must be held.
  */
 static void
 @@ -1075,27 +1061,27 @@ key_lookup_sa_bysaidx(const struct secas
 		state = saorder_state_valid[stateidx];
 		if (key_prefered_oldsa)
 			sav = SAVLIST_READER_FIRST(sah, state);
 		else {
 			/* XXX need O(1) lookup */
 			struct secasvar *last = NULL;
 			SAVLIST_READER_FOREACH(sav, sah, state)
 				last = sav;
 			sav = last;
+		}
 		if (sav != NULL) {
-			SA_ADDREF(sav);
+			KEY_SA_REF(sav);
 			KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
 			    "DP cause refcnt++:%d SA:%p\n",
 			    key_sa_refcnt(sav), sav);
 			break;
+		}
+	}
 out:
 	pserialize_read_exit(s);
 	return sav;
+}
 #if 0
 @@ -1274,27 +1260,27 @@ key_lookup_sa(
 #if 0	/* don't check src */
 	/* Fix port in src->sa */
 				/* check src address */
 				if (!key_sockaddr_match(&src->sa, &sav->sah->saidx.src.sa, PORT_NONE))
 					continue;
 #endif
 				/* fix port of dst address XXX*/
 				key_porttosaddr(__UNCONST(dst), dport);
 				/* check dst address */
 				if (!key_sockaddr_match(&dst->sa, &sav->sah->saidx.dst.sa, chkport))
 					continue;
-				SA_ADDREF2(sav, where, tag);
+				key_sa_ref(sav, where, tag);
 				goto done;
+			}
+		}
+	}
 	sav = NULL;
 done:
 	pserialize_read_exit(s);
 	KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
 	    "DP return SA:%p; refcnt %u\n", sav, key_sa_refcnt(sav));
 	return sav;
+}
 @@ -1361,45 +1347,66 @@ key_sp_ref(struct secpolicy *sp, const c
 void
 key_sp_unref(struct secpolicy *sp, const char* where, int tag)
+{
 	KDASSERT(mutex_ownable(&key_spd.lock));
 	KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
 	    "DP SP:%p (ID=%u) from %s:%u; refcnt-- now %u\n",
 	    sp, sp->id, where, tag, key_sp_refcnt(sp));
 	localcount_release(&sp->localcount, &key_spd.cv, &key_spd.lock);
+}
 static void
 key_init_sav(struct secasvar *sav)
+{
 	ASSERT_SLEEPABLE();
 	localcount_init(&sav->localcount);
 	SAVLIST_ENTRY_INIT(sav);
+}
 u_int
 key_sa_refcnt(const struct secasvar *sav)
+{
-	if (sav == NULL)
+	/* FIXME */
-		return 0;
+	return 0;
 	return sav->refcnt;
+}
 void
 key_sa_ref(struct secasvar *sav, const char* where, int tag)
+{
-	SA_ADDREF2(sav, where, tag);
+	localcount_acquire(&sav->localcount);
 	KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
-	    "DP cause refcnt++:%d SA:%p from %s:%u\n",
+	    "DP cause refcnt++: SA:%p from %s:%u\n",
-	    sav->refcnt, sav, where, tag);
+	    sav, where, tag);
+}
 void
 key_sa_unref(struct secasvar *sav, const char* where, int tag)
+{
 	KDASSERT(mutex_ownable(&key_sad.lock));
 	KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
 	    "DP cause refcnt--: SA:%p from %s:%u\n",
 	    sav, where, tag);
 	localcount_release(&sav->localcount, &key_sad.cv, &key_sad.lock);
+}
 #if 0
 /*
  * Must be called after calling key_lookup_sp*().
  * For the packet with socket.
  */
 static void
 key_freeso(struct socket *so)
+{
 	/* sanity check */
 	KASSERT(so != NULL);
 @@ -1458,52 +1465,87 @@ key_freesp_so(struct secpolicy **sp)
 	KASSERT(*sp != NULL);
 	if ((*sp)->policy == IPSEC_POLICY_ENTRUST ||
 	    (*sp)->policy == IPSEC_POLICY_BYPASS)
 		return;
 	KASSERTMSG((*sp)->policy == IPSEC_POLICY_IPSEC,
 	    "invalid policy %u", (*sp)->policy);
 	KEY_SP_UNREF(&sp);
+}
 #endif
 /*
- * Must be called after calling key_lookup_sa().
+ * Remove the sav from the savlist of its sah and wait for references to the sav
- * This function is called by key_freesp() to free some SA allocated
+ * to be released. key_sad.lock must be held.
  * for a policy.
  */
-void
+static void
-key_freesav(struct secasvar **psav, const char* where, int tag)
+key_unlink_sav(struct secasvar *sav)
+{
 	struct secasvar *sav = *psav;
 	unsigned int nv;
-	KASSERT(sav != NULL);
+	KASSERT(mutex_owned(&key_sad.lock));
-	SA_DELREF2(sav, nv, where, tag);
+	SAVLIST_WRITER_REMOVE(sav);
-	KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
+#ifdef NET_MPSAFE
-	    "DP SA:%p (SPI %lu) from %s:%u; refcnt now %u\n",
+	KASSERT(mutex_ownable(softnet_lock));
-	    sav, (u_long)ntohl(sav->spi), where, tag, nv);
+	pserialize_perform(key_sad_psz);
 #endif
-	if (nv == 0) {
+	localcount_drain(&sav->localcount, &key_sad.cv, &key_sad.lock);
 		*psav = NULL;
-		/* remove from SA header */
+/*
-		SAVLIST_WRITER_REMOVE(sav);
+ * Destroy an sav where the sav must be unlinked from an sah
  * by say key_unlink_sav.
  */
 static void
 key_destroy_sav(struct secasvar *sav)
+{
-		key_delsav(sav);
+	ASSERT_SLEEPABLE();
 	localcount_fini(&sav->localcount);
 	SAVLIST_ENTRY_DESTROY(sav);
 	key_delsav(sav);
+}
 /*
  * Destroy sav with holding its reference.
  */
 static void
 key_destroy_sav_with_ref(struct secasvar *sav)
+{
 	ASSERT_SLEEPABLE();
 	mutex_enter(&key_sad.lock);
 	sav->state = SADB_SASTATE_DEAD;
 	SAVLIST_WRITER_REMOVE(sav);
 	mutex_exit(&key_sad.lock);
 	/* We cannot unref with holding key_sad.lock */
 	KEY_SA_UNREF(&sav);
 	mutex_enter(&key_sad.lock);
 #ifdef NET_MPSAFE
 	KASSERT(mutex_ownable(softnet_lock));
 	pserialize_perform(key_sad_psz);
 #endif
 	localcount_drain(&sav->localcount, &key_sad.cv, &key_sad.lock);
 	mutex_exit(&key_sad.lock);
 	key_destroy_sav(sav);
+}
 /* %%% SPD management */
 /*
  * free security policy entry.
  */
 static void
 key_destroy_sp(struct secpolicy *sp)
+{
 	SPLIST_ENTRY_DESTROY(sp);
 	localcount_fini(&sp->localcount);
 @@ -3163,35 +3205,29 @@ key_clear_xform(struct secasvar *sav)
 		if (sav->key_enc != NULL)
 			explicit_memset(_KEYBUF(sav->key_enc), 0,
 			    _KEYLEN(sav->key_enc));
+	}
+}
 /*
  * free() SA variable entry.
  */
 static void
 key_delsav(struct secasvar *sav)
+{
 	KASSERT(sav != NULL);
 	KASSERTMSG(sav->refcnt == 0, "reference count %u > 0", sav->refcnt);
 	key_clear_xform(sav);
 	key_freesaval(sav);
-	SAVLIST_ENTRY_DESTROY(sav);
+	kmem_free(sav, sizeof(*sav));
 	kmem_intr_free(sav, sizeof(*sav));
 	return;
+}
 /*
  * Must be called in a pserialize read section. A held sah
  * must be released by key_sah_unref after use.
  */
 static void
 key_sah_ref(struct secashead *sah)
+{
 	localcount_acquire(&sah->localcount);
+}
 @@ -3305,27 +3341,27 @@ key_getsavbyspi(struct secashead *sah, u
 	/* search all status */
 	s = pserialize_read_enter();
 	SASTATE_ALIVE_FOREACH(state) {
 		SAVLIST_READER_FOREACH(sav, sah, state) {
 			/* sanity check */
 			if (sav->state != state) {
 				IPSECLOG(LOG_DEBUG,
 				    "invalid sav->state (queue: %d SA: %d)\n",
 				    state, sav->state);
 				continue;
+			}
 			if (sav->spi == spi) {
-				SA_ADDREF(sav);
+				KEY_SA_REF(sav);
 				goto out;
+			}
+		}
+	}
 out:
 	pserialize_read_exit(s);
 	return sav;
+}
 /*
  * Free allocated data to member variables of sav:
  * sav->replay, sav->key_* and sav->lft_*.
 @@ -4708,91 +4744,99 @@ restart:
 			goto restart;
+		}
+	}
 	mutex_exit(&key_sad.lock);
 	s = pserialize_read_enter();
 	SAHLIST_READER_FOREACH(sah) {
 		struct secasvar *sav;
 		key_sah_ref(sah);
 		pserialize_read_exit(s);
 		/* if LARVAL entry doesn't become MATURE, delete it. */
 		mutex_enter(&key_sad.lock);
 	restart_sav_LARVAL:
-		SAVLIST_READER_FOREACH(sav, sah, SADB_SASTATE_LARVAL) {
+		SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_LARVAL) {
 			if (now - sav->created > key_larval_lifetime) {
 				key_sa_chgstate(sav, SADB_SASTATE_DEAD);
 				goto restart_sav_LARVAL;
+			}
+		}
 		mutex_exit(&key_sad.lock);
 		/*
 		 * check MATURE entry to start to send expire message
 		 * whether or not.
 		 */
 	restart_sav_MATURE:
-		SAVLIST_READER_FOREACH(sav, sah, SADB_SASTATE_MATURE) {
+		mutex_enter(&key_sad.lock);
 		SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_MATURE) {
 			/* we don't need to check. */
 			if (sav->lft_s == NULL)
 				continue;
 			/* sanity check */
 			KASSERT(sav->lft_c != NULL);
 			/* check SOFT lifetime */
 			if (sav->lft_s->sadb_lifetime_addtime != 0 &&
 			    now - sav->created > sav->lft_s->sadb_lifetime_addtime) {
 				/*
 				 * check SA to be used whether or not.
 				 * when SA hasn't been used, delete it.
 				 */
 				if (sav->lft_c->sadb_lifetime_usetime == 0) {
 					key_sa_chgstate(sav, SADB_SASTATE_DEAD);
 					mutex_exit(&key_sad.lock);
 				} else {
 					key_sa_chgstate(sav, SADB_SASTATE_DYING);
 					mutex_exit(&key_sad.lock);
 					/*
 					 * XXX If we keep to send expire
 					 * message in the status of
 					 * DYING. Do remove below code.
 					 */
 					key_expire(sav);
+				}
 				goto restart_sav_MATURE;
+			}
 			/* check SOFT lifetime by bytes */
 			/*
 			 * XXX I don't know the way to delete this SA
 			 * when new SA is installed.  Caution when it's
 			 * installed too big lifetime by time.
 			 */
 			else if (sav->lft_s->sadb_lifetime_bytes != 0 &&
 			         sav->lft_s->sadb_lifetime_bytes <
 			         sav->lft_c->sadb_lifetime_bytes) {
 				key_sa_chgstate(sav, SADB_SASTATE_DYING);
 				mutex_exit(&key_sad.lock);
 				/*
 				 * XXX If we keep to send expire
 				 * message in the status of
 				 * DYING. Do remove below code.
 				 */
 				key_expire(sav);
 				goto restart_sav_MATURE;
+			}
+		}
 		mutex_exit(&key_sad.lock);
 		/* check DYING entry to change status to DEAD. */
 		mutex_enter(&key_sad.lock);
 	restart_sav_DYING:
-		SAVLIST_READER_FOREACH(sav, sah, SADB_SASTATE_DYING) {
+		SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_DYING) {
 			/* we don't need to check. */
 			if (sav->lft_h == NULL)
 				continue;
 			/* sanity check */
 			KASSERT(sav->lft_c != NULL);
 			if (sav->lft_h->sadb_lifetime_addtime != 0 &&
 			    now - sav->created > sav->lft_h->sadb_lifetime_addtime) {
 				key_sa_chgstate(sav, SADB_SASTATE_DEAD);
 				goto restart_sav_DYING;
+			}
 #if 0	/* XXX Should we keep to send expire message until HARD lifetime ? */
 @@ -4809,33 +4853,38 @@ restart:
 				 * expire message.
 				 */
 				key_expire(sav);
+			}
 #endif
 			/* check HARD lifetime by bytes */
 			else if (sav->lft_h->sadb_lifetime_bytes != 0 &&
 			         sav->lft_h->sadb_lifetime_bytes <
 			         sav->lft_c->sadb_lifetime_bytes) {
 				key_sa_chgstate(sav, SADB_SASTATE_DEAD);
 				goto restart_sav_DYING;
+			}
+		}
 		mutex_exit(&key_sad.lock);
 		/* delete entry in DEAD */
 	restart_sav_DEAD:
-		SAVLIST_READER_FOREACH(sav, sah, SADB_SASTATE_DEAD) {
+		mutex_enter(&key_sad.lock);
-			KEY_FREESAV(&sav);
+		SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_DEAD) {
 			key_unlink_sav(sav);
 			mutex_exit(&key_sad.lock);
 			key_destroy_sav(sav);
 			goto restart_sav_DEAD;
+		}
 		mutex_exit(&key_sad.lock);
 		s = pserialize_read_enter();
 		key_sah_unref(sah);
+	}
 	pserialize_read_exit(s);
+}
 static void
 key_timehandler_acq(time_t now)
+{
 #ifndef IPSEC_NONBLOCK_ACQUIRE
 	struct secacq *acq, *nextacq;
 @@ -5110,31 +5159,30 @@ key_api_getspi(struct socket *so, struct
 	/* get a new SA */
 	/* XXX rewrite */
 	newsav = KEY_NEWSAV(m, mhp, &error);
 	if (newsav == NULL) {
 		key_sah_unref(sah);
 		/* XXX don't free new SA index allocated in above. */
 		return key_senderror(so, m, error);
+	}
 	/* set spi */
 	newsav->spi = htonl(spi);
-	/* add to satree */
+	/* Add to sah#savlist */
-	newsav->refcnt = 1;
+	key_init_sav(newsav);
 	newsav->sah = sah;
 	newsav->state = SADB_SASTATE_LARVAL;
 	SAVLIST_ENTRY_INIT(newsav);
 	mutex_enter(&key_sad.lock);
 	SAVLIST_WRITER_INSERT_TAIL(sah, SADB_SASTATE_LARVAL, newsav);
 	mutex_exit(&key_sad.lock);
 	key_validate_savlist(sah, SADB_SASTATE_LARVAL);
 	key_sah_unref(sah);
 #ifndef IPSEC_NONBLOCK_ACQUIRE
 	/* delete the entry in key_misc.acqlist */
 	if (mhp->msg->sadb_msg_seq != 0) {
 		struct secacq *acq;
 		mutex_enter(&key_misc.lock);
 		acq = key_getacqbyseq(mhp->msg->sadb_msg_seq);
 @@ -5557,42 +5605,40 @@ key_api_update(struct socket *so, struct
 	error = key_handle_natt_info(newsav, mhp);
 	if (error != 0) {
 		key_delsav(newsav);
 		goto error;
+	}
 	error = key_init_xform(newsav);
 	if (error != 0) {
 		key_delsav(newsav);
 		goto error;
+	}
-	/* add to satree */
+	/* Add to sah#savlist */
-	newsav->refcnt = 1;
+	key_init_sav(newsav);
 	newsav->state = SADB_SASTATE_MATURE;
 	SAVLIST_ENTRY_INIT(newsav);
 	mutex_enter(&key_sad.lock);
 	SAVLIST_WRITER_INSERT_TAIL(sah, SADB_SASTATE_MATURE, newsav);
 	mutex_exit(&key_sad.lock);
 	key_validate_savlist(sah, SADB_SASTATE_MATURE);
 	key_sa_chgstate(sav, SADB_SASTATE_DEAD);
 	KEY_FREESAV(&sav);
 	KEY_FREESAV(&sav);
 	key_sah_unref(sah);
 	sah = NULL;
 	key_destroy_sav_with_ref(sav);
 	sav = NULL;
+    {
 	struct mbuf *n;
 	/* set msg buf from mhp */
 	n = key_getmsgbuf_x1(m, mhp);
 	if (n == NULL) {
 		IPSECLOG(LOG_DEBUG, "No more memory.\n");
 		return key_senderror(so, m, ENOBUFS);
+	}
 	m_freem(m);
 	return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
+    }
 @@ -5755,30 +5801,29 @@ key_api_add(struct socket *so, struct mb
 	error = key_handle_natt_info(newsav, mhp);
 	if (error != 0) {
 		key_delsav(newsav);
 		error = EINVAL;
 		goto error;
+	}
 	error = key_init_xform(newsav);
 	if (error != 0) {
 		key_delsav(newsav);
 		goto error;
+	}
-	/* add to satree */
+	/* Add to sah#savlist */
-	newsav->refcnt = 1;
+	key_init_sav(newsav);
 	newsav->state = SADB_SASTATE_MATURE;
 	SAVLIST_ENTRY_INIT(newsav);
 	mutex_enter(&key_sad.lock);
 	SAVLIST_WRITER_INSERT_TAIL(sah, SADB_SASTATE_MATURE, newsav);
 	mutex_exit(&key_sad.lock);
 	key_validate_savlist(sah, SADB_SASTATE_MATURE);
 	key_sah_unref(sah);
 	sah = NULL;
 	/*
 	 * don't call key_freesav() here, as we would like to keep the SA
 	 * in the database on success.
 	 */
 @@ -5985,29 +6030,28 @@ key_api_delete(struct socket *so, struct
 	/* get a SA header */
 	sah = key_getsah_ref(&saidx, CMP_HEAD);
 	if (sah != NULL) {
 		/* get a SA with SPI. */
 		sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
 		key_sah_unref(sah);
+	}
 	if (sav == NULL) {
 		IPSECLOG(LOG_DEBUG, "no SA found.\n");
 		return key_senderror(so, m, ENOENT);
+	}
-	key_sa_chgstate(sav, SADB_SASTATE_DEAD);
+	key_destroy_sav_with_ref(sav);
-	KEY_FREESAV(&sav);
+	sav = NULL;
 	KEY_FREESAV(&sav);
+    {
 	struct mbuf *n;
 	/* create new sadb_msg to reply. */
 	n = key_gather_mbuf(m, mhp, 1, 4, SADB_EXT_RESERVED,
 	    SADB_EXT_SA, SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
 	if (!n)
 		return key_senderror(so, m, ENOBUFS);
 	n = key_fill_replymsg(n, 0);
 	if (n == NULL)
 		return key_senderror(so, m, ENOBUFS);
 @@ -6039,40 +6083,35 @@ key_delete_all(struct socket *so, struct
 		return key_senderror(so, m, EINVAL);
 	error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
 	if (error != 0)
 		return key_senderror(so, m, EINVAL);
 	sah = key_getsah_ref(&saidx, CMP_HEAD);
 	if (sah != NULL) {
 		/* Delete all non-LARVAL SAs. */
 		SASTATE_ALIVE_FOREACH(state) {
 			if (state == SADB_SASTATE_LARVAL)
 				continue;
 		restart:
 			mutex_enter(&key_sad.lock);
 			SAVLIST_WRITER_FOREACH(sav, sah, state) {
-				/* sanity check */
+				sav->state = SADB_SASTATE_DEAD;
-				if (sav->state != state) {
+				key_unlink_sav(sav);
-					IPSECLOG(LOG_DEBUG,
+				mutex_exit(&key_sad.lock);
-					    "invalid sav->state "
+				key_destroy_sav(sav);
 					    "(queue: %d SA: %d)\n",
 					    state, sav->state);
 					continue;
 				key_sa_chgstate(sav, SADB_SASTATE_DEAD);
 				KEY_FREESAV(&sav);
 				goto restart;
+			}
 			mutex_exit(&key_sad.lock);
+		}
 		key_sah_unref(sah);
+	}
+    {
 	struct mbuf *n;
 	/* create new sadb_msg to reply. */
 	n = key_gather_mbuf(m, mhp, 1, 3, SADB_EXT_RESERVED,
 	    SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
 	if (!n)
 		return key_senderror(so, m, ENOBUFS);
 	n = key_fill_replymsg(n, 0);
 @@ -7282,31 +7321,35 @@ key_api_flush(struct socket *so, struct
 	/* no SATYPE specified, i.e. flushing all SA. */
 	s = pserialize_read_enter();
 	SAHLIST_READER_FOREACH(sah) {
 		if (mhp->msg->sadb_msg_satype != SADB_SATYPE_UNSPEC &&
 		    proto != sah->saidx.proto)
 			continue;
 		key_sah_ref(sah);
 		pserialize_read_exit(s);
 		SASTATE_ALIVE_FOREACH(state) {
 		restart:
 			mutex_enter(&key_sad.lock);
 			SAVLIST_WRITER_FOREACH(sav, sah, state) {
-				key_sa_chgstate(sav, SADB_SASTATE_DEAD);
+				sav->state = SADB_SASTATE_DEAD;
-				KEY_FREESAV(&sav);
+				key_unlink_sav(sav);
 				mutex_exit(&key_sad.lock);
 				key_destroy_sav(sav);
 				goto restart;
+			}
 			mutex_exit(&key_sad.lock);
+		}
 		s = pserialize_read_enter();
 		sah->state = SADB_SASTATE_DEAD;
 		key_sah_unref(sah);
+	}
 	pserialize_read_exit(s);
 	if (m->m_len < sizeof(struct sadb_msg) ||
 	    sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) {
 		IPSECLOG(LOG_DEBUG, "No more memory.\n");
 		return key_senderror(so, m, ENOBUFS);
+	}
 @@ -8231,34 +8274,35 @@ key_sa_routechange(struct sockaddr *dst)
 		s = pserialize_read_enter();
 		key_sah_unref(sah);
+	}
 	pserialize_read_exit(s);
 	return;
+}
 static void
 key_sa_chgstate(struct secasvar *sav, u_int8_t state)
+{
 	struct secasvar *_sav;
-	KASSERT(sav != NULL);
+	ASSERT_SLEEPABLE();
 	KASSERT(mutex_owned(&key_sad.lock));
 	if (sav->state == state)
 		return;
-	SAVLIST_WRITER_REMOVE(sav);
+	key_unlink_sav(sav);
 	SAVLIST_ENTRY_DESTROY(sav);
-	SAVLIST_ENTRY_INIT(sav);
+	key_init_sav(sav);
 	sav->state = state;
 	if (!SADB_SASTATE_USABLE_P(sav)) {
 		/* We don't need to care about the order */
 		SAVLIST_WRITER_INSERT_HEAD(sav->sah, state, sav);
 		return;
+	}
 	/*
 	 * Sort the list by lft_c->sadb_lifetime_addtime
 	 * in ascending order.
 	 */
 	SAVLIST_READER_FOREACH(_sav, sav->sah, state) {
 		if (_sav->lft_c->sadb_lifetime_addtime >

 @@ -1,14 +1,14 @@
-/*	$NetBSD: xform_ah.c,v 1.71 2017/08/03 06:32:51 ozaki-r Exp $	*/
+/*	$NetBSD: xform_ah.c,v 1.72 2017/08/09 09:48:11 ozaki-r Exp $	*/
 /*	$FreeBSD: src/sys/netipsec/xform_ah.c,v 1.1.4.1 2003/01/24 05:11:36 sam Exp $	*/
 /*	$OpenBSD: ip_ah.c,v 1.63 2001/06/26 06:18:58 angelos Exp $ */
 /*
  * The authors of this code are John Ioannidis (ji@tla.org),
  * Angelos D. Keromytis (kermit@csd.uch.gr) and
  * Niels Provos (provos@physnet.uni-hamburg.de).
+ *
  * The original version of this code was written by John Ioannidis
  * for BSD/OS in Athens, Greece, in November 1995.
+ *
  * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996,
  * by Angelos D. Keromytis.
+ *
 @@ -29,27 +29,27 @@
  * You may use this code under the GNU public license if you so wish. Please
  * contribute changes back to the authors under this freer than GPL license
  * so that we may further the use of strong encryption without limitations to
  * all.
+ *
  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
  * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
  * PURPOSE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: xform_ah.c,v 1.71 2017/08/03 06:32:51 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xform_ah.c,v 1.72 2017/08/09 09:48:11 ozaki-r Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_inet.h"
 #include "opt_ipsec.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <sys/syslog.h>
 #include <sys/kernel.h>
 #include <sys/sysctl.h>
 @@ -723,43 +723,58 @@ ah_input(struct mbuf *m, struct secasvar
 	m_copydata(m, 0, extra, (tc + 1));
 	/* Zeroize the authenticator on the packet. */
 	m_copyback(m, skip + rplen, authsize, ipseczeroes);
 	/* "Massage" the packet headers for crypto processing. */
 	error = ah_massage_headers(&m, sav->sah->saidx.dst.sa.sa_family,
 	    skip, ahx->type, 0);
 	if (error != 0) {
 		/* NB: mbuf is free'd by ah_massage_headers */
 		m = NULL;
 		goto bad;
+	}
+    {
 	int s = pserialize_read_enter();
 	/*
 	 * Take another reference to the SA for opencrypto callback.
 	 */
 	if (__predict_false(sav->state == SADB_SASTATE_DEAD)) {
 		pserialize_read_exit(s);
 		stat = AH_STAT_NOTDB;
 		error = ENOENT;
 		goto bad;
+	}
 	KEY_SA_REF(sav);
 	pserialize_read_exit(s);
+    }
 	/* Crypto operation descriptor. */
 	crp->crp_ilen = m->m_pkthdr.len; /* Total input length. */
 	crp->crp_flags = CRYPTO_F_IMBUF;
 	crp->crp_buf = m;
 	crp->crp_callback = ah_input_cb;
 	crp->crp_sid = sav->tdb_cryptoid;
 	crp->crp_opaque = tc;
 	/* These are passed as-is to the callback. */
 	tc->tc_spi = sav->spi;
 	tc->tc_dst = sav->sah->saidx.dst;
 	tc->tc_proto = sav->sah->saidx.proto;
 	tc->tc_nxt = ah->ah_nxt;
 	tc->tc_protoff = protoff;
 	tc->tc_skip = skip;
 	tc->tc_sav = sav;
 	KEY_SA_REF(sav);
 	DPRINTF(("%s: hash over %d bytes, skip %d: "
 		 "crda len %d skip %d inject %d\n", __func__,
 		 crp->crp_ilen, tc->tc_skip,
 		 crda->crd_len, crda->crd_skip, crda->crd_inject));
 	return crypto_dispatch(crp);
 bad:
 	if (tc != NULL)
 		pool_put(&ah_tdb_crypto_pool, tc);
 	if (crp != NULL)
 		crypto_freereq(crp);
 @@ -1134,55 +1149,59 @@ ah_output(
 	/* "Massage" the packet headers for crypto processing. */
 	error = ah_massage_headers(&m, sav->sah->saidx.dst.sa.sa_family,
 	    skip, ahx->type, 1);
 	if (error != 0) {
 		m = NULL;	/* mbuf was free'd by ah_massage_headers. */
 		pool_put(&ah_tdb_crypto_pool, tc);
 		crypto_freereq(crp);
 		goto bad;
+	}
+    {
 	int s = pserialize_read_enter();
-	if (__predict_false(isr->sp->state == IPSEC_SPSTATE_DEAD)) {
+	/*
 	 * Take another reference to the SP and the SA for opencrypto callback.
 	 */
 	if (__predict_false(isr->sp->state == IPSEC_SPSTATE_DEAD ||
 	    sav->state == SADB_SASTATE_DEAD)) {
 		pserialize_read_exit(s);
 		pool_put(&ah_tdb_crypto_pool, tc);
 		crypto_freereq(crp);
 		AH_STATINC(AH_STAT_NOTDB);
 		error = ENOENT;
 		goto bad;
+	}
 	KEY_SP_REF(isr->sp);
 	KEY_SA_REF(sav);
 	pserialize_read_exit(s);
+    }
 	/* Crypto operation descriptor. */
 	crp->crp_ilen = m->m_pkthdr.len; /* Total input length. */
 	crp->crp_flags = CRYPTO_F_IMBUF;
 	crp->crp_buf = m;
 	crp->crp_callback = ah_output_cb;
 	crp->crp_sid = sav->tdb_cryptoid;
 	crp->crp_opaque = tc;
 	/* These are passed as-is to the callback. */
 	tc->tc_isr = isr;
 	tc->tc_spi = sav->spi;
 	tc->tc_dst = sav->sah->saidx.dst;
 	tc->tc_proto = sav->sah->saidx.proto;
 	tc->tc_skip = skip;
 	tc->tc_protoff = protoff;
 	tc->tc_sav = sav;
 	KEY_SA_REF(sav);
 	return crypto_dispatch(crp);
 bad:
 	if (m)
 		m_freem(m);
 	return (error);
+}
 /*
  * AH output callback from the crypto driver.
  */
 static int
 ah_output_cb(struct cryptop *crp)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: xform_ipcomp.c,v 1.50 2017/08/03 06:32:51 ozaki-r Exp $	*/
+/*	$NetBSD: xform_ipcomp.c,v 1.51 2017/08/09 09:48:11 ozaki-r Exp $	*/
 /*	$FreeBSD: src/sys/netipsec/xform_ipcomp.c,v 1.1.4.1 2003/01/24 05:11:36 sam Exp $	*/
 /* $OpenBSD: ip_ipcomp.c,v 1.1 2001/07/05 12:08:52 jjbg Exp $ */
 /*
  * Copyright (c) 2001 Jean-Jacques Bernard-Gundol (jj@wabbitt.org)
+ *
  * 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
  *   notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -20,27 +20,27 @@
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: xform_ipcomp.c,v 1.50 2017/08/03 06:32:51 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xform_ipcomp.c,v 1.51 2017/08/09 09:48:11 ozaki-r Exp $");
 /* IP payload compression protocol (IPComp), see RFC 2393 */
 #if defined(_KERNEL_OPT)
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <sys/kernel.h>
 #include <sys/protosw.h>
 #include <sys/sysctl.h>
 @@ -174,52 +174,68 @@ ipcomp_input(struct mbuf *m, struct seca
 		return ENOBUFS;
+	}
 	error = m_makewritable(&m, 0, m->m_pkthdr.len, M_NOWAIT);
 	if (error) {
 		DPRINTF(("%s: m_makewritable failed\n", __func__));
 		m_freem(m);
 		pool_put(&ipcomp_tdb_crypto_pool, tc);
 		crypto_freereq(crp);
 		IPCOMP_STATINC(IPCOMP_STAT_CRYPTO);
 		return error;
+	}
+    {
 	int s = pserialize_read_enter();
 	/*
 	 * Take another reference to the SA for opencrypto callback.
 	 */
 	if (__predict_false(sav->state == SADB_SASTATE_DEAD)) {
 		pserialize_read_exit(s);
 		pool_put(&ipcomp_tdb_crypto_pool, tc);
 		crypto_freereq(crp);
 		IPCOMP_STATINC(IPCOMP_STAT_NOTDB);
 		return ENOENT;
+	}
 	KEY_SA_REF(sav);
 	pserialize_read_exit(s);
+    }
 	crdc = crp->crp_desc;
 	crdc->crd_skip = skip + hlen;
 	crdc->crd_len = m->m_pkthdr.len - (skip + hlen);
 	crdc->crd_inject = 0; /* unused */
 	/* Decompression operation */
 	crdc->crd_alg = sav->tdb_compalgxform->type;
 	/* Crypto operation descriptor */
 	crp->crp_ilen = m->m_pkthdr.len - (skip + hlen);
 	crp->crp_olen = MCLBYTES; /* hint to decompression code */
 	crp->crp_flags = CRYPTO_F_IMBUF;
 	crp->crp_buf = m;
 	crp->crp_callback = ipcomp_input_cb;
 	crp->crp_sid = sav->tdb_cryptoid;
 	crp->crp_opaque = tc;
 	/* These are passed as-is to the callback */
 	tc->tc_spi = sav->spi;
 	tc->tc_dst = sav->sah->saidx.dst;
 	tc->tc_proto = sav->sah->saidx.proto;
 	tc->tc_protoff = protoff;
 	tc->tc_skip = skip;
 	tc->tc_sav = sav;
 	KEY_SA_REF(sav);
 	return crypto_dispatch(crp);
+}
 #ifdef INET6
 #define	IPSEC_COMMON_INPUT_CB(m, sav, skip, protoff) do {		     \
 	if (saidx->dst.sa.sa_family == AF_INET6) {			     \
 		error = ipsec6_common_input_cb(m, sav, skip, protoff);	     \
 	} else {							     \
 		error = ipsec4_common_input_cb(m, sav, skip, protoff);       \
 	}								     \
 } while (0)
 #else
 @@ -473,46 +489,50 @@ ipcomp_output(
 	/* IPsec-specific opaque crypto info */
 	tc = pool_get(&ipcomp_tdb_crypto_pool, PR_NOWAIT);
 	if (tc == NULL) {
 		IPCOMP_STATINC(IPCOMP_STAT_CRYPTO);
 		DPRINTF(("%s: failed to allocate tdb_crypto\n", __func__));
 		crypto_freereq(crp);
 		error = ENOBUFS;
 		goto bad;
+	}
+    {
 	int s = pserialize_read_enter();
-	if (__predict_false(isr->sp->state == IPSEC_SPSTATE_DEAD)) {
+	/*
 	 * Take another reference to the SP and the SA for opencrypto callback.
 	 */
 	if (__predict_false(isr->sp->state == IPSEC_SPSTATE_DEAD ||
 	    sav->state == SADB_SASTATE_DEAD)) {
 		pserialize_read_exit(s);
 		pool_put(&ipcomp_tdb_crypto_pool, tc);
 		crypto_freereq(crp);
 		IPCOMP_STATINC(IPCOMP_STAT_NOTDB);
 		error = ENOENT;
 		goto bad;
+	}
 	KEY_SP_REF(isr->sp);
 	KEY_SA_REF(sav);
 	pserialize_read_exit(s);
+    }
 	tc->tc_isr = isr;
 	tc->tc_spi = sav->spi;
 	tc->tc_dst = sav->sah->saidx.dst;
 	tc->tc_proto = sav->sah->saidx.proto;
 	tc->tc_skip = skip;
 	tc->tc_protoff = protoff;
 	tc->tc_sav = sav;
 	KEY_SA_REF(sav);
 	/* Crypto operation descriptor */
 	crp->crp_ilen = m->m_pkthdr.len;	/* Total input length */
 	crp->crp_flags = CRYPTO_F_IMBUF;
 	crp->crp_buf = m;
 	crp->crp_callback = ipcomp_output_cb;
 	crp->crp_opaque = tc;
 	crp->crp_sid = sav->tdb_cryptoid;
 	return crypto_dispatch(crp);
 bad:
 	if (m)
 		m_freem(m);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: key.h,v 1.28 2017/08/08 08:23:10 ozaki-r Exp $	*/
+/*	$NetBSD: key.h,v 1.29 2017/08/09 09:48:11 ozaki-r Exp $	*/
 /*	$FreeBSD: src/sys/netipsec/key.h,v 1.1.4.1 2003/01/24 05:11:36 sam Exp $	*/
 /*	$KAME: key.h,v 1.21 2001/07/27 03:51:30 itojun Exp $	*/
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  * All rights reserved.
+ *
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -51,60 +51,59 @@ int key_havesp(u_int dir);
 struct secpolicy *key_lookup_sp_byspidx(const struct secpolicyindex *, u_int,
 	const char*, int);
 struct secpolicy *key_newsp(const char*, int);
 struct secpolicy *key_gettunnel(const struct sockaddr *,
 	const struct sockaddr *, const struct sockaddr *,
 	const struct sockaddr *, const char*, int);
 /* NB: prepend with _ for KAME IPv6 compatbility */
 void key_init_sp(struct secpolicy *);
 void key_free_sp(struct secpolicy *);
 u_int key_sp_refcnt(const struct secpolicy *);
 void key_sp_ref(struct secpolicy *, const char*, int);
 void key_sp_unref(struct secpolicy *, const char*, int);
 void key_sa_ref(struct secasvar *, const char*, int);
 void key_sa_unref(struct secasvar *, const char*, int);
 u_int key_sa_refcnt(const struct secasvar *);
 void key_socksplist_add(struct secpolicy *);
 /*
  * Access to the SADB are interlocked with splsoftnet.  In particular,
  * holders of SA's use this to block accesses by protocol processing
  * that can happen either by network swi's or by continuations that
  * occur on crypto callbacks.  Much of this could go away if
  * key_checkrequest were redone.
  */
 #define	KEY_LOOKUP_SP_BYSPIDX(spidx, dir)			\
 	key_lookup_sp_byspidx(spidx, dir, __func__, __LINE__)
 #define	KEY_NEWSP()						\
 	key_newsp(__func__, __LINE__)
 #define	KEY_GETTUNNEL(osrc, odst, isrc, idst)			\
 	key_gettunnel(osrc, odst, isrc, idst, __func__, __LINE__)
 #define	KEY_SP_UNREF(spp)					\
 	key_sp_unref(*(spp), __func__, __LINE__)
 #define	KEY_SP_REF(sp)						\
 	key_sp_ref(sp, __func__, __LINE__)
 #define KEY_SA_REF(sav)						\
 	key_sa_ref(sav, __func__, __LINE__)
 #define	KEY_SA_UNREF(psav)					\
-	key_freesav(psav, __func__, __LINE__)
+	key_sa_unref(*(psav), __func__, __LINE__)
 struct secasvar *key_lookup_sa(const union sockaddr_union *,
 		u_int, u_int32_t, u_int16_t, u_int16_t, const char*, int);
 void key_freesav(struct secasvar **, const char*, int);
 #define	KEY_LOOKUP_SA(dst, proto, spi, sport, dport)		\
 	key_lookup_sa(dst, proto, spi, sport, dport,  __func__, __LINE__)
 #define	KEY_FREESAV(psav)					\
 	key_freesav(psav, __func__, __LINE__)
 int key_checktunnelsanity (struct secasvar *, u_int, void *, void *);
 int key_checkrequest(struct ipsecrequest *, struct secasvar **);
 struct secpolicy *key_msg2sp (const struct sadb_x_policy *, size_t, int *);
 struct mbuf *key_sp2msg (const struct secpolicy *);
 int key_ismyaddr (const struct sockaddr *);
 int key_spdacquire (const struct secpolicy *);
 u_long key_random (void);
 void key_randomfill (void *, size_t);
 void key_freereg (struct socket *);
 int key_parse (struct mbuf *, struct socket *);
 void key_init (void);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: keydb.h,v 1.19 2017/08/08 04:17:34 ozaki-r Exp $	*/
+/*	$NetBSD: keydb.h,v 1.20 2017/08/09 09:48:11 ozaki-r Exp $	*/
 /*	$FreeBSD: src/sys/netipsec/keydb.h,v 1.1.4.1 2003/01/24 05:11:36 sam Exp $	*/
 /*	$KAME: keydb.h,v 1.14 2000/08/02 17:58:26 sakane Exp $	*/
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  * All rights reserved.
+ *
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -84,28 +84,28 @@ struct secashead {
 					/* The first of this list is newer SA */
 	struct route sa_route;		/* route cache */
 };
 struct xformsw;
 struct enc_xform;
 struct auth_hash;
 struct comp_algo;
 /* Security Association */
 struct secasvar {
 	struct pslist_entry pslist_entry;
 	struct localcount localcount;	/* reference count */
 	u_int refcnt;			/* reference count */
 	u_int8_t state;			/* Status of this Association */
 	u_int8_t alg_auth;		/* Authentication Algorithm Identifier*/
 	u_int8_t alg_enc;		/* Cipher Algorithm Identifier */
 	u_int8_t alg_comp;		/* Compression Algorithm Identifier */
 	u_int32_t spi;			/* SPI Value, network byte order */
 	u_int32_t flags;		/* holder for SADB_KEY_FLAGS */
 	struct sadb_key *key_auth;	/* Key for Authentication */
 	size_t key_auth_len;		/* length of key_auth */
 	struct sadb_key *key_enc;	/* Key for Encryption */
 	size_t key_enc_len;		/* length of key_enc */
 	u_int ivlen;			/* length of IV */