From: Kai Huang <kai.huang@intel.com>
TDX host core code implements three seamcall*() helpers to make SEAMCALL
to the TDX module. Currently, they are implemented in <asm/tdx.h> and
are exposed to other kernel code which includes <asm/tdx.h>.
However, other than the TDX host core, seamcall*() are not expected to
be used by other kernel code directly. For instance, for all SEAMCALLs
that are used by KVM, the TDX host core exports a wrapper function for
each of them.
Move seamcall*() and related code out of <asm/tdx.h> and make them only
visible to TDX host core.
Since TDX host core tdx.c is already very heavy, don't put low level
seamcall*() code there but to a new dedicated "seamcall.h". Also,
currently tdx.c has seamcall_prerr*() helpers which additionally print
error message when calling seamcall*() fails. Move them to "seamcall.h"
as well. In such way all low level SEAMCALL helpers are in a dedicated
place, which is much more readable.
Signed-off-by: Kai Huang <kai.huang@intel.com>
Signed-off-by: Chao Gao <chao.gao@intel.com>
Reviewed-by: Zhenzhong Duan <zhenzhong.duan@intel.com>
---
v2:
- new
---
arch/x86/include/asm/tdx.h | 47 ---------------
arch/x86/virt/vmx/tdx/seamcall.h | 99 ++++++++++++++++++++++++++++++++
arch/x86/virt/vmx/tdx/tdx.c | 46 +--------------
3 files changed, 100 insertions(+), 92 deletions(-)
create mode 100644 arch/x86/virt/vmx/tdx/seamcall.h
diff --git a/arch/x86/include/asm/tdx.h b/arch/x86/include/asm/tdx.h
index 6b338d7f01b7..cb2219302dfc 100644
--- a/arch/x86/include/asm/tdx.h
+++ b/arch/x86/include/asm/tdx.h
@@ -97,54 +97,7 @@ static inline long tdx_kvm_hypercall(unsigned int nr, unsigned long p1,
#endif /* CONFIG_INTEL_TDX_GUEST && CONFIG_KVM_GUEST */
#ifdef CONFIG_INTEL_TDX_HOST
-u64 __seamcall(u64 fn, struct tdx_module_args *args);
-u64 __seamcall_ret(u64 fn, struct tdx_module_args *args);
-u64 __seamcall_saved_ret(u64 fn, struct tdx_module_args *args);
void tdx_init(void);
-
-#include <linux/preempt.h>
-#include <asm/archrandom.h>
-#include <asm/processor.h>
-
-typedef u64 (*sc_func_t)(u64 fn, struct tdx_module_args *args);
-
-static __always_inline u64 __seamcall_dirty_cache(sc_func_t func, u64 fn,
- struct tdx_module_args *args)
-{
- lockdep_assert_preemption_disabled();
-
- /*
- * SEAMCALLs are made to the TDX module and can generate dirty
- * cachelines of TDX private memory. Mark cache state incoherent
- * so that the cache can be flushed during kexec.
- *
- * This needs to be done before actually making the SEAMCALL,
- * because kexec-ing CPU could send NMI to stop remote CPUs,
- * in which case even disabling IRQ won't help here.
- */
- this_cpu_write(cache_state_incoherent, true);
-
- return func(fn, args);
-}
-
-static __always_inline u64 sc_retry(sc_func_t func, u64 fn,
- struct tdx_module_args *args)
-{
- int retry = RDRAND_RETRY_LOOPS;
- u64 ret;
-
- do {
- preempt_disable();
- ret = __seamcall_dirty_cache(func, fn, args);
- preempt_enable();
- } while (ret == TDX_RND_NO_ENTROPY && --retry);
-
- return ret;
-}
-
-#define seamcall(_fn, _args) sc_retry(__seamcall, (_fn), (_args))
-#define seamcall_ret(_fn, _args) sc_retry(__seamcall_ret, (_fn), (_args))
-#define seamcall_saved_ret(_fn, _args) sc_retry(__seamcall_saved_ret, (_fn), (_args))
int tdx_cpu_enable(void);
int tdx_enable(void);
const char *tdx_dump_mce_info(struct mce *m);
diff --git a/arch/x86/virt/vmx/tdx/seamcall.h b/arch/x86/virt/vmx/tdx/seamcall.h
new file mode 100644
index 000000000000..0912e03fabfe
--- /dev/null
+++ b/arch/x86/virt/vmx/tdx/seamcall.h
@@ -0,0 +1,99 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (C) 2025 Intel Corporation */
+#ifndef _X86_VIRT_SEAMCALL_H
+#define _X86_VIRT_SEAMCALL_H
+
+#include <linux/printk.h>
+#include <linux/types.h>
+#include <asm/archrandom.h>
+#include <asm/processor.h>
+#include <asm/tdx.h>
+
+u64 __seamcall(u64 fn, struct tdx_module_args *args);
+u64 __seamcall_ret(u64 fn, struct tdx_module_args *args);
+u64 __seamcall_saved_ret(u64 fn, struct tdx_module_args *args);
+
+typedef u64 (*sc_func_t)(u64 fn, struct tdx_module_args *args);
+
+static __always_inline u64 __seamcall_dirty_cache(sc_func_t func, u64 fn,
+ struct tdx_module_args *args)
+{
+ lockdep_assert_preemption_disabled();
+
+ /*
+ * SEAMCALLs are made to the TDX module and can generate dirty
+ * cachelines of TDX private memory. Mark cache state incoherent
+ * so that the cache can be flushed during kexec.
+ *
+ * This needs to be done before actually making the SEAMCALL,
+ * because kexec-ing CPU could send NMI to stop remote CPUs,
+ * in which case even disabling IRQ won't help here.
+ */
+ this_cpu_write(cache_state_incoherent, true);
+
+ return func(fn, args);
+}
+
+static __always_inline u64 sc_retry(sc_func_t func, u64 fn,
+ struct tdx_module_args *args)
+{
+ int retry = RDRAND_RETRY_LOOPS;
+ u64 ret;
+
+ do {
+ ret = func(fn, args);
+ } while (ret == TDX_RND_NO_ENTROPY && --retry);
+
+ return ret;
+}
+
+#define seamcall(_fn, _args) sc_retry(__seamcall, (_fn), (_args))
+#define seamcall_ret(_fn, _args) sc_retry(__seamcall_ret, (_fn), (_args))
+#define seamcall_saved_ret(_fn, _args) sc_retry(__seamcall_saved_ret, (_fn), (_args))
+
+typedef void (*sc_err_func_t)(u64 fn, u64 err, struct tdx_module_args *args);
+
+static inline void seamcall_err(u64 fn, u64 err, struct tdx_module_args *args)
+{
+ pr_err("SEAMCALL (%llu) failed: %#016llx\n", fn, err);
+}
+
+static inline void seamcall_err_ret(u64 fn, u64 err,
+ struct tdx_module_args *args)
+{
+ seamcall_err(fn, err, args);
+ pr_err("RCX %#016llx RDX %#016llx R08 %#016llx\n",
+ args->rcx, args->rdx, args->r8);
+ pr_err("R09 %#016llx R10 %#016llx R11 %#016llx\n",
+ args->r9, args->r10, args->r11);
+}
+
+static __always_inline int sc_retry_prerr(sc_func_t func,
+ sc_err_func_t err_func,
+ u64 fn, struct tdx_module_args *args)
+{
+ u64 sret = sc_retry(func, fn, args);
+
+ if (sret == TDX_SUCCESS)
+ return 0;
+
+ if (sret == TDX_SEAMCALL_VMFAILINVALID)
+ return -ENODEV;
+
+ if (sret == TDX_SEAMCALL_GP)
+ return -EOPNOTSUPP;
+
+ if (sret == TDX_SEAMCALL_UD)
+ return -EACCES;
+
+ err_func(fn, sret, args);
+ return -EIO;
+}
+
+#define seamcall_prerr(__fn, __args) \
+ sc_retry_prerr(__seamcall, seamcall_err, (__fn), (__args))
+
+#define seamcall_prerr_ret(__fn, __args) \
+ sc_retry_prerr(__seamcall_ret, seamcall_err_ret, (__fn), (__args))
+
+#endif
diff --git a/arch/x86/virt/vmx/tdx/tdx.c b/arch/x86/virt/vmx/tdx/tdx.c
index 2218bb42af40..b44723ef4a14 100644
--- a/arch/x86/virt/vmx/tdx/tdx.c
+++ b/arch/x86/virt/vmx/tdx/tdx.c
@@ -39,6 +39,7 @@
#include <asm/cpu_device_id.h>
#include <asm/processor.h>
#include <asm/mce.h>
+#include "seamcall.h"
#include "tdx.h"
static u32 tdx_global_keyid __ro_after_init;
@@ -59,51 +60,6 @@ static LIST_HEAD(tdx_memlist);
static struct tdx_sys_info tdx_sysinfo;
-typedef void (*sc_err_func_t)(u64 fn, u64 err, struct tdx_module_args *args);
-
-static inline void seamcall_err(u64 fn, u64 err, struct tdx_module_args *args)
-{
- pr_err("SEAMCALL (%llu) failed: %#016llx\n", fn, err);
-}
-
-static inline void seamcall_err_ret(u64 fn, u64 err,
- struct tdx_module_args *args)
-{
- seamcall_err(fn, err, args);
- pr_err("RCX %#016llx RDX %#016llx R08 %#016llx\n",
- args->rcx, args->rdx, args->r8);
- pr_err("R09 %#016llx R10 %#016llx R11 %#016llx\n",
- args->r9, args->r10, args->r11);
-}
-
-static __always_inline int sc_retry_prerr(sc_func_t func,
- sc_err_func_t err_func,
- u64 fn, struct tdx_module_args *args)
-{
- u64 sret = sc_retry(func, fn, args);
-
- if (sret == TDX_SUCCESS)
- return 0;
-
- if (sret == TDX_SEAMCALL_VMFAILINVALID)
- return -ENODEV;
-
- if (sret == TDX_SEAMCALL_GP)
- return -EOPNOTSUPP;
-
- if (sret == TDX_SEAMCALL_UD)
- return -EACCES;
-
- err_func(fn, sret, args);
- return -EIO;
-}
-
-#define seamcall_prerr(__fn, __args) \
- sc_retry_prerr(__seamcall, seamcall_err, (__fn), (__args))
-
-#define seamcall_prerr_ret(__fn, __args) \
- sc_retry_prerr(__seamcall_ret, seamcall_err_ret, (__fn), (__args))
-
/*
* Do the module global initialization once and return its result.
* It can be done on any cpu. It's always called with interrupts
--
2.47.3On 1/23/26 06:55, Chao Gao wrote: > +++ b/arch/x86/virt/vmx/tdx/seamcall.h Moving the code to a local header is a good thing. The more private these things are, the better. I _do_ like when I see these things have a label in the filename like: internal.h or even: seamcall_internal.h That really catches your eye. It would also be ideal to have a small blurb at the top of the file to say what its scope is, just to explain what folks should be adding to it or not. If you get a chance to add those, all the better. But either way: Acked-by: Dave Hansen <dave.hansen@linux.intel.com>
On Wed, Jan 28, 2026 at 08:37:35AM -0800, Dave Hansen wrote: >On 1/23/26 06:55, Chao Gao wrote: >> +++ b/arch/x86/virt/vmx/tdx/seamcall.h > >Moving the code to a local header is a good thing. The more private >these things are, the better. > >I _do_ like when I see these things have a label in the filename like: > > internal.h > >or even: > > seamcall_internal.h > >That really catches your eye. It would also be ideal to have a small >blurb at the top of the file to say what its scope is, just to explain >what folks should be adding to it or not. > >If you get a chance to add those, all the better. But either way: > >Acked-by: Dave Hansen <dave.hansen@linux.intel.com> Thanks. I will rename it to "seamcall_internal.h" and add the following at the top: /* * SEAMCALL utilities for TDX host-side operations. * * Provides convenient wrappers around SEAMCALL assembly with retry logic, * error reporting and cache coherency tracking. */
On 1/23/2026 10:55 PM, Chao Gao wrote: > From: Kai Huang <kai.huang@intel.com> > > TDX host core code implements three seamcall*() helpers to make SEAMCALL > to the TDX module. Currently, they are implemented in <asm/tdx.h> and > are exposed to other kernel code which includes <asm/tdx.h>. > > However, other than the TDX host core, seamcall*() are not expected to > be used by other kernel code directly. For instance, for all SEAMCALLs > that are used by KVM, the TDX host core exports a wrapper function for > each of them. > > Move seamcall*() and related code out of <asm/tdx.h> and make them only > visible to TDX host core. > > Since TDX host core tdx.c is already very heavy, don't put low level > seamcall*() code there but to a new dedicated "seamcall.h". Also, > currently tdx.c has seamcall_prerr*() helpers which additionally print > error message when calling seamcall*() fails. Move them to "seamcall.h" > as well. In such way all low level SEAMCALL helpers are in a dedicated > place, which is much more readable. > > Signed-off-by: Kai Huang <kai.huang@intel.com> > Signed-off-by: Chao Gao <chao.gao@intel.com> > Reviewed-by: Zhenzhong Duan <zhenzhong.duan@intel.com> Reviewed-by: Binbin Wu <binbin.wu@linux.intel.com> One question below. [...] > diff --git a/arch/x86/virt/vmx/tdx/seamcall.h b/arch/x86/virt/vmx/tdx/seamcall.h > new file mode 100644 > index 000000000000..0912e03fabfe > --- /dev/null > +++ b/arch/x86/virt/vmx/tdx/seamcall.h > @@ -0,0 +1,99 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* Copyright (C) 2025 Intel Corporation */ Should this be updated to 2026?
On Wed, Jan 28, 2026 at 09:37:05AM +0800, Binbin Wu wrote: > > >On 1/23/2026 10:55 PM, Chao Gao wrote: >> From: Kai Huang <kai.huang@intel.com> >> >> TDX host core code implements three seamcall*() helpers to make SEAMCALL >> to the TDX module. Currently, they are implemented in <asm/tdx.h> and >> are exposed to other kernel code which includes <asm/tdx.h>. >> >> However, other than the TDX host core, seamcall*() are not expected to >> be used by other kernel code directly. For instance, for all SEAMCALLs >> that are used by KVM, the TDX host core exports a wrapper function for >> each of them. >> >> Move seamcall*() and related code out of <asm/tdx.h> and make them only >> visible to TDX host core. >> >> Since TDX host core tdx.c is already very heavy, don't put low level >> seamcall*() code there but to a new dedicated "seamcall.h". Also, >> currently tdx.c has seamcall_prerr*() helpers which additionally print >> error message when calling seamcall*() fails. Move them to "seamcall.h" >> as well. In such way all low level SEAMCALL helpers are in a dedicated >> place, which is much more readable. >> >> Signed-off-by: Kai Huang <kai.huang@intel.com> >> Signed-off-by: Chao Gao <chao.gao@intel.com> >> Reviewed-by: Zhenzhong Duan <zhenzhong.duan@intel.com> > >Reviewed-by: Binbin Wu <binbin.wu@linux.intel.com> > >One question below. > >[...] > >> diff --git a/arch/x86/virt/vmx/tdx/seamcall.h b/arch/x86/virt/vmx/tdx/seamcall.h >> new file mode 100644 >> index 000000000000..0912e03fabfe >> --- /dev/null >> +++ b/arch/x86/virt/vmx/tdx/seamcall.h >> @@ -0,0 +1,99 @@ >> +/* SPDX-License-Identifier: GPL-2.0 */ >> +/* Copyright (C) 2025 Intel Corporation */ > >Should this be updated to 2026? Yes. And I may drop the copyright notice if it is not necessary. According to [1][2], it seems to be optional or even discouraged. [1]: https://lwn.net/Articles/912355/ [2]: https://www.linuxfoundation.org/blog/blog/copyright-notices-in-open-source-software-projects
On 1/28/26 04:42, Chao Gao wrote: >>> diff --git a/arch/x86/virt/vmx/tdx/seamcall.h b/arch/x86/virt/vmx/tdx/seamcall.h >>> new file mode 100644 >>> index 000000000000..0912e03fabfe >>> --- /dev/null >>> +++ b/arch/x86/virt/vmx/tdx/seamcall.h >>> @@ -0,0 +1,99 @@ >>> +/* SPDX-License-Identifier: GPL-2.0 */ >>> +/* Copyright (C) 2025 Intel Corporation */ >> Should this be updated to 2026? > Yes. And I may drop the copyright notice if it is not necessary. No. The copyright is to document the timing of a creative action. Moving code is not a creative action. If you want to remove it, do it in another patch. If you move code, just _move_ _the_ _code_. You can _maybe_ clean up whitespace if you want to along the way. But that's it. Don't muck with it unless you have a reason. A *good* reason.
On Wed, Jan 28, 2026 at 08:31:26AM -0800, Dave Hansen wrote: >On 1/28/26 04:42, Chao Gao wrote: >>>> diff --git a/arch/x86/virt/vmx/tdx/seamcall.h b/arch/x86/virt/vmx/tdx/seamcall.h >>>> new file mode 100644 >>>> index 000000000000..0912e03fabfe >>>> --- /dev/null >>>> +++ b/arch/x86/virt/vmx/tdx/seamcall.h >>>> @@ -0,0 +1,99 @@ >>>> +/* SPDX-License-Identifier: GPL-2.0 */ >>>> +/* Copyright (C) 2025 Intel Corporation */ >>> Should this be updated to 2026? >> Yes. And I may drop the copyright notice if it is not necessary. > >No. Sorry. I am a bit confused.. > >The copyright is to document the timing of a creative action. Moving >code is not a creative action. This sounds like we don't need to add copyright notices for moving code. > >If you want to remove it, do it in another patch. If you move code, just >_move_ _the_ _code_. You can _maybe_ clean up whitespace if you want to >along the way. But that's it. Don't muck with it unless you have a >reason. A *good* reason. But this sounds like the copyright notice should be kept. Do you mean the copyright notices from the original files should be carried over to the new file? This patch extracts code from arch/x86/include/asm/tdx.h and arch/x86/virt/vmx/tdx/tdx.c. They have: Copyright (C) 2021-2022 Intel Corporation Copyright(c) 2023 Intel Corporation. So for the new file, the copyright notice should be Copyright (C) 2021-2023 Intel Corporation ?
On 1/29/26 06:02, Chao Gao wrote:' ... > But this sounds like the copyright notice should be kept. > > Do you mean the copyright notices from the original files should be carried > over to the new file? > > This patch extracts code from arch/x86/include/asm/tdx.h and > arch/x86/virt/vmx/tdx/tdx.c. They have: > > Copyright (C) 2021-2022 Intel Corporation > Copyright(c) 2023 Intel Corporation. > > So for the new file, the copyright notice should be > > Copyright (C) 2021-2023 Intel Corporation > ? The most straightforward thing to do is to copy the gunk from the original file: Copyright (C) 2021-2023 Intel Corporation ... which is as of today the "official" Intel way of doing it with the "(C)" just like that. along with: /* SPDX-License-Identifier: GPL-2.0 */ and a note in the changelog about what you did. There's no need to do any more than that because that's what git is for.
On Fri, Jan 23, 2026 at 06:55:11AM -0800, Chao Gao wrote: > From: Kai Huang <kai.huang@intel.com> > > TDX host core code implements three seamcall*() helpers to make SEAMCALL > to the TDX module. Currently, they are implemented in <asm/tdx.h> and > are exposed to other kernel code which includes <asm/tdx.h>. > > However, other than the TDX host core, seamcall*() are not expected to > be used by other kernel code directly. For instance, for all SEAMCALLs > that are used by KVM, the TDX host core exports a wrapper function for > each of them. > > Move seamcall*() and related code out of <asm/tdx.h> and make them only > visible to TDX host core. Reviewed-by: Tony Lindgren <tony.lindgren@linux.intel.com>
© 2016 - 2026 Red Hat, Inc.