diff --git a/sys/compat/linuxkpi/common/include/linux/seqlock.h b/sys/compat/linuxkpi/common/include/linux/seqlock.h
index a7b9dd12e493..48e42efc10fe 100644
--- a/sys/compat/linuxkpi/common/include/linux/seqlock.h
+++ b/sys/compat/linuxkpi/common/include/linux/seqlock.h
@@ -1,168 +1,184 @@
 /*-
  * SPDX-License-Identifier: BSD-2-Clause
  *
  * Copyright (c) 2021 Vladimir Kondratyev <wulf@FreeBSD.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
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 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.
  */
 
 #ifndef _LINUXKPI_LINUX_SEQLOCK_H__
 #define	_LINUXKPI_LINUX_SEQLOCK_H__
 
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/cdefs.h>
 #include <sys/lock.h>
 #include <sys/mutex.h>
 #include <sys/rwlock.h>
 #include <sys/seqc.h>
 
 struct lock_class_key;
 
 struct seqcount {
 	seqc_t		seqc;
 };
 typedef struct seqcount seqcount_t;
 
 struct seqlock {
 	struct mtx	seql_lock;
 	struct seqcount	seql_count;
 };
 typedef struct seqlock seqlock_t;
 
 struct seqcount_mutex {
 	seqc_t		seqc;
 };
 typedef struct seqcount_mutex seqcount_mutex_t;
 typedef struct seqcount_mutex seqcount_ww_mutex_t;
 
 static inline void
 __seqcount_init(struct seqcount *seqcount, const char *name __unused,
     struct lock_class_key *key __unused)
 {
 	seqcount->seqc = 0;
 }
 #define	seqcount_init(seqcount)	__seqcount_init(seqcount, NULL, NULL)
 
 static inline void
 seqcount_mutex_init(struct seqcount_mutex *seqcount, void *mutex __unused)
 {
 	seqcount->seqc = 0;
 }
 
 #define	seqcount_ww_mutex_init(seqcount, ww_mutex) \
     seqcount_mutex_init((seqcount), (ww_mutex))
 
 #define	write_seqcount_begin(s)						\
     _Generic(*(s),							\
 	struct seqcount:	seqc_sleepable_write_begin,		\
 	struct seqcount_mutex:	seqc_write_begin			\
     )(&(s)->seqc)
 
 #define	write_seqcount_end(s)						\
     _Generic(*(s),							\
 	struct seqcount:	seqc_sleepable_write_end,		\
 	struct seqcount_mutex:	seqc_write_end				\
     )(&(s)->seqc)
 
+static inline void
+lkpi_write_seqcount_invalidate(seqc_t *seqcp)
+{
+	atomic_thread_fence_rel();
+	*seqcp += SEQC_MOD * 2;
+}
+#define	write_seqcount_invalidate(s) lkpi_write_seqcount_invalidate(&(s)->seqc)
+
 #define	read_seqcount_begin(s)	seqc_read(&(s)->seqc)
 #define	raw_read_seqcount(s)	seqc_read_any(&(s)->seqc)
 
+static inline seqc_t
+lkpi_seqprop_sequence(const seqc_t *seqcp)
+{
+	return (atomic_load_int(__DECONST(seqc_t *, seqcp)));
+}
+#define	seqprop_sequence(s)	lkpi_seqprop_sequence(&(s)->seqc)
+
 /*
  * XXX: Are predicts from inline functions still not honored by clang?
  */
 #define	__read_seqcount_retry(seqcount, gen)	\
 	(!seqc_consistent_no_fence(&(seqcount)->seqc, gen))
 #define	read_seqcount_retry(seqcount, gen)	\
 	(!seqc_consistent(&(seqcount)->seqc, gen))
 
 static inline void
 seqlock_init(struct seqlock *seqlock)
 {
 	/*
 	 * Don't enroll to witness(4) to avoid orphaned references after struct
 	 * seqlock has been freed. There is no seqlock destructor exists so we
 	 * can't expect automatic mtx_destroy() execution before free().
 	 */
 	mtx_init(&seqlock->seql_lock, "seqlock", NULL, MTX_DEF|MTX_NOWITNESS);
 	seqcount_init(&seqlock->seql_count);
 }
 
 static inline void
 lkpi_write_seqlock(struct seqlock *seqlock, const bool irqsave)
 {
 	mtx_lock(&seqlock->seql_lock);
 	if (irqsave)
 		critical_enter();
 	write_seqcount_begin(&seqlock->seql_count);
 }
 
 static inline void
 write_seqlock(struct seqlock *seqlock)
 {
 	lkpi_write_seqlock(seqlock, false);
 }
 
 static inline void
 lkpi_write_sequnlock(struct seqlock *seqlock, const bool irqsave)
 {
 	write_seqcount_end(&seqlock->seql_count);
 	if (irqsave)
 		critical_exit();
 	mtx_unlock(&seqlock->seql_lock);
 }
 
 static inline void
 write_sequnlock(struct seqlock *seqlock)
 {
 	lkpi_write_sequnlock(seqlock, false);
 }
 
 /*
  * Disable preemption when the consumer wants to disable interrupts.  This
  * ensures that the caller won't be starved if it is preempted by a
  * higher-priority reader, but assumes that the caller won't perform any
  * blocking operations while holding the write lock; probably a safe
  * assumption.
  */
 #define	write_seqlock_irqsave(seqlock, flags)	do {	\
 	(flags) = 0;					\
 	lkpi_write_seqlock(seqlock, true);		\
 } while (0)
 
 static inline void
 write_sequnlock_irqrestore(struct seqlock *seqlock,
     unsigned long flags __unused)
 {
 	lkpi_write_sequnlock(seqlock, true);
 }
 
 static inline unsigned
 read_seqbegin(const struct seqlock *seqlock)
 {
 	return (read_seqcount_begin(&seqlock->seql_count));
 }
 
 #define	read_seqretry(seqlock, gen)	\
 	read_seqcount_retry(&(seqlock)->seql_count, gen)
 
 #endif	/* _LINUXKPI_LINUX_SEQLOCK_H__ */