1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
// SPDX-License-Identifier: GPL-2.0
/*
* TDX host user interface driver
*
* Copyright (C) 2025 Intel Corporation
*/
#include <linux/device/faux.h>
#include <linux/firmware.h>
#include <linux/module.h>
#include <linux/sysfs.h>
#include <asm/cpu_device_id.h>
#include <asm/seamldr.h>
#include <asm/tdx.h>
static const struct x86_cpu_id tdx_host_ids[] = {
X86_MATCH_FEATURE(X86_FEATURE_TDX_HOST_PLATFORM, NULL),
{}
};
MODULE_DEVICE_TABLE(x86cpu, tdx_host_ids);
static ssize_t version_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
const struct tdx_sys_info *tdx_sysinfo = tdx_get_sysinfo();
const struct tdx_sys_info_version *ver;
int ret;
if (!tdx_sysinfo)
return -ENXIO;
/*
* The version number can change during an update.
* Lock out updates while printing the version.
*/
seamldr_lock_module_update();
ver = &tdx_sysinfo->version;
ret = sysfs_emit(buf, TDX_VERSION_FMT "\n", ver->major_version,
ver->minor_version,
ver->update_version);
seamldr_unlock_module_update();
return ret;
}
static DEVICE_ATTR_RO(version);
static struct attribute *tdx_host_attrs[] = {
&dev_attr_version.attr,
NULL,
};
static const struct attribute_group tdx_host_group = {
.attrs = tdx_host_attrs,
};
static ssize_t seamldr_version_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct seamldr_info info;
int ret;
ret = seamldr_get_info(&info);
if (ret)
return ret;
return sysfs_emit(buf, TDX_VERSION_FMT "\n", info.major_version,
info.minor_version,
info.update_version);
}
static ssize_t num_remaining_updates_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct seamldr_info info;
int ret;
ret = seamldr_get_info(&info);
if (ret)
return ret;
return sysfs_emit(buf, "%u\n", info.num_remaining_updates);
}
/*
* These attributes are intended for managing TDX module updates. Reading
* them issues a slow, serialized P-SEAMLDR query, so keep them admin-only.
*/
static DEVICE_ATTR_ADMIN_RO(seamldr_version);
static DEVICE_ATTR_ADMIN_RO(num_remaining_updates);
static struct attribute *seamldr_attrs[] = {
&dev_attr_seamldr_version.attr,
&dev_attr_num_remaining_updates.attr,
NULL,
};
static bool supports_runtime_update(void)
{
const struct tdx_sys_info *sysinfo = tdx_get_sysinfo();
if (!sysinfo)
return false;
if (!tdx_supports_runtime_update(sysinfo))
return false;
/*
* This bug makes P-SEAMLDR calls clobber the current VMCS
* which breaks KVM. Avoid P-SEAMLDR calls by hiding all
* attributes if the CPU has this bug.
*/
if (boot_cpu_has_bug(X86_BUG_SEAMRET_INVD_VMCS))
return false;
return true;
}
static umode_t seamldr_group_visible(struct kobject *kobj, struct attribute *attr, int idx)
{
if (!supports_runtime_update())
return 0;
return attr->mode;
}
static const struct attribute_group seamldr_group = {
.attrs = seamldr_attrs,
.is_visible = seamldr_group_visible,
};
static const struct attribute_group *tdx_host_groups[] = {
&tdx_host_group,
&seamldr_group,
NULL,
};
static enum fw_upload_err tdx_fw_prepare(struct fw_upload *fwl,
const u8 *data, u32 data_len)
{
return FW_UPLOAD_ERR_NONE;
}
static enum fw_upload_err tdx_fw_write(struct fw_upload *fwl, const u8 *data,
u32 offset, u32 data_len, u32 *written)
{
int ret;
ret = seamldr_install_module(data, data_len);
switch (ret) {
case 0:
*written = data_len;
return FW_UPLOAD_ERR_NONE;
default:
return FW_UPLOAD_ERR_FW_INVALID;
}
}
static enum fw_upload_err tdx_fw_poll_complete(struct fw_upload *fwl)
{
/*
* The upload completed during tdx_fw_write().
* Never poll for completion.
*/
return FW_UPLOAD_ERR_NONE;
}
static void tdx_fw_cancel(struct fw_upload *fwl)
{
/*
* TDX module updates are not cancellable.
* Provide a no-op callback to satisfy fw_upload_ops.
*/
}
static const struct fw_upload_ops tdx_fw_ops = {
.prepare = tdx_fw_prepare,
.write = tdx_fw_write,
.poll_complete = tdx_fw_poll_complete,
.cancel = tdx_fw_cancel,
};
static void seamldr_deinit(void *tdx_fwl)
{
firmware_upload_unregister(tdx_fwl);
}
static int seamldr_init(struct device *dev)
{
struct fw_upload *tdx_fwl;
if (!supports_runtime_update())
return 0;
tdx_fwl = firmware_upload_register(THIS_MODULE, dev, "tdx_module",
&tdx_fw_ops, NULL);
if (IS_ERR(tdx_fwl))
return PTR_ERR(tdx_fwl);
return devm_add_action_or_reset(dev, seamldr_deinit, tdx_fwl);
}
static int tdx_host_probe(struct faux_device *fdev)
{
return seamldr_init(&fdev->dev);
}
static const struct faux_device_ops tdx_host_ops = {
.probe = tdx_host_probe,
};
static struct faux_device *fdev;
static int __init tdx_host_init(void)
{
if (!x86_match_cpu(tdx_host_ids) || !tdx_get_sysinfo())
return -ENODEV;
fdev = faux_device_create_with_groups(KBUILD_MODNAME, NULL,
&tdx_host_ops,
tdx_host_groups);
if (!fdev)
return -ENODEV;
return 0;
}
module_init(tdx_host_init);
static void __exit tdx_host_exit(void)
{
faux_device_destroy(fdev);
}
module_exit(tdx_host_exit);
MODULE_DESCRIPTION("TDX Host Services");
MODULE_LICENSE("GPL");
|
