| 0/0 |
2026/05/26 05:01 |
flow |
assessment-security |
57m
Results: map[DenialOfService:false Explanation:Based on the analysis of the bug report and the kernel source code, here is the
assessment of the security impact:
**Bug Mechanism:**
The warning `ioremap: invalid physical address 4ff4208dd89fe53e` is triggered in
`__ioremap_caller` when the kernel attempts to map an invalid physical address.
The stack trace shows this occurs during a PCI bus rescan (`dev_rescan_store` ->
`pci_rescan_bus` -> ... -> `pcibios_device_add`).
In `pcibios_device_add`, the kernel iterates over the
`boot_params.hdr.setup_data` linked list to find `SETUP_PCI` ROMs. It maps each
entry using `memremap`. If the `next` pointer of a `setup_data` entry contains a
garbage value (like `4ff4208dd89fe53e`), `memremap` will attempt to map it.
Since this garbage address is not valid RAM, it falls back to `ioremap_cache`,
which checks `phys_addr_valid()` and triggers the `WARN_ON_ONCE`.
Since this warning occurs during a runtime sysfs write (`syz.5.5717`) and not
during the initial boot PCI enumeration, the `setup_data` chain must have been
valid during boot but became corrupted later. This typically happens when the
bootloader (e.g., QEMU) places the `setup_data` chain in memory that the kernel
later frees (such as overlapping with or immediately following the `initrd`
which gets freed by `free_initrd_mem`). Once freed, the memory is reallocated
and overwritten with arbitrary data. When a PCI rescan is later triggered, the
kernel reads the overwritten memory, encounters the garbage `next` pointer, and
triggers the warning.
**Security Impact:**
* **Exploitable:** No. The bug results in a `WARN_ON_ONCE` and `memremap` safely
returning `NULL`. The calling function (`pcibios_device_add`) handles the `NULL`
return by returning `-ENOMEM`. There is no memory corruption, out-of-bounds
access, or use-after-free caused by this bug itself (the kernel is just reading
its own reused memory).
* **Denial Of Service:** No. It is a non-fatal warning. The specific PCI device
being added might fail to initialize its ROM or MSI domain properly, but the
system continues to operate.
* **Accessible From Unprivileged Processes / User Namespaces:** No. Triggering a
PCI rescan via `/sys/bus/pci/devices/.../rescan` requires global root privileges
(`0200` permissions, owned by global root). It cannot be triggered by
unprivileged users or from within a user namespace.
* **VM Guest Trigger:** No. The bug is internal to the guest kernel and does not
affect the host.
* **VM Host Trigger in The Confidential Computing Context:** Yes. In a
confidential computing environment (like AMD SEV or Intel TDX), the host VMM
provides the `boot_params` and `setup_data` to the guest. A malicious host can
intentionally provide a malformed `setup_data` chain with an invalid physical
address to trigger this warning in the guest during boot.
* **Peripheral Trigger:** Yes. Physically plugging in a Thunderbolt/USB4 device
triggers a PCI hotplug event. This scans the new PCI bus and calls
`pci_device_add` -> `pcibios_device_add`. If the `setup_data` was previously
corrupted (e.g., by the initrd freeing issue), plugging in the peripheral will
trigger the warning.
* **Network / Remote / Filesystem Trigger:** No. The bug is strictly related to
PCI device enumeration and boot parameters. Exploitable:false FilesystemTrigger:false NetworkTrigger:false PeripheralTrigger:true RemoteTrigger:false Unprivileged:false UserNamespace:false VMGuestTrigger:false VMHostTrigger:true]
|
| 1/1 |
2026/05/26 05:01 |
action |
syz-repro-to-c-repro |
0m
Results:
|
| 2/1 |
2026/05/26 05:01 |
action |
kernel-checkouter |
0m
Results: map[KernelSrc:/app/workdir/cache/src/9357ac3721766faf3e40ccf90da1e28fc7351fa2]
|
| 3/1 |
2026/05/26 05:01 |
action |
kernel-builder |
25m
Results: map[KernelObj:/app/workdir/cache/build/d9ef8700cf14db03626fe47f3976a465b0fb622b]
|
| 4/1 |
2026/05/26 05:26 |
action |
codesearch-prepare |
18m
Results: map[Index:codesearch-index]
|
| 5/1 |
2026/05/26 05:44 |
agent |
expert |
13m
Model:
Results: map[DenialOfService:false Exploitable:false FilesystemTrigger:false NetworkTrigger:false PeripheralTrigger:true RemoteTrigger:false Unprivileged:false UserNamespace:false VMGuestTrigger:false VMHostTrigger:true]
Instruction:
You are an experienced Linux kernel security engineer. Your task is to analyze given kernel bug report
and determine its security impact based on the following dimensions.
Use the provided tools to examine the source code, check for capability checks (e.g., capable(), ns_capable()),
and understand the nature of the bug. Analyze the given kernel build and configuration.
You can check the kernel config by grepping ".config" file; you can check kernel cmdline by greeping
".config" file for "CONFIG_CMDLINE=". Assume sysctl parameters have default values.
But analyze for the corresponding production build w/o debugging tools enabled (like KASAN, KMSAN, UBSAN).
Try different strategies when analyzing the bug:
- think of ways in which the vulnerable code is unreachable
- or the other way around: try to come up with different ideas of how an unprivileged user can reach the bug
If still unsure err on the side of the bug being non-exploitable/not-accessible.
In the final reply, provide a reasoning for your assessment.
Analysis dimensions:
* Exploitable:
Determine if the bug can result in memory corruption or elevated privileges.
Memory safety issues are almost always exploitable (KASAN or UBSAN reports for use-after-free, out-of-bounds;
refcounting issues, corrupted lists, etc). When kernel is crashing on a completly wild pointer access
(e.g. user-space address, or non-canonical address, but not on NULL or address corresponding to KASAN shadow
for NULL address), including both data accesses and control tranfers, that's also usually implies possibility
of exploitation. Such reports usually say "unable to handle kernel paging request".
Uses of uninitialized values detected by KMSAN may be exploitable b/c attacker frequently can affect uninit
values with spraying techniques. However, for these exploitabability depends on how exactly the uninit value
is used in the code, and what it affects.
Think of what happens after the bug is triggered. Some bugs cause kernel panic and halt execution,
they are harder to exploit. For example, BUG reports halts the kernel. However, WARNING reports don't halt
execution in production builds. Debug bug detection tools (like KASAN, KMSAN, KCSAN, UBSAN) are also not enabled
in production builds, so attacker can freely exploit these bugs w/o being detected by these tools.
If you see an integer overflow, think how the overflowed value used later (if it's used as allocation size,
or an array index). If you see an out-of-bounds read, think if it's followed by an out-of-bounds write as well.
Some KCSAN data-races may be exploitable by skilled attackers as well. Think what data structures got corrupted
as the result of data races and how. However, note that kernel has lots of "benign" data races that don't lead
to any runtime misbehavior at all.
* Denial Of Service:
Determine if the bug can result in denial-of-service. Most bugs can, since they cause system crash,
hangs, deadlocks, or resource leaks. This is mostly applicable to WARNING bugs that won't cause system crash
in production. For these think what will be consequences of the violation of the kernel assumptions flagged
by the WARNING. In some cases the unexpected condition is also properly handled by the normal control flow
(e.g. with "if (WARN_ON(...))"), these won't cause denial-of-service. If the condition is not handled,
then it may or may not cause denial-of-service.
* Accessible From Unprivileged Processes:
Determine if the bug can be reached from a typical (non-root) user process that does NOT have any special capabilities
(like CAP_SYS_ADMIN, CAP_NET_ADMIN, CAP_NET_RAW, CAP_PERFMON) or access to device nodes restricted to root.
Assume that unprivileged_bpf_disabled=1, that is eBPF loading is not accessible. However, cBPF (classical BPF)
is still accessible to non-root processes.
Assume that user namespaces are not accessible, that is, the process cannot get the mentioned capabilities even
within a new user namespace (checked by ns_capable() function in the kernel sources).
* Accessible From User Namespaces:
Determine if the bug can be reached within a user-namespace where the process has all capabilities
(including CAP_SYS_ADMIN, CAP_NET_ADMIN, CAP_NET_RAW, CAP_PERFMON). Such capabilities are checked with ns_capable()
function in the kernel sources.
* VM Guest Trigger:
Determine if the bug can be triggered from the context of a typical KVM guest (e.g., set up by a QEMU VMM).
Consider accesses to standard Linux host paravirtualized features (virtio-blk, virtio-net, etc.),
and handling of VM exits in the KVM code.
* VM Host Trigger in The Confidetial Computing Context:
Determine if the bug can be triggered in a confidential computing guest kernel from the context of a KVM host.
Consider access to standard Linux guest paravirtualized features (virtio-blk, virtio-net, etc.).
* Ethernet Network Trigger:
Determine if the bug can be triggered by processing ingress network Ethernet traffic, either directly (network stack)
or via drivers exposed to network data.
* Other Remote Trigger:
Determine if the bug can be triggered by processing remote traffic other than Ethernet (Wifi, Bluetooth, NFC, etc).
* Peripheral Trigger:
Determine if the bug can be triggered via an untrusted peripheral device that can be physically plugged
into a system, such as a USB device or a niche hardware driver handling external hardware inputs.
This is particularly important for mobile and desktop environments where users can plug in unknown devices.
* Malicious Filesystem Trigger:
Determine if the bug can be triggered by the kernel mounting and parsing a malicious filesystem image.
This is highly critical for Desktop and Mobile environments where external media or downloaded images
might be auto-mounted.
Don't make assumptions about the kernel source code (it may be different from what you assume it is).
Extensively use the provided code access tools (codesearch-*, git-*, grepper, etc)
to examine the actual source code, and confirm any assumptions.
Prefer calling several tools at the same time to save round-trips.
Use set-results tool to provide results of the analysis.
It must be called exactly once before the final reply.
Ignore results of this tool.
Prompt:
The kernel bug report is:
ioremap: invalid physical address 4ff4208dd89fe53e
------------[ cut here ]------------
1
WARNING: arch/x86/mm/ioremap.c:206 at __ioremap_caller.isra.0.cold+0x59/0xa4 arch/x86/mm/ioremap.c:206, CPU#0: syz.5.5717/30414
Modules linked in:
CPU: 0 UID: 0 PID: 30414 Comm: syz.5.5717 Tainted: G L syzkaller #0 PREEMPT(full)
Tainted: [L]=SOFTLOCKUP
Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 03/18/2026
RIP: 0010:__ioremap_caller.isra.0.cold+0x59/0xa4 arch/x86/mm/ioremap.c:206
Code: 48 8b 34 24 48 c7 c7 e0 fc ab 8b e8 20 1d 01 00 e9 c1 c4 97 00 e8 b6 db e6 00 4c 89 ee 48 c7 c7 40 fb ab 8b e8 07 1d 01 00 90 <0f> 0b 90 e9 a1 c4 97 00 e8 99 db e6 00 41 0f b6 d7 4c 89 ee 48 c7
RSP: 0018:ffffc9000426f700 EFLAGS: 00010286
RAX: 0000000000000032 RBX: 1ffff9200084dee4 RCX: 0000000000000000
RDX: 0000000000000032 RSI: ffffffff81e6f1a9 RDI: fffff5200084ded1
RBP: 0000000000000040 R08: 0000000000000005 R09: 0000000000000000
R10: 0000000080000000 R11: 000000000008e030 R12: 4ff4208dd89fe57d
R13: 4ff4208dd89fe53e R14: 0000000000000000 R15: 0000000000013fd0
FS: 00007f4bd6ff66c0(0000) GS:ffff888124332000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 000020000017f000 CR3: 0000000038ace000 CR4: 00000000003526f0
Call Trace:
<TASK>
ioremap_cache arch/x86/mm/ioremap.c:436 [inline]
arch_memremap_wb+0x23/0x40 arch/x86/mm/ioremap.c:508
memremap+0x1cb/0x7d0 kernel/iomem.c:95
pcibios_device_add+0x101/0x600 arch/x86/pci/common.c:652
pci_device_add+0xd4f/0x1810 drivers/pci/probe.c:2760
pci_scan_single_device drivers/pci/probe.c:2792 [inline]
pci_scan_single_device+0x1d0/0x240 drivers/pci/probe.c:2778
pci_scan_slot+0x1c9/0x7c0 drivers/pci/probe.c:2875
pci_scan_child_bus_extend+0x6b/0x7b0 drivers/pci/probe.c:3094
pci_scan_child_bus drivers/pci/probe.c:3207 [inline]
pci_rescan_bus+0x18/0x40 drivers/pci/probe.c:3498
dev_rescan_store+0x11b/0x140 drivers/pci/pci-sysfs.c:505
dev_attr_store+0x58/0x80 drivers/base/core.c:2437
sysfs_kf_write+0xf2/0x150 fs/sysfs/file.c:142
kernfs_fop_write_iter+0x3e0/0x5f0 fs/kernfs/file.c:352
new_sync_write fs/read_write.c:595 [inline]
vfs_write+0x6ac/0x1070 fs/read_write.c:688
ksys_write+0x12a/0x250 fs/read_write.c:740
do_syscall_x64 arch/x86/entry/syscall_64.c:63 [inline]
do_syscall_64+0x10b/0xf80 arch/x86/entry/syscall_64.c:94
entry_SYSCALL_64_after_hwframe+0x77/0x7f
RIP: 0033:0x7f4bd8d9c819
Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 e8 ff ff ff f7 d8 64 89 01 48
RSP: 002b:00007f4bd6ff6028 EFLAGS: 00000246 ORIG_RAX: 0000000000000001
RAX: ffffffffffffffda RBX: 00007f4bd9016270 RCX: 00007f4bd8d9c819
RDX: 0000000000000081 RSI: 0000200000000040 RDI: 0000000000000009
RBP: 00007f4bd8e32c91 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000
R13: 00007f4bd9016308 R14: 00007f4bd9016270 R15: 00007ffcc728ff08
</TASK>
Reply: Based on the analysis of the bug report and the kernel source code, here is the assessment of the security impact:
**Bug Mechanism:**
The warning `ioremap: invalid physical address 4ff4208dd89fe53e` is triggered in `__ioremap_caller` when the kernel attempts to map an invalid physical address. The stack trace shows this occurs during a PCI bus rescan (`dev_rescan_store` -> `pci_rescan_bus` -> ... -> `pcibios_device_add`).
In `pcibios_device_add`, the kernel iterates over the `boot_params.hdr.setup_data` linked list to find `SETUP_PCI` ROMs. It maps each entry using `memremap`. If the `next` pointer of a `setup_data` entry contains a garbage value (like `4ff4208dd89fe53e`), `memremap` will attempt to map it. Since this garbage address is not valid RAM, it falls back to `ioremap_cache`, which checks `phys_addr_valid()` and triggers the `WARN_ON_ONCE`.
Since this warning occurs during a runtime sysfs write (`syz.5.5717`) and not during the initial boot PCI enumeration, the `setup_data` chain must have been valid during boot but became corrupted later. This typically happens when the bootloader (e.g., QEMU) places the `setup_data` chain in memory that the kernel later frees (such as overlapping with or immediately following the `initrd` which gets freed by `free_initrd_mem`). Once freed, the memory is reallocated and overwritten with arbitrary data. When a PCI rescan is later triggered, the kernel reads the overwritten memory, encounters the garbage `next` pointer, and triggers the warning.
**Security Impact:**
* **Exploitable:** No. The bug results in a `WARN_ON_ONCE` and `memremap` safely returning `NULL`. The calling function (`pcibios_device_add`) handles the `NULL` return by returning `-ENOMEM`. There is no memory corruption, out-of-bounds access, or use-after-free caused by this bug itself (the kernel is just reading its own reused memory).
* **Denial Of Service:** No. It is a non-fatal warning. The specific PCI device being added might fail to initialize its ROM or MSI domain properly, but the system continues to operate.
* **Accessible From Unprivileged Processes / User Namespaces:** No. Triggering a PCI rescan via `/sys/bus/pci/devices/.../rescan` requires global root privileges (`0200` permissions, owned by global root). It cannot be triggered by unprivileged users or from within a user namespace.
* **VM Guest Trigger:** No. The bug is internal to the guest kernel and does not affect the host.
* **VM Host Trigger in The Confidential Computing Context:** Yes. In a confidential computing environment (like AMD SEV or Intel TDX), the host VMM provides the `boot_params` and `setup_data` to the guest. A malicious host can intentionally provide a malformed `setup_data` chain with an invalid physical address to trigger this warning in the guest during boot.
* **Peripheral Trigger:** Yes. Physically plugging in a Thunderbolt/USB4 device triggers a PCI hotplug event. This scans the new PCI bus and calls `pci_device_add` -> `pcibios_device_add`. If the `setup_data` was previously corrupted (e.g., by the initrd freeing issue), plugging in the peripheral will trigger the warning.
* **Network / Remote / Filesystem Trigger:** No. The bug is strictly related to PCI device enumeration and boot parameters.
|
| 6/2 |
2026/05/26 05:44 |
llm |
expert |
0m
Model:
Tokens:
input: 7450
output: 47
thoughts: 322
Thoughts: **Analyzing a Kernel Bug Report: Ioremap Warning in PCI Rescan**
Okay, here's what I'm seeing: there's a kernel bug report popping up a warning related to `ioremap`. Specifically, it's: `WARNING: arch/x86/mm/ioremap.c:206 at __ioremap_caller.isra.0.cold+0x59/0xa4 arch/x86/mm/ioremap.c:206`. The call stack is quite extensive, which I expect from this kind of low-level memory mapping issue, and it looks like it all starts with `ioremap_cache` leading to `arch_memremap_wb` then `memremap`, eventually culminating in a call to `ksys_write` via `dev_rescan_store`.
The critical piece seems to be that this occurs when writing to a sysfs file, `/sys/bus/pci/devices/.../rescan`, which is intriguing. The warning mentions "invalid physical address 4ff4208dd89fe53e" during the `ioremap` process. This is the core issue that needs to be addressed.
I know `dev_rescan_store` is the function triggered by writing to that specific sysfs file, `/sys/bus/pci/devices/.../rescan`. That's where my focus needs to be. I'll need to dive into `drivers/pci/pci-sysfs.c` and start examining `dev_rescan_store` to see where the invalid physical address might be coming from during the rescan process. It appears we're doing something that triggers an invalid `ioremap` call during PCI device rescan.
|
| 7/2 |
2026/05/26 05:45 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:drivers/pci/pci-sysfs.c IncludeLines:true Name:dev_rescan_store]
Results: map[SourceCode: 493: static ssize_t dev_rescan_store(struct device *dev,
494: struct device_attribute *attr, const char *buf,
495: size_t count)
496: {
497: unsigned long val;
498: struct pci_dev *pdev = to_pci_dev(dev);
499:
500: if (kstrtoul(buf, 0, &val) < 0)
501: return -EINVAL;
502:
503: if (val) {
504: pci_lock_rescan_remove();
505: pci_rescan_bus(pdev->bus);
506: pci_unlock_rescan_remove();
507: }
508: return count;
509: }
SourceFile:drivers/pci/pci-sysfs.c]
|
| 8/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 8476
output: 55
thoughts: 33
Thoughts: Here's my take on the thought process, as if it were my own:
**Investigating PCI Device Rescan Permissions**
Okay, so I need to interact with `/sys/bus/pci/devices/.../rescan`. My immediate concern, as always when dealing with `sysfs`, is permissions. I'm pretty sure that writing to that particular file requires root. But let's not assume, let's verify. I'm going to quickly check the file permissions on `/sys/bus/pci/devices/.../rescan` to make sure I'm correct. Gotta dot my i's and cross my t's, especially with something that could potentially trigger a device re-enumeration! No point running the rest of the script if I'm going to run into a permission denied error. Let's see what the access control list says.
|
| 9/2 |
2026/05/26 05:45 |
tool |
codesearch-find-references |
0m
Args: map[ContextFile:drivers/pci/pci-sysfs.c IncludeSnippetLines:5 Name:dev_rescan_store SourceTreePrefix:]
Results: map[References:<nil> TruncatedOutput:false]
|
| 10/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 8765
output: 20
thoughts: 18
Thoughts: Okay, here's my thought process on that:
**Investigating `dev_rescan_store` Usage**
Alright, before I proceed any further, I need to take a step back and get a handle on how this `dev_rescan_store` function is actually being employed. I can't just dive in without understanding the context and purpose of its use. Knowing *where* and *why* it's called is crucial for understanding its impact and ensuring any modifications I make are sound and don't introduce regressions or unforeseen consequences. A careful examination of its call sites will be time well spent. I need to trace its usage to solidify my understanding before I consider any changes to it.
|
| 11/2 |
2026/05/26 05:45 |
tool |
grepper |
0m
Args: map[Expression:dev_rescan_store]
Results: map[Output:drivers/pci/pci-sysfs.c=488=const struct attribute_group *pci_bus_groups[] = {
--
drivers/pci/pci-sysfs.c-492-
drivers/pci/pci-sysfs.c:493:static ssize_t dev_rescan_store(struct device *dev,
drivers/pci/pci-sysfs.c-494- struct device_attribute *attr, const char *buf,
--
drivers/pci/pci-sysfs.c=510=static struct device_attribute dev_attr_dev_rescan = __ATTR(rescan, 0200, NULL,
drivers/pci/pci-sysfs.c:511: dev_rescan_store);
drivers/pci/pci-sysfs.c-512-
]
|
| 12/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 9173
output: 46
thoughts: 206
Thoughts: **Analyzing PCI Device Rescan Permissions**
Okay, so the permissions on `/sys/bus/pci/devices/.../rescan` are set to `0200`, meaning it's write-only, and only by the owner. That owner is `root`. So, obviously, an unprivileged process can't touch it. That's expected.
But what about user namespaces? I need to think this through. My initial gut feeling is that `sysfs` is typically read-only within a user namespace, or at the very least, PCI-related sysfs files aren't owned by the user namespace root. They're tied to the initial namespace.
Hang on... can a user namespace even *mount* `sysfs`? Yes, but it's only going to see network devices if the user namespace also owns the network namespace. PCI devices, though, they're not namespace-aware. Theyβre owned by the `GLOBAL_ROOT_UID`. Therefore, a process running within a user namespace won't be able to write to it unless it has a global root UID mapped. And mapping that requiresβ¦ well, global root privileges.
So, yeah, it's pretty clear: a process in a user namespace can't manipulate `/sys/bus/pci/devices/.../rescan` without having global root level privileges. No dice there.
Time to go check that warning in `arch/x86/mm/ioremap.c:206`. I need to figure out why this is even on my radar.
|
| 13/2 |
2026/05/26 05:45 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/mm/ioremap.c IncludeLines:true Name:__ioremap_caller]
Results: map[SourceCode: 169: /*
170: * Remap an arbitrary physical address space into the kernel virtual
171: * address space. It transparently creates kernel huge I/O mapping when
172: * the physical address is aligned by a huge page size (1GB or 2MB) and
173: * the requested size is at least the huge page size.
174: *
175: * NOTE: MTRRs can override PAT memory types with a 4KB granularity.
176: * Therefore, the mapping code falls back to use a smaller page toward 4KB
177: * when a mapping range is covered by non-WB type of MTRRs.
178: *
179: * NOTE! We need to allow non-page-aligned mappings too: we will obviously
180: * have to convert them into an offset in a page-aligned mapping, but the
181: * caller shouldn't need to know that small detail.
182: */
183: static void __iomem *
184: __ioremap_caller(resource_size_t phys_addr, unsigned long size,
185: enum page_cache_mode pcm, void *caller, bool encrypted)
186: {
187: unsigned long offset, vaddr;
188: resource_size_t last_addr;
189: const resource_size_t unaligned_phys_addr = phys_addr;
190: const unsigned long unaligned_size = size;
191: struct ioremap_desc io_desc;
192: struct vm_struct *area;
193: enum page_cache_mode new_pcm;
194: pgprot_t prot;
195: int retval;
196: void __iomem *ret_addr;
197:
198: /* Don't allow wraparound or zero size */
199: last_addr = phys_addr + size - 1;
200: if (!size || last_addr < phys_addr)
201: return NULL;
202:
203: if (!phys_addr_valid(phys_addr)) {
204: printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
205: (unsigned long long)phys_addr);
206: WARN_ON_ONCE(1);
207: return NULL;
208: }
209:
210: __ioremap_check_mem(phys_addr, size, &io_desc);
211:
212: /*
213: * Don't allow anybody to remap normal RAM that we're using..
214: */
215: if (io_desc.flags & IORES_MAP_SYSTEM_RAM) {
216: WARN_ONCE(1, "ioremap on RAM at %pa - %pa\n",
217: &phys_addr, &last_addr);
218: return NULL;
219: }
220:
221: /*
222: * Mappings have to be page-aligned
223: */
224: offset = phys_addr & ~PAGE_MASK;
225: phys_addr &= PAGE_MASK;
226: size = PAGE_ALIGN(last_addr+1) - phys_addr;
227:
228: /*
229: * Mask out any bits not part of the actual physical
230: * address, like memory encryption bits.
231: */
232: phys_addr &= PHYSICAL_PAGE_MASK;
233:
234: retval = memtype_reserve(phys_addr, (u64)phys_addr + size,
235: pcm, &new_pcm);
236: if (retval) {
237: printk(KERN_ERR "ioremap memtype_reserve failed %d\n", retval);
238: return NULL;
239: }
240:
241: if (pcm != new_pcm) {
242: if (!is_new_memtype_allowed(phys_addr, size, pcm, new_pcm)) {
243: printk(KERN_ERR
244: "ioremap error for 0x%llx-0x%llx, requested 0x%x, got 0x%x\n",
245: (unsigned long long)phys_addr,
246: (unsigned long long)(phys_addr + size),
247: pcm, new_pcm);
248: goto err_free_memtype;
249: }
250: pcm = new_pcm;
251: }
252:
253: /*
254: * If the page being mapped is in memory and SEV is active then
255: * make sure the memory encryption attribute is enabled in the
256: * resulting mapping.
257: * In TDX guests, memory is marked private by default. If encryption
258: * is not requested (using encrypted), explicitly set decrypt
259: * attribute in all IOREMAPPED memory.
260: */
261: prot = PAGE_KERNEL_IO;
262: if ((io_desc.flags & IORES_MAP_ENCRYPTED) || encrypted)
263: prot = pgprot_encrypted(prot);
264: else
265: prot = pgprot_decrypted(prot);
266:
267: switch (pcm) {
268: case _PAGE_CACHE_MODE_UC:
269: default:
270: prot = __pgprot(pgprot_val(prot) |
271: cachemode2protval(_PAGE_CACHE_MODE_UC));
272: break;
273: case _PAGE_CACHE_MODE_UC_MINUS:
274: prot = __pgprot(pgprot_val(prot) |
275: cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS));
276: break;
277: case _PAGE_CACHE_MODE_WC:
278: prot = __pgprot(pgprot_val(prot) |
279: cachemode2protval(_PAGE_CACHE_MODE_WC));
280: break;
281: case _PAGE_CACHE_MODE_WT:
282: prot = __pgprot(pgprot_val(prot) |
283: cachemode2protval(_PAGE_CACHE_MODE_WT));
284: break;
285: case _PAGE_CACHE_MODE_WB:
286: break;
287: }
288:
289: /*
290: * Ok, go for it..
291: */
292: area = get_vm_area_caller(size, VM_IOREMAP, caller);
293: if (!area)
294: goto err_free_memtype;
295: area->phys_addr = phys_addr;
296: vaddr = (unsigned long) area->addr;
297:
298: if (memtype_kernel_map_sync(phys_addr, size, pcm))
299: goto err_free_area;
300:
301: if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot))
302: goto err_free_area;
303:
304: ret_addr = (void __iomem *) (vaddr + offset);
305: mmiotrace_ioremap(unaligned_phys_addr, unaligned_size, ret_addr);
306:
307: /*
308: * Check if the request spans more than any BAR in the iomem resource
309: * tree.
310: */
311: if (iomem_map_sanity_check(unaligned_phys_addr, unaligned_size))
312: pr_warn("caller %pS mapping multiple BARs\n", caller);
313:
314: return ret_addr;
315: err_free_area:
316: free_vm_area(area);
317: err_free_memtype:
318: memtype_free(phys_addr, phys_addr + size);
319: return NULL;
320: }
SourceFile:arch/x86/mm/ioremap.c]
|
| 14/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 12152
output: 48
thoughts: 124
Thoughts: **Investigating a Suspected Memory Mapping Issue**
Okay, so I've hit a `WARN_ON_ONCE(1)` β a one-time warning β and it's flagged when `phys_addr` is invalid. The specific address in question is `4ff4208dd89fe53e`. That looks like a pretty random physical address, but I need to investigate. This warning is triggered by a sequence of calls: `memremap` down to `arch_memremap_wb` and finally through `ioremap_cache`. This suggests a problem with how we are attempting to remap a physical memory region. Digging deeper, the call stack traces back to `pcibios_device_add`, which means there could be an issue related to PCI device initialization. It's calling `pci_device_add` then `pci_scan_single_device`, so my immediate focus needs to be on how `pcibios_device_add` is handling that invalid physical address. Let's start by scrutinizing the logic within `pcibios_device_add` and see if there are any obvious missteps in its memory management.
|
| 15/2 |
2026/05/26 05:45 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/pci/common.c IncludeLines:true Name:pcibios_device_add]
Results: map[SourceCode: 643: int pcibios_device_add(struct pci_dev *dev)
644: {
645: struct pci_setup_rom *rom;
646: struct irq_domain *msidom;
647: struct setup_data *data;
648: u64 pa_data;
649:
650: pa_data = boot_params.hdr.setup_data;
651: while (pa_data) {
652: data = memremap(pa_data, sizeof(*rom), MEMREMAP_WB);
653: if (!data)
654: return -ENOMEM;
655:
656: if (data->type == SETUP_PCI) {
657: rom = (struct pci_setup_rom *)data;
658:
659: if ((pci_domain_nr(dev->bus) == rom->segment) &&
660: (dev->bus->number == rom->bus) &&
661: (PCI_SLOT(dev->devfn) == rom->device) &&
662: (PCI_FUNC(dev->devfn) == rom->function) &&
663: (dev->vendor == rom->vendor) &&
664: (dev->device == rom->devid)) {
665: dev->rom = pa_data +
666: offsetof(struct pci_setup_rom, romdata);
667: dev->romlen = rom->pcilen;
668: }
669: }
670: pa_data = data->next;
671: memunmap(data);
672: }
673: set_dev_domain_options(dev);
674:
675: /*
676: * Setup the initial MSI domain of the device. If the underlying
677: * bus has a PCI/MSI irqdomain associated use the bus domain,
678: * otherwise set the default domain. This ensures that special irq
679: * domains e.g. VMD are preserved. The default ensures initial
680: * operation if irq remapping is not active. If irq remapping is
681: * active it will overwrite the domain pointer when the device is
682: * associated to a remapping domain.
683: */
684: msidom = dev_get_msi_domain(&dev->bus->dev);
685: if (!msidom)
686: msidom = x86_pci_msi_default_domain;
687: dev_set_msi_domain(&dev->dev, msidom);
688: return 0;
689: }
SourceFile:arch/x86/pci/common.c]
|
| 16/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 13378
output: 52
thoughts: 314
Thoughts: **Analyzing a Potential Kernel Memory Corruption Vulnerability**
Okay, so I'm looking at this code and immediately see `pa_data = boot_params.hdr.setup_data;`. Right, `boot_params` is populated by the bootloader β makes sense. Now, the potential problem is that if `boot_params.hdr.setup_data` points to an invalid physical address, `memremap` will be called on it, and `ioremap` will throw a warning, which is bad news. Hold on though, I see that `pa_data` is then updated to `data->next`. Okay, so if *that* `data->next` is an invalid physical address, the next loop iteration will have the same problem, calling `memremap` and complaining.
The question then becomes, where does this `boot_params` come from? Right, it's the x86 boot parameters. And in a virtual machine, the VMM, QEMU or even something like syzkaller's custom VMM, can control these parameters. So, in the syzkaller context, it's most likely running this within a VM. Can syzkaller inject or corrupt the `setup_data` chain?
Ah, I think that's it. Syzkaller can inject it via `syz_kvm_setup_cpu` or something similar. Or perhaps it's a corrupted `setup_data` chain provided by the bootloader itself, or potentially syzkaller directly corrupts `boot_params` memory somehow?
Okay, so `boot_params` is a global kernel variable. To really understand this, I need to check where it's defined and how it's used. Let's trace back to see if it's something that can be modified directly within the kernel.
|
| 17/2 |
2026/05/26 05:45 |
tool |
codesearch-find-references |
0m
Args: map[ContextFile:arch/x86/pci/common.c IncludeSnippetLines:0 Name:boot_params SourceTreePrefix:]
Results: map[References:[map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:mem_map_via_hcall SourceFile:arch/x86/platform/pvh/enlighten.c SourceLine:35] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:35] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:52] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:58] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:59] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:60] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:61] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:62] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:63] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:64] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:65] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:66] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:67] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:68] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:69] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:70] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:71] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:72] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:73] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:74] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:75] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:76] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:57] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sanitize_boot_params SourceFile:arch/x86/include/asm/bootparam_utils.h SourceLine:77] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sev_enable SourceFile:arch/x86/include/asm/sev.h SourceLine:608] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sme_enable SourceFile:arch/x86/include/asm/mem_encrypt.h SourceLine:85] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:sme_encrypt_kernel SourceFile:arch/x86/include/asm/mem_encrypt.h SourceLine:84] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:snp_init SourceFile:arch/x86/include/asm/sev.h SourceLine:619] map[ReferenceKind:uses ReferencingEntityKind:function ReferencingEntityName:xen_pvh_init SourceFile:arch/x86/platform/pvh/enlighten.c SourceLine:100]] TruncatedOutput:false]
|
| 18/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 16883
output: 17
thoughts: 594
Thoughts: **Analyzing a Kernel Bug: A Deep Dive**
Okay, so I'm looking at this kernel issue, and my initial thought is: *`boot_params` is a global variable. Interesting...* I need to figure out how it's getting corrupted. My first instinct is to see if there's some sysfs or debugfs file that allows modification of `boot_params` or `setup_data`. Is this something that's being directly manipulated? Or, is Syzkaller just hammering the VM with a garbage `setup_data` chain during boot?
If it *is* an invalid `setup_data` chain from boot, then that indicates either a VM Host Trigger (if the host is passing it along), or a VM Guest Trigger (if the bootloader itself is creating the issue).
But wait... the bug report mentions a running process, `syz.5.5717`, with PID 30414. It seems the system has already booted. This means Syzkaller is triggering the issue *after* boot. The process is writing to `/sys/bus/pci/devices/.../rescan`, which is clearly the key. This triggers a PCI device scan: `pci_rescan_bus` -> `pci_scan_child_bus` -> `pci_scan_slot` -> `pci_scan_single_device` -> `pci_device_add` -> `pcibios_device_add`. Ah, I see! In `pcibios_device_add`, it's iterating over `boot_params.hdr.setup_data`.
The problem is likely a malformed linked list: a loop, or a bad physical address. That's what's causing the warning. The question is, how did `boot_params.hdr.setup_data` get corrupted in the first place? Did Syzkaller somehow modify it *at runtime*, or was it invalid from the beginning, but only getting triggered now when a PCI device is added?
If it was invalid from the beginning, `pcibios_device_add` should have triggered it during *boot*, when the initial PCI devices were being added. I need to know if PCI devices are added during boot. It *should* be, as this is a Google Compute Engine VM. But if PCI devices are present, then I'd expect `pcibios_device_add` to have been called already during boot.
Let's confirm that `pcibios_device_add` *is* called during boot, for every PCI device. Okay, it is. So if `boot_params.hdr.setup_data` was bad from the start, we would've crashed already during boot. So that's out.
Unless... Syzkaller is somehow modifying `boot_params` at runtime? How could that be? Does it have `/dev/mem` write access? Syzkaller *usually* doesn't have this, but... is it possible? This is crucial. Wait... is `boot_params` exposed in sysfs? Perhaps it's writable through sysfs or debugfs? I need to check.
|
| 19/2 |
2026/05/26 05:45 |
tool |
grepper |
0m
Args: map[Expression:boot_params]
Results: map[Output:
Full output is too long, showing 500 out of 3089 lines.
Use more precise expression if possible.
[Documentation/ABI/testing/sysfs-kernel-boot_params:1:What: /sys/kernel/boot_params
Documentation/ABI/testing/sysfs-kernel-boot_params-2-Date: December 2013
Documentation/ABI/testing/sysfs-kernel-boot_params=3=Contact: Dave Young <dyoung@redhat.com>
Documentation/ABI/testing/sysfs-kernel-boot_params:4:Description: The /sys/kernel/boot_params directory contains two
Documentation/ABI/testing/sysfs-kernel-boot_params-5- files: "data" and "version" and one subdirectory "setup_data".
--
Documentation/ABI/testing/sysfs-kernel-boot_params-8-
Documentation/ABI/testing/sysfs-kernel-boot_params:9: If there's no setup_data in boot_params the subdirectory will
Documentation/ABI/testing/sysfs-kernel-boot_params-10- not be created.
Documentation/ABI/testing/sysfs-kernel-boot_params-11-
Documentation/ABI/testing/sysfs-kernel-boot_params:12: "data" file is the binary representation of struct boot_params.
Documentation/ABI/testing/sysfs-kernel-boot_params-13-
--
Documentation/ABI/testing/sysfs-kernel-boot_params-17- "setup_data" subdirectory contains the setup_data data
Documentation/ABI/testing/sysfs-kernel-boot_params:18: structure in boot_params. setup_data is maintained in kernel
Documentation/ABI/testing/sysfs-kernel-boot_params-19- as a link list. In "setup_data" subdirectory there's one
--
Documentation/ABI/testing/sysfs-kernel-boot_params-25-
Documentation/ABI/testing/sysfs-kernel-boot_params:26: The whole boot_params directory structure is like below::
Documentation/ABI/testing/sysfs-kernel-boot_params-27-
Documentation/ABI/testing/sysfs-kernel-boot_params:28: /sys/kernel/boot_params
Documentation/ABI/testing/sysfs-kernel-boot_params-29- |__ data
--
Documentation/arch/x86/boot.rst=64=Protocol 2.12 (Kernel 3.8) Added the xloadflags field and extension fields
Documentation/arch/x86/boot.rst:65: to struct boot_params for loading bzImage and ramdisk
Documentation/arch/x86/boot.rst-66- above 4G in 64bit.
--
Documentation/arch/x86/boot.rst=77=Protocol 2.15 (Kernel 5.5) Added the kernel_info and kernel_info.setup_type_max.
--
Documentation/arch/x86/boot.rst-81- The protocol version number should be changed only if the setup header
Documentation/arch/x86/boot.rst:82: is changed. There is no need to update the version number if boot_params
Documentation/arch/x86/boot.rst-83- or kernel_info are changed. Additionally, it is recommended to use
--
Documentation/arch/x86/boot.rst=699=Protocol: 2.12+
--
Documentation/arch/x86/boot.rst-709-
Documentation/arch/x86/boot.rst:710: - If 1, kernel/boot_params/cmdline/ramdisk can be above 4G.
Documentation/arch/x86/boot.rst-711-
--
Documentation/arch/x86/boot.rst=941=sections::
--
Documentation/arch/x86/boot.rst-943- setup_header = .data
Documentation/arch/x86/boot.rst:944: boot_params/setup_data = .bss
Documentation/arch/x86/boot.rst-945-
--
Documentation/arch/x86/boot.rst=951=a long time, for lack of alternatives and -- especially early on -- inertia.
Documentation/arch/x86/boot.rst:952:Also, the BIOS stub is responsible for creating boot_params, so it isn't
Documentation/arch/x86/boot.rst-953-available to a BIOS-based loader (setup_data is, though).
--
Documentation/arch/x86/boot.rst=955=setup_header is permanently limited to 144 bytes due to the reach of the
Documentation/arch/x86/boot.rst-956-2-byte jump field, which doubles as a length field for the structure, combined
Documentation/arch/x86/boot.rst:957:with the size of the "hole" in struct boot_params that a protected-mode loader
Documentation/arch/x86/boot.rst-958-or the BIOS stub has to copy it into. It is currently 119 bytes long, which
--
Documentation/arch/x86/boot.rst=960=without revising the boot protocol entirely, breaking backwards compatibility.
Documentation/arch/x86/boot.rst-961-
Documentation/arch/x86/boot.rst:962:boot_params proper is limited to 4096 bytes, but can be arbitrarily extended
Documentation/arch/x86/boot.rst-963-by adding setup_data entries. It cannot be used to communicate properties of
--
Documentation/arch/x86/boot.rst=1332=In 32-bit boot protocol, the first step in loading a Linux kernel
Documentation/arch/x86/boot.rst:1333:should be to setup the boot parameters (struct boot_params,
Documentation/arch/x86/boot.rst:1334:traditionally known as "zero page"). The memory for struct boot_params
Documentation/arch/x86/boot.rst-1335-should be allocated and initialized to all zero. Then the setup header
Documentation/arch/x86/boot.rst=1336=from offset 0x01f1 of kernel image on should be loaded into struct
Documentation/arch/x86/boot.rst:1337:boot_params and examined. The end of setup header can be calculated as
Documentation/arch/x86/boot.rst-1338-follow::
--
Documentation/arch/x86/boot.rst=1342=In addition to read/modify/write the setup header of the struct
Documentation/arch/x86/boot.rst:1343:boot_params as that of 16-bit boot protocol, the boot loader should
Documentation/arch/x86/boot.rst:1344:also fill the additional fields of the struct boot_params as
Documentation/arch/x86/boot.rst-1345-described in chapter Documentation/arch/x86/zero-page.rst.
Documentation/arch/x86/boot.rst-1346-
Documentation/arch/x86/boot.rst:1347:After setting up the struct boot_params, the boot loader can load the
Documentation/arch/x86/boot.rst-1348-32/64-bit kernel in the same way as that of 16-bit boot protocol.
--
Documentation/arch/x86/boot.rst=1359=must be __BOOT_DS; interrupt must be disabled; %esi must hold the base
Documentation/arch/x86/boot.rst:1360:address of the struct boot_params; %ebp, %edi and %ebx must be zero.
Documentation/arch/x86/boot.rst-1361-
--
Documentation/arch/x86/boot.rst=1368=In 64-bit boot protocol, the first step in loading a Linux kernel
Documentation/arch/x86/boot.rst:1369:should be to setup the boot parameters (struct boot_params,
Documentation/arch/x86/boot.rst:1370:traditionally known as "zero page"). The memory for struct boot_params
Documentation/arch/x86/boot.rst-1371-could be allocated anywhere (even above 4G) and initialized to all zero.
Documentation/arch/x86/boot.rst=1372=Then, the setup header at offset 0x01f1 of kernel image on should be
Documentation/arch/x86/boot.rst:1373:loaded into struct boot_params and examined. The end of setup header
Documentation/arch/x86/boot.rst-1374-can be calculated as follows::
--
Documentation/arch/x86/boot.rst=1378=In addition to read/modify/write the setup header of the struct
Documentation/arch/x86/boot.rst:1379:boot_params as that of 16-bit boot protocol, the boot loader should
Documentation/arch/x86/boot.rst:1380:also fill the additional fields of the struct boot_params as described
Documentation/arch/x86/boot.rst-1381-in chapter Documentation/arch/x86/zero-page.rst.
Documentation/arch/x86/boot.rst-1382-
Documentation/arch/x86/boot.rst:1383:After setting up the struct boot_params, the boot loader can load
Documentation/arch/x86/boot.rst-1384-64-bit kernel in the same way as that of 16-bit boot protocol, but
--
Documentation/arch/x86/boot.rst=1398=must be __BOOT_DS; interrupt must be disabled; %rsi must hold the base
Documentation/arch/x86/boot.rst:1399:address of the struct boot_params.
Documentation/arch/x86/boot.rst-1400-
--
Documentation/arch/x86/boot.rst=1416=The function prototype for the handover entry point looks like this::
Documentation/arch/x86/boot.rst-1417-
Documentation/arch/x86/boot.rst:1418: void efi_stub_entry(void *handle, efi_system_table_t *table, struct boot_params *bp);
Documentation/arch/x86/boot.rst-1419-
--
Documentation/arch/x86/boot.rst=1455=This approach removes the need for any knowledge on the part of the EFI
Documentation/arch/x86/boot.rst:1456:bootloader regarding the internal representation of boot_params or any
Documentation/arch/x86/boot.rst-1457-requirements/limitations regarding the placement of the command line and
--
Documentation/arch/x86/intel_txt.rst=94=How Does it Work?
--
Documentation/arch/x86/intel_txt.rst-146-
Documentation/arch/x86/intel_txt.rst:147: - The location of the shared page is passed via the boot_params
Documentation/arch/x86/intel_txt.rst-148- struct as a physical address.
--
Documentation/arch/x86/zero-page.rst=4=Zero Page
Documentation/arch/x86/zero-page.rst-5-=========
Documentation/arch/x86/zero-page.rst:6:The additional fields in struct boot_params as a part of 32-bit boot
Documentation/arch/x86/zero-page.rst-7-protocol of kernel. These should be filled by bootloader or 16-bit
--
arch/arc/plat-axs10x/axs10x.c=300=static void __init axs103_early_init(void)
--
arch/arc/plat-axs10x/axs10x.c-314- u32 freq;
arch/arc/plat-axs10x/axs10x.c:315: int off = fdt_path_offset(initial_boot_params, "/cpu_card/core_clk");
arch/arc/plat-axs10x/axs10x.c-316- const struct fdt_property *prop;
arch/arc/plat-axs10x/axs10x.c-317-
arch/arc/plat-axs10x/axs10x.c:318: prop = fdt_get_property(initial_boot_params, off,
arch/arc/plat-axs10x/axs10x.c-319- "assigned-clock-rates", NULL);
--
arch/arc/plat-axs10x/axs10x.c-324- freq = cpu_to_be32(AXS103_QUAD_CORE_CPU_FREQ_HZ);
arch/arc/plat-axs10x/axs10x.c:325: fdt_setprop_inplace(initial_boot_params, off,
arch/arc/plat-axs10x/axs10x.c-326- "assigned-clock-rates", &freq, sizeof(freq));
--
arch/arc/plat-hsdk/platform.c=88=static int __init hsdk_tweak_node_coherency(const char *path, bool coherent)
arch/arc/plat-hsdk/platform.c-89-{
arch/arc/plat-hsdk/platform.c:90: void *fdt = initial_boot_params;
arch/arc/plat-hsdk/platform.c-91- const void *prop;
--
arch/arm/mach-pxa/gumstix.c=230=MACHINE_START(GUMSTIX, "Gumstix")
arch/arm/mach-pxa/gumstix.c:231: .atag_offset = 0x100, /* match u-boot bi_boot_params */
arch/arm/mach-pxa/gumstix.c-232- .map_io = pxa25x_map_io,
--
arch/arm64/kernel/acpi.c=72=static bool __init dt_is_stub(void)
--
arch/arm64/kernel/acpi.c-75-
arch/arm64/kernel/acpi.c:76: fdt_for_each_subnode(node, initial_boot_params, 0) {
arch/arm64/kernel/acpi.c:77: const char *name = fdt_get_name(initial_boot_params, node, NULL);
arch/arm64/kernel/acpi.c-78- if (strcmp(name, "chosen") == 0)
--
arch/loongarch/kernel/setup.c=306=static void __init bootcmdline_init(char **cmdline_p)
--
arch/loongarch/kernel/setup.c-324- */
arch/loongarch/kernel/setup.c:325: if (initial_boot_params) {
arch/loongarch/kernel/setup.c-326- if (boot_command_line[0])
--
arch/mips/cavium-octeon/octeon-platform.c=483=static void __init octeon_fdt_set_phy(int eth, int phy_addr)
--
arch/mips/cavium-octeon/octeon-platform.c-494-
arch/mips/cavium-octeon/octeon-platform.c:495: phy_handle = fdt_getprop(initial_boot_params, eth, "phy-handle", NULL);
arch/mips/cavium-octeon/octeon-platform.c-496- if (!phy_handle)
--
arch/mips/cavium-octeon/octeon-platform.c-499- phandle = be32_to_cpup(phy_handle);
arch/mips/cavium-octeon/octeon-platform.c:500: phy = fdt_node_offset_by_phandle(initial_boot_params, phandle);
arch/mips/cavium-octeon/octeon-platform.c-501-
arch/mips/cavium-octeon/octeon-platform.c:502: alt_phy_handle = fdt_getprop(initial_boot_params, eth, "cavium,alt-phy-handle", NULL);
arch/mips/cavium-octeon/octeon-platform.c-503- if (alt_phy_handle) {
--
arch/mips/cavium-octeon/octeon-platform.c-505-
arch/mips/cavium-octeon/octeon-platform.c:506: alt_phy = fdt_node_offset_by_phandle(initial_boot_params, alt_phandle);
arch/mips/cavium-octeon/octeon-platform.c-507- } else {
--
arch/mips/cavium-octeon/octeon-platform.c-512- /* Delete the PHY things */
arch/mips/cavium-octeon/octeon-platform.c:513: fdt_nop_property(initial_boot_params, eth, "phy-handle");
arch/mips/cavium-octeon/octeon-platform.c-514- /* This one may fail */
arch/mips/cavium-octeon/octeon-platform.c:515: fdt_nop_property(initial_boot_params, eth, "cavium,alt-phy-handle");
arch/mips/cavium-octeon/octeon-platform.c-516- if (phy >= 0)
arch/mips/cavium-octeon/octeon-platform.c:517: fdt_nop_node(initial_boot_params, phy);
arch/mips/cavium-octeon/octeon-platform.c-518- if (alt_phy >= 0)
arch/mips/cavium-octeon/octeon-platform.c:519: fdt_nop_node(initial_boot_params, alt_phy);
arch/mips/cavium-octeon/octeon-platform.c-520- return;
--
arch/mips/cavium-octeon/octeon-platform.c-528- /* Use the alt phy node instead.*/
arch/mips/cavium-octeon/octeon-platform.c:529: phy_prop = fdt_get_property(initial_boot_params, eth, "phy-handle", NULL);
arch/mips/cavium-octeon/octeon-platform.c-530- phy_handle_name = phy_prop->nameoff;
arch/mips/cavium-octeon/octeon-platform.c:531: fdt_nop_node(initial_boot_params, phy);
arch/mips/cavium-octeon/octeon-platform.c:532: fdt_nop_property(initial_boot_params, eth, "phy-handle");
arch/mips/cavium-octeon/octeon-platform.c:533: alt_prop = fdt_get_property_w(initial_boot_params, eth, "cavium,alt-phy-handle", NULL);
arch/mips/cavium-octeon/octeon-platform.c-534- alt_prop->nameoff = phy_handle_name;
--
arch/mips/cavium-octeon/octeon-platform.c-540- if (octeon_has_88e1145()) {
arch/mips/cavium-octeon/octeon-platform.c:541: fdt_nop_property(initial_boot_params, phy, "marvell,reg-init");
arch/mips/cavium-octeon/octeon-platform.c-542- strscpy_pad(new_name, "marvell,88e1145");
arch/mips/cavium-octeon/octeon-platform.c:543: p = fdt_getprop(initial_boot_params, phy, "compatible",
arch/mips/cavium-octeon/octeon-platform.c-544- ¤t_len);
arch/mips/cavium-octeon/octeon-platform.c-545- if (p && current_len >= strlen(new_name))
arch/mips/cavium-octeon/octeon-platform.c:546: fdt_setprop_inplace(initial_boot_params, phy,
arch/mips/cavium-octeon/octeon-platform.c-547- "compatible", new_name, current_len);
--
arch/mips/cavium-octeon/octeon-platform.c-549-
arch/mips/cavium-octeon/octeon-platform.c:550: reg = fdt_getprop(initial_boot_params, phy, "reg", NULL);
arch/mips/cavium-octeon/octeon-platform.c-551- if (phy_addr == be32_to_cpup(reg))
--
arch/mips/cavium-octeon/octeon-platform.c-553-
arch/mips/cavium-octeon/octeon-platform.c:554: fdt_setprop_inplace_cell(initial_boot_params, phy, "reg", phy_addr);
arch/mips/cavium-octeon/octeon-platform.c-555-
--
arch/mips/cavium-octeon/octeon-platform.c-557-
arch/mips/cavium-octeon/octeon-platform.c:558: p = fdt_get_name(initial_boot_params, phy, ¤t_len);
arch/mips/cavium-octeon/octeon-platform.c-559- if (p && current_len == strlen(new_name))
arch/mips/cavium-octeon/octeon-platform.c:560: fdt_set_name(initial_boot_params, phy, new_name);
arch/mips/cavium-octeon/octeon-platform.c-561- else
--
arch/mips/cavium-octeon/octeon-platform.c=565=static void __init octeon_fdt_set_mac_addr(int n, u64 *pmac)
--
arch/mips/cavium-octeon/octeon-platform.c-572-
arch/mips/cavium-octeon/octeon-platform.c:573: old_mac = fdt_getprop(initial_boot_params, n, "local-mac-address",
arch/mips/cavium-octeon/octeon-platform.c-574- &old_len);
--
arch/mips/cavium-octeon/octeon-platform.c-584-
arch/mips/cavium-octeon/octeon-platform.c:585: r = fdt_setprop_inplace(initial_boot_params, n, "local-mac-address",
arch/mips/cavium-octeon/octeon-platform.c-586- new_mac, sizeof(new_mac));
--
arch/mips/cavium-octeon/octeon-platform.c=595=static void __init octeon_fdt_rm_ethernet(int node)
--
arch/mips/cavium-octeon/octeon-platform.c-598-
arch/mips/cavium-octeon/octeon-platform.c:599: phy_handle = fdt_getprop(initial_boot_params, node, "phy-handle", NULL);
arch/mips/cavium-octeon/octeon-platform.c-600- if (phy_handle) {
arch/mips/cavium-octeon/octeon-platform.c-601- u32 ph = be32_to_cpup(phy_handle);
arch/mips/cavium-octeon/octeon-platform.c:602: int p = fdt_node_offset_by_phandle(initial_boot_params, ph);
arch/mips/cavium-octeon/octeon-platform.c-603-
arch/mips/cavium-octeon/octeon-platform.c-604- if (p >= 0)
arch/mips/cavium-octeon/octeon-platform.c:605: fdt_nop_node(initial_boot_params, p);
arch/mips/cavium-octeon/octeon-platform.c-606- }
arch/mips/cavium-octeon/octeon-platform.c:607: fdt_nop_node(initial_boot_params, node);
arch/mips/cavium-octeon/octeon-platform.c-608-}
--
arch/mips/cavium-octeon/octeon-platform.c=610=static void __init _octeon_rx_tx_delay(int eth, int rx_delay, int tx_delay)
arch/mips/cavium-octeon/octeon-platform.c-611-{
arch/mips/cavium-octeon/octeon-platform.c:612: fdt_setprop_inplace_cell(initial_boot_params, eth, "rx-delay",
arch/mips/cavium-octeon/octeon-platform.c-613- rx_delay);
arch/mips/cavium-octeon/octeon-platform.c:614: fdt_setprop_inplace_cell(initial_boot_params, eth, "tx-delay",
arch/mips/cavium-octeon/octeon-platform.c-615- tx_delay);
--
arch/mips/cavium-octeon/octeon-platform.c=618=static void __init octeon_rx_tx_delay(int eth, int iface, int port)
--
arch/mips/cavium-octeon/octeon-platform.c-644- }
arch/mips/cavium-octeon/octeon-platform.c:645: fdt_nop_property(initial_boot_params, eth, "rx-delay");
arch/mips/cavium-octeon/octeon-platform.c:646: fdt_nop_property(initial_boot_params, eth, "tx-delay");
arch/mips/cavium-octeon/octeon-platform.c-647-}
--
arch/mips/cavium-octeon/octeon-platform.c=649=static void __init octeon_fdt_pip_port(int iface, int i, int p, int max)
--
arch/mips/cavium-octeon/octeon-platform.c-657- snprintf(name_buffer, sizeof(name_buffer), "ethernet@%x", p);
arch/mips/cavium-octeon/octeon-platform.c:658: eth = fdt_subnode_offset(initial_boot_params, iface, name_buffer);
arch/mips/cavium-octeon/octeon-platform.c-659- if (eth < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-673-
arch/mips/cavium-octeon/octeon-platform.c:674: fixed_link = fdt_subnode_offset(initial_boot_params, eth, "fixed-link");
arch/mips/cavium-octeon/octeon-platform.c-675- if (fixed_link < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-677- else if (!octeon_has_fixed_link(ipd_port))
arch/mips/cavium-octeon/octeon-platform.c:678: fdt_nop_node(initial_boot_params, fixed_link);
arch/mips/cavium-octeon/octeon-platform.c-679- octeon_rx_tx_delay(eth, i, p);
--
arch/mips/cavium-octeon/octeon-platform.c=682=static void __init octeon_fdt_pip_iface(int pip, int idx)
--
arch/mips/cavium-octeon/octeon-platform.c-689- snprintf(name_buffer, sizeof(name_buffer), "interface@%d", idx);
arch/mips/cavium-octeon/octeon-platform.c:690: iface = fdt_subnode_offset(initial_boot_params, pip, name_buffer);
arch/mips/cavium-octeon/octeon-platform.c-691- if (iface < 0)
--
arch/mips/cavium-octeon/octeon-platform.c=701=void __init octeon_fill_mac_addresses(void)
--
arch/mips/cavium-octeon/octeon-platform.c-709-
arch/mips/cavium-octeon/octeon-platform.c:710: aliases = fdt_path_offset(initial_boot_params, "/aliases");
arch/mips/cavium-octeon/octeon-platform.c-711- if (aliases < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-725- snprintf(name_buffer, sizeof(name_buffer), "mix%d", i);
arch/mips/cavium-octeon/octeon-platform.c:726: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-727- name_buffer, NULL);
--
arch/mips/cavium-octeon/octeon-platform.c-729- continue;
arch/mips/cavium-octeon/octeon-platform.c:730: mgmt = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-731- if (mgmt < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-735-
arch/mips/cavium-octeon/octeon-platform.c:736: alias_prop = fdt_getprop(initial_boot_params, aliases, "pip", NULL);
arch/mips/cavium-octeon/octeon-platform.c-737- if (!alias_prop)
--
arch/mips/cavium-octeon/octeon-platform.c-739-
arch/mips/cavium-octeon/octeon-platform.c:740: pip = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-741- if (pip < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-748- snprintf(name_buffer, sizeof(name_buffer), "interface@%d", i);
arch/mips/cavium-octeon/octeon-platform.c:749: iface = fdt_subnode_offset(initial_boot_params, pip,
arch/mips/cavium-octeon/octeon-platform.c-750- name_buffer);
--
arch/mips/cavium-octeon/octeon-platform.c-757- "ethernet@%x", p);
arch/mips/cavium-octeon/octeon-platform.c:758: eth = fdt_subnode_offset(initial_boot_params, iface,
arch/mips/cavium-octeon/octeon-platform.c-759- name_buffer);
--
arch/mips/cavium-octeon/octeon-platform.c=767=int __init octeon_prune_device_tree(void)
--
arch/mips/cavium-octeon/octeon-platform.c-774-
arch/mips/cavium-octeon/octeon-platform.c:775: if (fdt_check_header(initial_boot_params))
arch/mips/cavium-octeon/octeon-platform.c-776- panic("Corrupt Device Tree.");
--
arch/mips/cavium-octeon/octeon-platform.c-781-
arch/mips/cavium-octeon/octeon-platform.c:782: aliases = fdt_path_offset(initial_boot_params, "/aliases");
arch/mips/cavium-octeon/octeon-platform.c-783- if (aliases < 0) {
--
arch/mips/cavium-octeon/octeon-platform.c-802- "mix%d", i);
arch/mips/cavium-octeon/octeon-platform.c:803: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-804- name_buffer, NULL);
arch/mips/cavium-octeon/octeon-platform.c-805- if (alias_prop) {
arch/mips/cavium-octeon/octeon-platform.c:806: mgmt = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-807- if (mgmt < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-811- octeon_fdt_rm_ethernet(mgmt);
arch/mips/cavium-octeon/octeon-platform.c:812: fdt_nop_property(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-813- name_buffer);
--
arch/mips/cavium-octeon/octeon-platform.c-821-
arch/mips/cavium-octeon/octeon-platform.c:822: pip_path = fdt_getprop(initial_boot_params, aliases, "pip", NULL);
arch/mips/cavium-octeon/octeon-platform.c-823- if (pip_path) {
arch/mips/cavium-octeon/octeon-platform.c:824: int pip = fdt_path_offset(initial_boot_params, pip_path);
arch/mips/cavium-octeon/octeon-platform.c-825-
--
arch/mips/cavium-octeon/octeon-platform.c-844- "twsi%d", i);
arch/mips/cavium-octeon/octeon-platform.c:845: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-846- name_buffer, NULL);
--
arch/mips/cavium-octeon/octeon-platform.c-848- if (alias_prop) {
arch/mips/cavium-octeon/octeon-platform.c:849: i2c = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-850- if (i2c < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-853- pr_debug("Deleting twsi%d\n", i);
arch/mips/cavium-octeon/octeon-platform.c:854: fdt_nop_node(initial_boot_params, i2c);
arch/mips/cavium-octeon/octeon-platform.c:855: fdt_nop_property(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-856- name_buffer);
--
arch/mips/cavium-octeon/octeon-platform.c-875- "smi%d", i);
arch/mips/cavium-octeon/octeon-platform.c:876: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-877- name_buffer, NULL);
arch/mips/cavium-octeon/octeon-platform.c-878- if (alias_prop) {
arch/mips/cavium-octeon/octeon-platform.c:879: i2c = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-880- if (i2c < 0)
--
arch/mips/cavium-octeon/octeon-platform.c-883- pr_debug("Deleting smi%d\n", i);
arch/mips/cavium-octeon/octeon-platform.c:884: fdt_nop_node(initial_boot_params, i2c);
arch/mips/cavium-octeon/octeon-platform.c:885: fdt_nop_property(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-886- name_buffer);
--
arch/mips/cavium-octeon/octeon-platform.c-902- "uart%d", i);
arch/mips/cavium-octeon/octeon-platform.c:903: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-904- name_buffer, NULL);
--
arch/mips/cavium-octeon/octeon-platform.c-906- if (alias_prop) {
arch/mips/cavium-octeon/octeon-platform.c:907: uart = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-908- if (uart_mask & (1 << i)) {
--
arch/mips/cavium-octeon/octeon-platform.c-911- f = cpu_to_be32(octeon_get_io_clock_rate());
arch/mips/cavium-octeon/octeon-platform.c:912: fdt_setprop_inplace(initial_boot_params,
arch/mips/cavium-octeon/octeon-platform.c-913- uart, "clock-frequency",
--
arch/mips/cavium-octeon/octeon-platform.c-917- pr_debug("Deleting uart%d\n", i);
arch/mips/cavium-octeon/octeon-platform.c:918: fdt_nop_node(initial_boot_params, uart);
arch/mips/cavium-octeon/octeon-platform.c:919: fdt_nop_property(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-920- name_buffer);
--
arch/mips/cavium-octeon/octeon-platform.c-924- /* Compact Flash */
arch/mips/cavium-octeon/octeon-platform.c:925: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-926- "cf0", NULL);
--
arch/mips/cavium-octeon/octeon-platform.c-938-
arch/mips/cavium-octeon/octeon-platform.c:939: int cf = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-940-
--
arch/mips/cavium-octeon/octeon-platform.c-985- } else {
arch/mips/cavium-octeon/octeon-platform.c:986: fdt_nop_property(initial_boot_params, cf, "cavium,true-ide");
arch/mips/cavium-octeon/octeon-platform.c:987: fdt_nop_property(initial_boot_params, cf, "cavium,dma-engine-handle");
arch/mips/cavium-octeon/octeon-platform.c-988- if (!is_16bit) {
--
arch/mips/cavium-octeon/octeon-platform.c-990-
arch/mips/cavium-octeon/octeon-platform.c:991: fdt_setprop_inplace(initial_boot_params, cf,
arch/mips/cavium-octeon/octeon-platform.c-992- "cavium,bus-width", &width, sizeof(width));
--
arch/mips/cavium-octeon/octeon-platform.c-1000- new_reg[5] = cpu_to_be32(0x10000);
arch/mips/cavium-octeon/octeon-platform.c:1001: fdt_setprop_inplace(initial_boot_params, cf,
arch/mips/cavium-octeon/octeon-platform.c-1002- "reg", new_reg, sizeof(new_reg));
arch/mips/cavium-octeon/octeon-platform.c-1003-
arch/mips/cavium-octeon/octeon-platform.c:1004: bootbus = fdt_parent_offset(initial_boot_params, cf);
arch/mips/cavium-octeon/octeon-platform.c-1005- if (bootbus < 0)
arch/mips/cavium-octeon/octeon-platform.c-1006- goto no_cf;
arch/mips/cavium-octeon/octeon-platform.c:1007: ranges = fdt_getprop_w(initial_boot_params, bootbus, "ranges", &len);
arch/mips/cavium-octeon/octeon-platform.c-1008- if (!ranges || len < (5 * 8 * sizeof(__be32)))
--
arch/mips/cavium-octeon/octeon-platform.c-1021-no_cf:
arch/mips/cavium-octeon/octeon-platform.c:1022: fdt_nop_node(initial_boot_params, cf);
arch/mips/cavium-octeon/octeon-platform.c-1023-
--
arch/mips/cavium-octeon/octeon-platform.c-1028- /* 8 char LED */
arch/mips/cavium-octeon/octeon-platform.c:1029: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-1030- "led0", NULL);
--
arch/mips/cavium-octeon/octeon-platform.c-1037- int len;
arch/mips/cavium-octeon/octeon-platform.c:1038: int led = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-1039-
--
arch/mips/cavium-octeon/octeon-platform.c-1061- new_reg[5] = cpu_to_be32(0x20);
arch/mips/cavium-octeon/octeon-platform.c:1062: fdt_setprop_inplace(initial_boot_params, led,
arch/mips/cavium-octeon/octeon-platform.c-1063- "reg", new_reg, sizeof(new_reg));
arch/mips/cavium-octeon/octeon-platform.c-1064-
arch/mips/cavium-octeon/octeon-platform.c:1065: bootbus = fdt_parent_offset(initial_boot_params, led);
arch/mips/cavium-octeon/octeon-platform.c-1066- if (bootbus < 0)
arch/mips/cavium-octeon/octeon-platform.c-1067- goto no_led;
arch/mips/cavium-octeon/octeon-platform.c:1068: ranges = fdt_getprop_w(initial_boot_params, bootbus, "ranges", &len);
arch/mips/cavium-octeon/octeon-platform.c-1069- if (!ranges || len < (5 * 8 * sizeof(__be32)))
--
arch/mips/cavium-octeon/octeon-platform.c-1077-no_led:
arch/mips/cavium-octeon/octeon-platform.c:1078: fdt_nop_node(initial_boot_params, led);
arch/mips/cavium-octeon/octeon-platform.c-1079-end_led:
--
arch/mips/cavium-octeon/octeon-platform.c-1084- /* OHCI/UHCI USB */
arch/mips/cavium-octeon/octeon-platform.c:1085: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-1086- "uctl", NULL);
arch/mips/cavium-octeon/octeon-platform.c-1087- if (alias_prop) {
arch/mips/cavium-octeon/octeon-platform.c:1088: int uctl = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-1089-
--
arch/mips/cavium-octeon/octeon-platform.c-1092- pr_debug("Deleting uctl\n");
arch/mips/cavium-octeon/octeon-platform.c:1093: fdt_nop_node(initial_boot_params, uctl);
arch/mips/cavium-octeon/octeon-platform.c:1094: fdt_nop_property(initial_boot_params, aliases, "uctl");
arch/mips/cavium-octeon/octeon-platform.c-1095- } else if (octeon_bootinfo->board_type == CVMX_BOARD_TYPE_NIC10E ||
--
arch/mips/cavium-octeon/octeon-platform.c-1097- /* Missing "refclk-type" defaults to crystal. */
arch/mips/cavium-octeon/octeon-platform.c:1098: fdt_nop_property(initial_boot_params, uctl, "refclk-type");
arch/mips/cavium-octeon/octeon-platform.c-1099- }
--
arch/mips/cavium-octeon/octeon-platform.c-1102- /* DWC2 USB */
arch/mips/cavium-octeon/octeon-platform.c:1103: alias_prop = fdt_getprop(initial_boot_params, aliases,
arch/mips/cavium-octeon/octeon-platform.c-1104- "usbn", NULL);
arch/mips/cavium-octeon/octeon-platform.c-1105- if (alias_prop) {
arch/mips/cavium-octeon/octeon-platform.c:1106: int usbn = fdt_path_offset(initial_boot_params, alias_prop);
arch/mips/cavium-octeon/octeon-platform.c-1107-
--
arch/mips/cavium-octeon/octeon-platform.c-1110- pr_debug("Deleting usbn\n");
arch/mips/cavium-octeon/octeon-platform.c:1111: fdt_nop_node(initial_boot_params, usbn);
arch/mips/cavium-octeon/octeon-platform.c:1112: fdt_nop_property(initial_boot_params, aliases, "usbn");
arch/mips/cavium-octeon/octeon-platform.c-1113- } else {
--
arch/mips/cavium-octeon/octeon-platform.c-1120- new_f[0] = cpu_to_be32(48000000);
arch/mips/cavium-octeon/octeon-platform.c:1121: fdt_setprop_inplace(initial_boot_params, usbn,
arch/mips/cavium-octeon/octeon-platform.c-1122- "refclk-frequency", new_f, sizeof(new_f));
--
arch/mips/cavium-octeon/octeon-platform.c-1125- /* Missing "refclk-type" defaults to external. */
arch/mips/cavium-octeon/octeon-platform.c:1126: fdt_nop_property(initial_boot_params, usbn, "refclk-type");
arch/mips/cavium-octeon/octeon-platform.c-1127- break;
--
arch/mips/cavium-octeon/setup.c=1142=void __init device_tree_init(void)
--
arch/mips/cavium-octeon/setup.c-1172-
arch/mips/cavium-octeon/setup.c:1173: initial_boot_params = (void *)fdt;
arch/mips/cavium-octeon/setup.c-1174-
--
arch/mips/include/asm/mach-loongson64/boot_param.h=188=struct efi_loongson {
--
arch/mips/include/asm/mach-loongson64/boot_param.h-196-
arch/mips/include/asm/mach-loongson64/boot_param.h:197:struct boot_params {
arch/mips/include/asm/mach-loongson64/boot_param.h-198- struct efi_loongson efi;
--
arch/mips/kernel/relocate.c=215=static inline __init unsigned long get_random_boot(void)
--
arch/mips/kernel/relocate.c-227- /* Get any additional entropy passed in device tree */
arch/mips/kernel/relocate.c:228: if (initial_boot_params) {
arch/mips/kernel/relocate.c-229- int node, len;
--
arch/mips/kernel/relocate.c-231-
arch/mips/kernel/relocate.c:232: node = fdt_path_offset(initial_boot_params, "/chosen");
arch/mips/kernel/relocate.c-233- if (node >= 0) {
arch/mips/kernel/relocate.c:234: prop = fdt_getprop_w(initial_boot_params, node,
arch/mips/kernel/relocate.c-235- "kaslr-seed", &len);
--
arch/mips/loongson64/env.c=172=void __init prom_lefi_init_env(void)
arch/mips/loongson64/env.c-173-{
arch/mips/loongson64/env.c:174: struct boot_params *boot_p;
arch/mips/loongson64/env.c-175- struct loongson_params *loongson_p;
--
arch/mips/loongson64/env.c-182- /* firmware arguments are initialized in head.S */
arch/mips/loongson64/env.c:183: boot_p = (struct boot_params *)fw_arg2;
arch/mips/loongson64/env.c-184- loongson_p = &(boot_p->efi.smbios.lp);
--
arch/powerpc/kernel/prom.c=117=static void __init move_device_tree(void)
--
arch/powerpc/kernel/prom.c-123-
arch/powerpc/kernel/prom.c:124: start = __pa(initial_boot_params);
arch/powerpc/kernel/prom.c:125: size = fdt_totalsize(initial_boot_params);
arch/powerpc/kernel/prom.c-126-
--
arch/powerpc/kernel/prom.c-133- size);
arch/powerpc/kernel/prom.c:134: memcpy(p, initial_boot_params, size);
arch/powerpc/kernel/prom.c:135: initial_boot_params = p;
]
]
|
| 20/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 32207
output: 49
thoughts: 94
Thoughts: Okay, let me think this through.
**Investigating Boot Parameters in Sysfs**
Right, so I'm digging into boot parameters and I recall seeing something relevant in the documentation. Specifically, I seem to remember that `Documentation/ABI/testing/sysfs-kernel-boot_params` contains some useful information, let's see... Ah, yes, it confirms that the `/sys/kernel/boot_params` directory contains `data`, `version` and the `setup_data` sub directory. That's a good starting point. Now, the key here is the "data" file β it's the *binary representation* of `struct boot_params`. Interesting. The next question is, is this thing *writable*? Can I modify the boot parameters via sysfs? I need to check the documentation more closely, or better yet, go directly to the code that *creates* this sysfs entry. That should tell me if there are any write operations, which seems very unlikely... but I need to be sure. This warrants a deeper look.
|
| 21/2 |
2026/05/26 05:45 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/ksysfs.c IncludeLines:true Name:boot_params_data_attr]
Results: map[SourceCode: 38: static const struct bin_attribute boot_params_data_attr = {
39: .attr = {
40: .name = "data",
41: .mode = S_IRUGO,
42: },
43: .read = boot_params_data_read,
44: .size = sizeof(boot_params),
45: };
SourceFile:arch/x86/kernel/ksysfs.c]
|
| 22/2 |
2026/05/26 05:45 |
llm |
expert |
0m
Model:
Tokens:
input: 32713
output: 49
thoughts: 24
Thoughts: Here's the summary, assuming I'm an expert and this is a coding context:
**Analyzing Read-Only Data Access**
Okay, so the code's pointing at `S_IRUGO`. Right away, I see "read-only" written all over it. Nothing surprising there, but I need to make sure I understand the full implication in this specific context. This is about data access control, so I need to think carefully about the security implications. What exactly is being protected, and who or what needs read-only access?
The immediate follow-up question is about `setup_data`. This suggests that there's some sort of initialization or configuration step related to this read-only access. Is this data being prepped for use? Is the read-only flag enforced after the setup, or is it inherent to the data itself? Understanding how `setup_data` interacts with the `S_IRUGO` flag is crucial. We need to look closely at the data initialization and how we are dealing with a potentially immutable state. I need to dig deeper into the relationship and make sure that we aren't creating vulnerabilities by some interaction between the two concepts.
|
| 23/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/ksysfs.c IncludeLines:true Name:create_setup_data_node]
Results: map[SourceCode: 271: static int __init create_setup_data_node(struct kobject *parent,
272: struct kobject **kobjp, int nr)
273: {
274: int ret = 0;
275: size_t size;
276: struct kobject *kobj;
277: char name[16]; /* should be enough for setup_data nodes numbers */
278: snprintf(name, 16, "%d", nr);
279:
280: kobj = kobject_create_and_add(name, parent);
281: if (!kobj)
282: return -ENOMEM;
283:
284: ret = get_setup_data_size(nr, &size);
285: if (ret)
286: goto out_kobj;
287:
288: data_attr.size = size;
289: ret = sysfs_create_group(kobj, &setup_data_attr_group);
290: if (ret)
291: goto out_kobj;
292: *kobjp = kobj;
293:
294: return 0;
295: out_kobj:
296: kobject_put(kobj);
297: return ret;
298: }
SourceFile:arch/x86/kernel/ksysfs.c]
|
| 24/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 33463
output: 49
thoughts: 28
Thoughts: Okay, let's see...
**Analyzing Data Attribute Permissions**
Right, hold on a second. I'm looking at this `setup_data_attr_group` function and it's containing both `type` and `data` attributes, which piques my interest. It looks like it could be crucial. Given my experience, I need to immediately drill down into the permissions associated with these particular attributes. What's the context here? Are they user-defined, system-level, or somewhere in between? Are there any security implications I need to consider? I'm going to carefully review their access controls to understand how these attributes are handled and protected, because that's always the smart move. I can't leave this unexplored.
|
| 25/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/ksysfs.c IncludeLines:true Name:setup_data_attr_group]
Results: map[SourceCode: 266: static const struct attribute_group setup_data_attr_group = {
267: .attrs = setup_data_type_attrs,
268: .bin_attrs = setup_data_data_attrs,
269: };
SourceFile:arch/x86/kernel/ksysfs.c]
|
| 26/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 33800
output: 49
thoughts: 23
Thoughts: Here's my take on those thought processes:
**Checking `setup_data_type_attrs` and `setup_data_data_attrs`**
Okay, time to zero in on these data setup functions: `setup_data_type_attrs` and `setup_data_data_attrs`. My gut tells me these are critical, but I need to make sure I'm not missing anything. They are at the heart of how this data is being structured, what attributes are being defined, and how the actual data is being organized within the system.
I want to dive into the code and verify the assumptions I'm making about how data types and the data itself are being handled. Are there any edge cases? Any potential performance bottlenecks here? Understanding exactly what these functions are doing under the hood is crucial for grasping the overall data flow and identifying any areas that might require optimization or further scrutiny, especially if we're dealing with a large dataset. I need to ensure they're robust, efficient, and aligned with the overarching design principles. I'm looking for elegance and maintainability in these functions; they should be well-documented and easy to follow. Any potential refactoring points? Let's get to it.
|
| 27/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/ksysfs.c IncludeLines:true Name:setup_data_type_attrs]
Results: map[SourceCode: 256: static struct attribute *setup_data_type_attrs[] = {
257: &type_attr.attr,
258: NULL,
259: };
SourceFile:arch/x86/kernel/ksysfs.c]
|
| 28/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 34215
output: 45
thoughts: 7
Thoughts: Okay, I'm ready. Let's dive in.
**Thinking Through Attribute Types**
Hmm, so we're talking about attributes... and I'm specifically wondering about `type_attr`. What are the implications of this attribute? What's its purpose in this context? Is it controlling data validation, or defining the structure, or something else entirely? I need to understand its role within this particular system or data model.
I'm thinking, is `type_attr` a core piece, or is it a more advanced, optional feature? Does the structure of the overall design rely on its presence? What are the fallbacks if it's not set correctly? This is important because improper setting will likely cause problems down the line. I must consider edge cases too. What does an invalid or missing `type_attr` look like in terms of errors? And how does the system recover or respond? I need to think this through.
I must remember to consider the impact of `type_attr` on any kind of data transformation that occurs. If data coming into the system is somehow transformed, how does `type_attr` influence that, and how does it prevent data issues or enable more effective transformations? What about compatibility? Is this something that exists in legacy systems?
|
| 29/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/ksysfs.c IncludeLines:true Name:type_attr]
Results: map[SourceCode: 246: static struct kobj_attribute type_attr = __ATTR_RO(type);
SourceFile:arch/x86/kernel/ksysfs.c]
|
| 30/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 34593
output: 49
thoughts: 11
Thoughts: Okay, here's my attempt at summarizing the thought process, tailored for an expert audience, and written in the first person:
**Deep Dive on Data Attribute Setup**
Right, let me see... I'm looking at this code and immediately my mind jumps to that function: `setup_data_data_attrs`. I'm going through the process, considering the overall structure. It's an obvious question, so I'm thinking, what's *actually* happening in there? What's the context? Is this the right level of abstraction for handling all the data attributes, or is it getting messy? We've got a lot of data flying around in this system, so the setup of those data attributes is something that merits a close look. Is it efficient? Is it extensible? Does it integrate well with other data functions in this segment? I need to go over the design choices being made here.
|
| 31/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/ksysfs.c IncludeLines:true Name:setup_data_data_attrs]
Results: map[SourceCode: 261: static const struct bin_attribute *const setup_data_data_attrs[] = {
262: &data_attr,
263: NULL,
264: };
SourceFile:arch/x86/kernel/ksysfs.c]
|
| 32/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 34934
output: 45
thoughts: 7
Thoughts: Okay, here's my attempt at summarizing the thought process, tailored for an expert audience, and written in the first person:
**Navigating Data Attributes**
Alright, so I'm thinking about this code, specifically this section... and I keep coming back to this `data_attr`. I'm used to thinking about data attributes in the context of [mention a specific relevant field or technology the expert would likely use, e.g., "DOM manipulation" or "GraphQL metadata"]. But here, I'm trying to figure out how it's being used. Is it purely for presentation purposes, maybe a way to bind data to elements for JavaScript interaction later on? Or is it being used more fundamentally, perhaps as a way to extend the semantic meaning of the HTML structure?
I'm considering the potential impact on [mention a relevant performance or design concern, e.g., "SEO" or "accessibility"]. If we're not careful, indiscriminate use of `data_attr` could lead to some pretty messy code, especially when it comes to long-term maintainability. So the question is, what is the strategy here? What is the function in the wider context of this section of the code?
I need to delve deeper into how the data attributes are being accessed and processed. Are there any helper functions, custom libraries, or frameworks that rely on these attributes? What are the implications for [a relevant testing strategy or system, e.g., "unit testing" or "end-to-end integration"]? I'm asking myself if this is a good design pattern or something to change to a different, more structured approach to data.
|
| 33/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/ksysfs.c IncludeLines:true Name:data_attr]
Results: map[SourceCode: 248: static struct bin_attribute data_attr __ro_after_init = {
249: .attr = {
250: .name = "data",
251: .mode = S_IRUGO,
252: },
253: .read = setup_data_data_read,
254: };
SourceFile:arch/x86/kernel/ksysfs.c]
|
| 34/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 35464
output: 39
thoughts: 323
Thoughts: **Analyzing the `setup_data` Chain Vulnerability**
Okay, so the initial assumption is that these parameters are read-only. That's the starting point. If `boot_params` is read-only, how the heck is Syzkaller triggering a vulnerability related to it? The report specifically mentions Syzkaller triggering it, but... wait, Syzkaller runs in a VM, right? So, if the VM was booted with a corrupted `setup_data` chain, `pcibios_device_add` *should* have crashed during the boot process when the first PCI device was added. But the bug report shows this `syz.5.5717` triggering it with `dev_rescan_store`, which means the system booted up successfully and then Syzkaller found a way to trigger it. So how can the system successfully boot if the `boot_params.hdr.setup_data` was messed up?
Perhaps no PCI devices are added during the boot process? Let's check whether a Google Compute Engine VM has PCI devices at boot time. Okay, yes, it definitely does, things like `virtio-net` and `virtio-blk` are present. So, `pcibios_device_add` *must* have been called during boot. And if `pcibios_device_add` was called during boot, it would have iterated over `boot_params.hdr.setup_data`. If the `boot_params.hdr.setup_data` was bad, it would have crashed during boot. Hold on, could `memremap` behave differently during boot? Perhaps when `memremap` is called during boot, it doesn't call `ioremap_cache` or maybe `ioremap` does not warn? Need to check `memremap` itself, see if there's different behaviour there.
|
| 35/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:kernel/iomem.c IncludeLines:true Name:memremap]
Results: map[SourceCode: 41: /**
42: * memremap() - remap an iomem_resource as cacheable memory
43: * @offset: iomem resource start address
44: * @size: size of remap
45: * @flags: any of MEMREMAP_WB, MEMREMAP_WT, MEMREMAP_WC,
46: * MEMREMAP_ENC, MEMREMAP_DEC
47: *
48: * memremap() is "ioremap" for cases where it is known that the resource
49: * being mapped does not have i/o side effects and the __iomem
50: * annotation is not applicable. In the case of multiple flags, the different
51: * mapping types will be attempted in the order listed below until one of
52: * them succeeds.
53: *
54: * MEMREMAP_WB - matches the default mapping for System RAM on
55: * the architecture. This is usually a read-allocate write-back cache.
56: * Moreover, if MEMREMAP_WB is specified and the requested remap region is RAM
57: * memremap() will bypass establishing a new mapping and instead return
58: * a pointer into the direct map.
59: *
60: * MEMREMAP_WT - establish a mapping whereby writes either bypass the
61: * cache or are written through to memory and never exist in a
62: * cache-dirty state with respect to program visibility. Attempts to
63: * map System RAM with this mapping type will fail.
64: *
65: * MEMREMAP_WC - establish a writecombine mapping, whereby writes may
66: * be coalesced together (e.g. in the CPU's write buffers), but is otherwise
67: * uncached. Attempts to map System RAM with this mapping type will fail.
68: */
69: void *memremap(resource_size_t offset, size_t size, unsigned long flags)
70: {
71: int is_ram = region_intersects(offset, size,
72: IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE);
73: void *addr = NULL;
74:
75: if (!flags)
76: return NULL;
77:
78: if (is_ram == REGION_MIXED) {
79: WARN_ONCE(1, "memremap attempted on mixed range %pa size: %#lx\n",
80: &offset, (unsigned long) size);
81: return NULL;
82: }
83:
84: /* Try all mapping types requested until one returns non-NULL */
85: if (flags & MEMREMAP_WB) {
86: /*
87: * MEMREMAP_WB is special in that it can be satisfied
88: * from the direct map. Some archs depend on the
89: * capability of memremap() to autodetect cases where
90: * the requested range is potentially in System RAM.
91: */
92: if (is_ram == REGION_INTERSECTS)
93: addr = try_ram_remap(offset, size, flags);
94: if (!addr)
95: addr = arch_memremap_wb(offset, size, flags);
96: }
97:
98: /*
99: * If we don't have a mapping yet and other request flags are
100: * present then we will be attempting to establish a new virtual
101: * address mapping. Enforce that this mapping is not aliasing
102: * System RAM.
103: */
104: if (!addr && is_ram == REGION_INTERSECTS && flags != MEMREMAP_WB) {
105: WARN_ONCE(1, "memremap attempted on ram %pa size: %#lx\n",
106: &offset, (unsigned long) size);
107: return NULL;
108: }
109:
110: if (!addr && (flags & MEMREMAP_WT))
111: addr = ioremap_wt(offset, size);
112:
113: if (!addr && (flags & MEMREMAP_WC))
114: addr = ioremap_wc(offset, size);
115:
116: return addr;
117: }
SourceFile:kernel/iomem.c]
|
| 36/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 37459
output: 19
thoughts: 164
Thoughts: **Investigating a `WARN_ON_ONCE` Triggered by syzkaller**
Okay, so I'm looking at this bug report and the `WARN_ON_ONCE(1)` in `__ioremap_caller` is triggered. I need to figure out why. The first thing that jumps out is this: if this warning was hit during boot, it would've been printed during boot. And since it's `WARN_ON_ONCE`, it wouldn't show up again. But the report says syzkaller triggered it. This means it *wasn't* a boot-time issue. That's key.
So, why wouldn't `pcibios_device_add` have triggered it during boot? Something must be different. My mind is jumping to `boot_params`. Could it be that `boot_params.hdr.setup_data` was valid at boot, but corrupted later? That seems like a good avenue to explore.
Now, how could `boot_params` get corrupted? That's the real question. I need to determine if any code modifies `boot_params` at runtime. That's what I need to check for next. Let's see if we can find any writes to that structure.
|
| 37/2 |
2026/05/26 05:46 |
tool |
grepper |
0m
Args: map[Expression:boot_params.*=]
Results: map[Output:
Full output is too long, showing 500 out of 677 lines.
Use more precise expression if possible.
[Documentation/arch/x86/boot.rst=941=sections::
--
Documentation/arch/x86/boot.rst-943- setup_header = .data
Documentation/arch/x86/boot.rst:944: boot_params/setup_data = .bss
Documentation/arch/x86/boot.rst-945-
--
arch/mips/cavium-octeon/setup.c=1142=void __init device_tree_init(void)
--
arch/mips/cavium-octeon/setup.c-1172-
arch/mips/cavium-octeon/setup.c:1173: initial_boot_params = (void *)fdt;
arch/mips/cavium-octeon/setup.c-1174-
--
arch/powerpc/kernel/prom.c=117=static void __init move_device_tree(void)
--
arch/powerpc/kernel/prom.c-134- memcpy(p, initial_boot_params, size);
arch/powerpc/kernel/prom.c:135: initial_boot_params = p;
arch/powerpc/kernel/prom.c-136- DBG("Moved device tree to 0x%px\n", p);
--
arch/powerpc/kernel/prom.c=947=void __init early_get_first_memblock_info(void *params, phys_addr_t *size)
--
arch/powerpc/kernel/prom.c-949- /* Setup flat device-tree pointer */
arch/powerpc/kernel/prom.c:950: initial_boot_params = params;
arch/powerpc/kernel/prom.c-951-
--
arch/x86/boot/apm.c=19=int query_apm_bios(void)
--
arch/x86/boot/apm.c-44-
arch/x86/boot/apm.c:45: boot_params.apm_bios_info.cseg = oreg.ax;
arch/x86/boot/apm.c:46: boot_params.apm_bios_info.offset = oreg.ebx;
arch/x86/boot/apm.c:47: boot_params.apm_bios_info.cseg_16 = oreg.cx;
arch/x86/boot/apm.c:48: boot_params.apm_bios_info.dseg = oreg.dx;
arch/x86/boot/apm.c:49: boot_params.apm_bios_info.cseg_len = oreg.si;
arch/x86/boot/apm.c:50: boot_params.apm_bios_info.cseg_16_len = oreg.hsi;
arch/x86/boot/apm.c:51: boot_params.apm_bios_info.dseg_len = oreg.di;
arch/x86/boot/apm.c-52-
--
arch/x86/boot/apm.c-68-
arch/x86/boot/apm.c:69: boot_params.apm_bios_info.version = oreg.ax;
arch/x86/boot/apm.c:70: boot_params.apm_bios_info.flags = oreg.cx;
arch/x86/boot/apm.c-71- return 0;
--
arch/x86/boot/compressed/ident_map_64.c=110=void initialize_identity_maps(void *rmode)
--
arch/x86/boot/compressed/ident_map_64.c-161- kernel_add_identity_map((unsigned long)_head, (unsigned long)_end);
arch/x86/boot/compressed/ident_map_64.c:162: boot_params_ptr = rmode;
arch/x86/boot/compressed/ident_map_64.c-163- kernel_add_identity_map((unsigned long)boot_params_ptr,
--
arch/x86/boot/compressed/kaslr.c=861=void choose_random_location(unsigned long input,
--
arch/x86/boot/compressed/kaslr.c-873-
arch/x86/boot/compressed/kaslr.c:874: boot_params_ptr->hdr.loadflags |= KASLR_FLAG;
arch/x86/boot/compressed/kaslr.c-875-
--
arch/x86/boot/compressed/misc.c=118=void __putstr(const char *s)
--
arch/x86/boot/compressed/misc.c-156-
arch/x86/boot/compressed/misc.c:157: boot_params_ptr->screen_info.orig_x = x;
arch/x86/boot/compressed/misc.c:158: boot_params_ptr->screen_info.orig_y = y;
arch/x86/boot/compressed/misc.c-159-
--
arch/x86/boot/compressed/misc.c=407=asmlinkage __visible void *extract_kernel(void *rmode, unsigned char *output)
--
arch/x86/boot/compressed/misc.c-414- /* Retain x86 boot parameters pointer passed from startup_32/64. */
arch/x86/boot/compressed/misc.c:415: boot_params_ptr = rmode;
arch/x86/boot/compressed/misc.c-416-
arch/x86/boot/compressed/misc.c-417- /* Clear flags intended for solely in-kernel use. */
arch/x86/boot/compressed/misc.c:418: boot_params_ptr->hdr.loadflags &= ~KASLR_FLAG;
arch/x86/boot/compressed/misc.c-419-
--
arch/x86/boot/compressed/misc.c-423-
arch/x86/boot/compressed/misc.c:424: if (boot_params_ptr->screen_info.orig_video_mode == 7) {
arch/x86/boot/compressed/misc.c-425- vidmem = (char *) 0xb0000;
--
arch/x86/boot/compressed/misc.c-453- */
arch/x86/boot/compressed/misc.c:454: boot_params_ptr->acpi_rsdp_addr = get_rsdp_addr();
arch/x86/boot/compressed/misc.c-455-
--
arch/x86/boot/compressed/pgtable_64.c=33=static unsigned long find_trampoline_placement(void)
--
arch/x86/boot/compressed/pgtable_64.c-66- /* Find the first usable memory region under bios_start. */
arch/x86/boot/compressed/pgtable_64.c:67: for (i = boot_params_ptr->e820_entries - 1; i >= 0; i--) {
arch/x86/boot/compressed/pgtable_64.c-68- unsigned long new = bios_start;
--
arch/x86/boot/compressed/pgtable_64.c=103=asmlinkage void configure_5level_paging(struct boot_params *bp, void *pgtable)
--
arch/x86/boot/compressed/pgtable_64.c-109- sanitize_boot_params(bp);
arch/x86/boot/compressed/pgtable_64.c:110: boot_params_ptr = bp;
arch/x86/boot/compressed/pgtable_64.c-111-
--
arch/x86/boot/edd.c=120=void query_edd(void)
--
arch/x86/boot/edd.c-172- if (do_mbr && !read_mbr_sig(devno, &ei, mbrptr++))
arch/x86/boot/edd.c:173: boot_params.edd_mbr_sig_buf_entries = devno-0x80+1;
arch/x86/boot/edd.c-174- }
--
arch/x86/boot/main.c=30=static void copy_boot_params(void)
--
arch/x86/boot/main.c-37-
arch/x86/boot/main.c:38: BUILD_BUG_ON(sizeof(boot_params) != 4096);
arch/x86/boot/main.c-39- memcpy(&boot_params.hdr, &hdr, sizeof(hdr));
arch/x86/boot/main.c-40-
arch/x86/boot/main.c:41: if (!boot_params.hdr.cmd_line_ptr && oldcmd->cl_magic == OLD_CL_MAGIC) {
arch/x86/boot/main.c-42- /* Old-style command line protocol */
--
arch/x86/boot/main.c-54-
arch/x86/boot/main.c:55: boot_params.hdr.cmd_line_ptr = (cmdline_seg << 4) + oldcmd->cl_offset;
arch/x86/boot/main.c-56- }
--
arch/x86/boot/main.c=64=static void keyboard_init(void)
--
arch/x86/boot/main.c-71- intcall(0x16, &ireg, &oreg);
arch/x86/boot/main.c:72: boot_params.kbd_status = oreg.al;
arch/x86/boot/main.c-73-
--
arch/x86/boot/main.c=81=static void query_ist(void)
--
arch/x86/boot/main.c-96-
arch/x86/boot/main.c:97: boot_params.ist_info.signature = oreg.eax;
arch/x86/boot/main.c:98: boot_params.ist_info.command = oreg.ebx;
arch/x86/boot/main.c:99: boot_params.ist_info.event = oreg.ecx;
arch/x86/boot/main.c:100: boot_params.ist_info.perf_level = oreg.edx;
arch/x86/boot/main.c-101-}
--
arch/x86/boot/memory.c=18=static void detect_memory_e820(void)
--
arch/x86/boot/memory.c-68-
arch/x86/boot/memory.c:69: boot_params.e820_entries = count;
arch/x86/boot/memory.c-70-}
--
arch/x86/boot/memory.c=72=static void detect_memory_e801(void)
--
arch/x86/boot/memory.c-91- } else if (oreg.ax == 15*1024) {
arch/x86/boot/memory.c:92: boot_params.alt_mem_k = (oreg.bx << 6) + oreg.ax;
arch/x86/boot/memory.c-93- } else {
--
arch/x86/boot/memory.c-100- */
arch/x86/boot/memory.c:101: boot_params.alt_mem_k = oreg.ax;
arch/x86/boot/memory.c-102- }
--
arch/x86/boot/memory.c=105=static void detect_memory_88(void)
--
arch/x86/boot/memory.c-112-
arch/x86/boot/memory.c:113: boot_params.screen_info.ext_mem_k = oreg.ax;
arch/x86/boot/memory.c-114-}
--
arch/x86/boot/video-mode.c=145=int set_mode(u16 mode)
--
arch/x86/boot/video-mode.c-167-#ifndef _WAKEUP
arch/x86/boot/video-mode.c:168: boot_params.hdr.vid_mode = real_mode;
arch/x86/boot/video-mode.c-169-#endif
--
arch/x86/boot/video-vesa.c=161=static void vesa_dac_set_8bits(void)
--
arch/x86/boot/video-vesa.c-176- /* Set the color sizes to the DAC size, and offsets to 0 */
arch/x86/boot/video-vesa.c:177: boot_params.screen_info.red_size = dac_size;
arch/x86/boot/video-vesa.c:178: boot_params.screen_info.green_size = dac_size;
arch/x86/boot/video-vesa.c:179: boot_params.screen_info.blue_size = dac_size;
arch/x86/boot/video-vesa.c:180: boot_params.screen_info.rsvd_size = dac_size;
arch/x86/boot/video-vesa.c-181-
arch/x86/boot/video-vesa.c:182: boot_params.screen_info.red_pos = 0;
arch/x86/boot/video-vesa.c:183: boot_params.screen_info.green_pos = 0;
arch/x86/boot/video-vesa.c:184: boot_params.screen_info.blue_pos = 0;
arch/x86/boot/video-vesa.c:185: boot_params.screen_info.rsvd_pos = 0;
arch/x86/boot/video-vesa.c-186-}
--
arch/x86/boot/video-vesa.c=189=static void vesa_store_pm_info(void)
--
arch/x86/boot/video-vesa.c-199-
arch/x86/boot/video-vesa.c:200: boot_params.screen_info.vesapm_seg = oreg.es;
arch/x86/boot/video-vesa.c:201: boot_params.screen_info.vesapm_off = oreg.di;
arch/x86/boot/video-vesa.c-202-}
--
arch/x86/boot/video-vesa.c=207=static void vesa_store_mode_params_graphics(void)
--
arch/x86/boot/video-vesa.c-209- /* Tell the kernel we're in VESA graphics mode */
arch/x86/boot/video-vesa.c:210: boot_params.screen_info.orig_video_isVGA = VIDEO_TYPE_VLFB;
arch/x86/boot/video-vesa.c-211-
arch/x86/boot/video-vesa.c-212- /* Mode parameters */
arch/x86/boot/video-vesa.c:213: boot_params.screen_info.vesa_attributes = vminfo.mode_attr;
arch/x86/boot/video-vesa.c:214: boot_params.screen_info.lfb_linelength = vminfo.logical_scan;
arch/x86/boot/video-vesa.c:215: boot_params.screen_info.lfb_width = vminfo.h_res;
arch/x86/boot/video-vesa.c:216: boot_params.screen_info.lfb_height = vminfo.v_res;
arch/x86/boot/video-vesa.c:217: boot_params.screen_info.lfb_depth = vminfo.bpp;
arch/x86/boot/video-vesa.c:218: boot_params.screen_info.pages = vminfo.image_planes;
arch/x86/boot/video-vesa.c:219: boot_params.screen_info.lfb_base = vminfo.lfb_ptr;
arch/x86/boot/video-vesa.c-220- memcpy(&boot_params.screen_info.red_size,
--
arch/x86/boot/video-vesa.c-223- /* General parameters */
arch/x86/boot/video-vesa.c:224: boot_params.screen_info.lfb_size = vginfo.total_memory;
arch/x86/boot/video-vesa.c-225-
--
arch/x86/boot/video-vga.c=231=static int vga_probe(void)
--
arch/x86/boot/video-vga.c-255-#ifndef _WAKEUP
arch/x86/boot/video-vga.c:256: boot_params.screen_info.orig_video_ega_bx = oreg.bx;
arch/x86/boot/video-vga.c-257-#endif
--
arch/x86/boot/video-vga.c-267-#ifndef _WAKEUP
arch/x86/boot/video-vga.c:268: boot_params.screen_info.orig_video_isVGA = 1;
arch/x86/boot/video-vga.c-269-#endif
--
arch/x86/boot/video.c=22=static void store_cursor_position(void)
--
arch/x86/boot/video.c-29-
arch/x86/boot/video.c:30: boot_params.screen_info.orig_x = oreg.dl;
arch/x86/boot/video.c:31: boot_params.screen_info.orig_y = oreg.dh;
arch/x86/boot/video.c-32-
arch/x86/boot/video.c-33- if (oreg.ch & 0x20)
arch/x86/boot/video.c:34: boot_params.screen_info.flags |= VIDEO_FLAGS_NOCURSOR;
arch/x86/boot/video.c-35-
arch/x86/boot/video.c-36- if ((oreg.ch & 0x1f) > (oreg.cl & 0x1f))
arch/x86/boot/video.c:37: boot_params.screen_info.flags |= VIDEO_FLAGS_NOCURSOR;
arch/x86/boot/video.c-38-}
--
arch/x86/boot/video.c=40=static void store_video_mode(void)
--
arch/x86/boot/video.c-50- /* Not all BIOSes are clean with respect to the top bit */
arch/x86/boot/video.c:51: boot_params.screen_info.orig_video_mode = oreg.al & 0x7f;
arch/x86/boot/video.c:52: boot_params.screen_info.orig_video_page = oreg.bh;
arch/x86/boot/video.c-53-}
--
arch/x86/boot/video.c=61=static void store_mode_params(void)
--
arch/x86/boot/video.c-73-
arch/x86/boot/video.c:74: if (boot_params.screen_info.orig_video_mode == 0x07) {
arch/x86/boot/video.c-75- /* MDA, HGC, or VGA in monochrome mode */
--
arch/x86/boot/video.c-83- font_size = rdfs16(0x485); /* Font size, BIOS area */
arch/x86/boot/video.c:84: boot_params.screen_info.orig_video_points = font_size;
arch/x86/boot/video.c-85-
--
arch/x86/boot/video.c-93-
arch/x86/boot/video.c:94: boot_params.screen_info.orig_video_cols = x;
arch/x86/boot/video.c:95: boot_params.screen_info.orig_video_lines = y;
arch/x86/boot/video.c-96-}
--
arch/x86/boot/video.c=317=void set_video(void)
--
arch/x86/boot/video.c-336- }
arch/x86/boot/video.c:337: boot_params.hdr.vid_mode = mode;
arch/x86/boot/video.c-338- vesa_store_edid();
--
arch/x86/include/asm/bootparam_utils.h=35=static void sanitize_boot_params(struct boot_params *boot_params)
--
arch/x86/include/asm/bootparam_utils.h-56-
arch/x86/include/asm/bootparam_utils.h:57: const struct boot_params_to_save to_save[] = {
arch/x86/include/asm/bootparam_utils.h-58- BOOT_PARAM_PRESERVE(screen_info),
--
arch/x86/kernel/acpi/boot.c=1831=void x86_default_set_root_pointer(u64 addr)
arch/x86/kernel/acpi/boot.c-1832-{
arch/x86/kernel/acpi/boot.c:1833: boot_params.acpi_rsdp_addr = addr;
arch/x86/kernel/acpi/boot.c-1834-}
--
arch/x86/kernel/crash.c=281=static int memmap_entry_callback(struct resource *res, void *arg)
--
arch/x86/kernel/crash.c-283- struct crash_memmap_data *cmd = arg;
arch/x86/kernel/crash.c:284: struct boot_params *params = cmd->params;
arch/x86/kernel/crash.c-285- struct e820_entry ei;
--
arch/x86/kernel/early_printk.c=388=static int __init setup_early_printk(char *buf)
--
arch/x86/kernel/early_printk.c-424- if (!strncmp(buf, "vga", 3) &&
arch/x86/kernel/early_printk.c:425: boot_params.screen_info.orig_video_isVGA == 1) {
arch/x86/kernel/early_printk.c-426- max_xpos = boot_params.screen_info.orig_video_cols;
--
arch/x86/kernel/kdebugfs.c=89=static int __init create_setup_data_nodes(struct dentry *parent)
--
arch/x86/kernel/kdebugfs.c-159-
arch/x86/kernel/kdebugfs.c:160:static struct debugfs_blob_wrapper boot_params_blob = {
arch/x86/kernel/kdebugfs.c-161- .data = &boot_params,
--
arch/x86/kernel/ksysfs.c=22=static ssize_t version_show(struct kobject *kobj,
--
arch/x86/kernel/ksysfs.c-27-
arch/x86/kernel/ksysfs.c:28:static struct kobj_attribute boot_params_version_attr = __ATTR_RO(version);
arch/x86/kernel/ksysfs.c-29-
arch/x86/kernel/ksysfs.c=30=static ssize_t boot_params_data_read(struct file *fp, struct kobject *kobj,
--
arch/x86/kernel/ksysfs.c-37-
arch/x86/kernel/ksysfs.c:38:static const struct bin_attribute boot_params_data_attr = {
arch/x86/kernel/ksysfs.c-39- .attr = {
--
arch/x86/kernel/ksysfs.c-46-
arch/x86/kernel/ksysfs.c:47:static struct attribute *boot_params_version_attrs[] = {
arch/x86/kernel/ksysfs.c-48- &boot_params_version_attr.attr,
--
arch/x86/kernel/ksysfs.c-51-
arch/x86/kernel/ksysfs.c:52:static const struct bin_attribute *const boot_params_data_attrs[] = {
arch/x86/kernel/ksysfs.c-53- &boot_params_data_attr,
--
arch/x86/kernel/ksysfs.c-56-
arch/x86/kernel/ksysfs.c:57:static const struct attribute_group boot_params_attr_group = {
arch/x86/kernel/ksysfs.c-58- .attrs = boot_params_version_attrs,
--
arch/x86/kernel/ksysfs.c=372=static int __init boot_params_ksysfs_init(void)
--
arch/x86/kernel/ksysfs.c-376-
arch/x86/kernel/ksysfs.c:377: boot_params_kobj = kobject_create_and_add("boot_params",
arch/x86/kernel/ksysfs.c-378- kernel_kobj);
--
arch/x86/xen/efi.c=132=void __init xen_efi_init(struct boot_params *boot_params)
--
arch/x86/xen/efi.c-142- sizeof(boot_params->efi_info.efi_loader_signature));
arch/x86/xen/efi.c:143: boot_params->efi_info.efi_systab = (__u32)__pa(efi_systab_xen);
arch/x86/xen/efi.c:144: boot_params->efi_info.efi_systab_hi = (__u32)(__pa(efi_systab_xen) >> 32);
arch/x86/xen/efi.c-145-
arch/x86/xen/efi.c:146: boot_params->secure_boot = xen_efi_get_secureboot();
arch/x86/xen/efi.c-147-
--
arch/x86/xen/enlighten_pv.c=1259=static void __init xen_boot_params_init_edd(void)
--
arch/x86/xen/enlighten_pv.c-1293- }
arch/x86/xen/enlighten_pv.c:1294: boot_params.eddbuf_entries = nr;
arch/x86/xen/enlighten_pv.c-1295-
--
arch/x86/xen/enlighten_pv.c-1303- }
arch/x86/xen/enlighten_pv.c:1304: boot_params.edd_mbr_sig_buf_entries = nr;
arch/x86/xen/enlighten_pv.c-1305-#endif
--
arch/x86/xen/enlighten_pv.c=1337=asmlinkage __visible void __init xen_start_kernel(struct start_info *si)
--
arch/x86/xen/enlighten_pv.c-1506- /* Poke various useful things into boot_params */
arch/x86/xen/enlighten_pv.c:1507: boot_params.hdr.type_of_loader = (9 << 4) | 0;
arch/x86/xen/enlighten_pv.c:1508: boot_params.hdr.ramdisk_image = initrd_start;
arch/x86/xen/enlighten_pv.c:1509: boot_params.hdr.ramdisk_size = xen_start_info->mod_len;
arch/x86/xen/enlighten_pv.c:1510: boot_params.hdr.cmd_line_ptr = __pa(xen_start_info->cmd_line);
arch/x86/xen/enlighten_pv.c:1511: boot_params.hdr.hardware_subarch = X86_SUBARCH_XEN;
arch/x86/xen/enlighten_pv.c-1512-
--
arch/x86/xen/enlighten_pv.c-1535- if (HYPERVISOR_platform_op(&op) == 0)
arch/x86/xen/enlighten_pv.c:1536: boot_params.kbd_status = op.u.firmware_info.u.kbd_shift_flags;
arch/x86/xen/enlighten_pv.c-1537-
--
arch/x86/xen/enlighten_pvh.c=70=static void __init pvh_reserve_extra_memory(void)
arch/x86/xen/enlighten_pvh.c-71-{
arch/x86/xen/enlighten_pvh.c:72: struct boot_params *bootp = &boot_params;
arch/x86/xen/enlighten_pvh.c-73- unsigned int i, ram_pages = 0, extra_pages;
--
arch/x86/xen/enlighten_pvh.c=172=void __init mem_map_via_hcall(struct boot_params *boot_params_p)
--
arch/x86/xen/enlighten_pvh.c-183- }
arch/x86/xen/enlighten_pvh.c:184: boot_params_p->e820_entries = memmap.nr_entries;
arch/x86/xen/enlighten_pvh.c-185-}
--
arch/x86/xen/setup.c=789=char * __init xen_memory_setup(void)
--
arch/x86/xen/setup.c-966- memblock_phys_free(start, size);
arch/x86/xen/setup.c:967: boot_params.hdr.ramdisk_image = new_area;
arch/x86/xen/setup.c:968: boot_params.ext_ramdisk_image = new_area >> 32;
arch/x86/xen/setup.c-969- }
--
drivers/accel/ivpu/ivpu_fw.c=203=static int ivpu_fw_parse(struct ivpu_device *vdev)
--
drivers/accel/ivpu/ivpu_fw.c-222-
drivers/accel/ivpu/ivpu_fw.c:223: boot_params_addr = fw_hdr->boot_params_load_address;
drivers/accel/ivpu/ivpu_fw.c:224: boot_params_size = SZ_4K;
drivers/accel/ivpu/ivpu_fw.c-225-
--
drivers/accel/ivpu/ivpu_fw.c-293-
drivers/accel/ivpu/ivpu_fw.c:294: fw->boot_params_addr = boot_params_addr;
drivers/accel/ivpu/ivpu_fw.c:295: fw->boot_params_size = boot_params_size;
drivers/accel/ivpu/ivpu_fw.c-296- fw->fw_version_addr = fw_version_addr;
--
drivers/accel/ivpu/ivpu_fw.c=523=static void ivpu_fw_boot_params_print(struct ivpu_device *vdev, struct vpu_boot_params *boot_params)
drivers/accel/ivpu/ivpu_fw.c-524-{
drivers/accel/ivpu/ivpu_fw.c:525: ivpu_dbg(vdev, FW_BOOT, "boot_params.magic = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-526- boot_params->magic);
drivers/accel/ivpu/ivpu_fw.c:527: ivpu_dbg(vdev, FW_BOOT, "boot_params.vpu_id = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-528- boot_params->vpu_id);
drivers/accel/ivpu/ivpu_fw.c:529: ivpu_dbg(vdev, FW_BOOT, "boot_params.vpu_count = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-530- boot_params->vpu_count);
drivers/accel/ivpu/ivpu_fw.c:531: ivpu_dbg(vdev, FW_BOOT, "boot_params.frequency = %u\n",
drivers/accel/ivpu/ivpu_fw.c-532- boot_params->frequency);
drivers/accel/ivpu/ivpu_fw.c:533: ivpu_dbg(vdev, FW_BOOT, "boot_params.perf_clk_frequency = %u\n",
drivers/accel/ivpu/ivpu_fw.c-534- boot_params->perf_clk_frequency);
drivers/accel/ivpu/ivpu_fw.c-535-
drivers/accel/ivpu/ivpu_fw.c:536: ivpu_dbg(vdev, FW_BOOT, "boot_params.ipc_header_area_start = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-537- boot_params->ipc_header_area_start);
drivers/accel/ivpu/ivpu_fw.c:538: ivpu_dbg(vdev, FW_BOOT, "boot_params.ipc_header_area_size = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-539- boot_params->ipc_header_area_size);
drivers/accel/ivpu/ivpu_fw.c:540: ivpu_dbg(vdev, FW_BOOT, "boot_params.shared_region_base = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-541- boot_params->shared_region_base);
drivers/accel/ivpu/ivpu_fw.c:542: ivpu_dbg(vdev, FW_BOOT, "boot_params.shared_region_size = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-543- boot_params->shared_region_size);
drivers/accel/ivpu/ivpu_fw.c:544: ivpu_dbg(vdev, FW_BOOT, "boot_params.ipc_payload_area_start = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-545- boot_params->ipc_payload_area_start);
drivers/accel/ivpu/ivpu_fw.c:546: ivpu_dbg(vdev, FW_BOOT, "boot_params.ipc_payload_area_size = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-547- boot_params->ipc_payload_area_size);
drivers/accel/ivpu/ivpu_fw.c:548: ivpu_dbg(vdev, FW_BOOT, "boot_params.global_aliased_pio_base = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-549- boot_params->global_aliased_pio_base);
drivers/accel/ivpu/ivpu_fw.c:550: ivpu_dbg(vdev, FW_BOOT, "boot_params.global_aliased_pio_size = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-551- boot_params->global_aliased_pio_size);
drivers/accel/ivpu/ivpu_fw.c-552-
drivers/accel/ivpu/ivpu_fw.c:553: ivpu_dbg(vdev, FW_BOOT, "boot_params.autoconfig = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-554- boot_params->autoconfig);
drivers/accel/ivpu/ivpu_fw.c-555-
drivers/accel/ivpu/ivpu_fw.c:556: ivpu_dbg(vdev, FW_BOOT, "boot_params.cache_defaults[VPU_BOOT_L2_CACHE_CFG_NN].use = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-557- boot_params->cache_defaults[VPU_BOOT_L2_CACHE_CFG_NN].use);
drivers/accel/ivpu/ivpu_fw.c:558: ivpu_dbg(vdev, FW_BOOT, "boot_params.cache_defaults[VPU_BOOT_L2_CACHE_CFG_NN].cfg = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-559- boot_params->cache_defaults[VPU_BOOT_L2_CACHE_CFG_NN].cfg);
drivers/accel/ivpu/ivpu_fw.c-560-
drivers/accel/ivpu/ivpu_fw.c:561: ivpu_dbg(vdev, FW_BOOT, "boot_params.shave_nn_fw_base = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-562- boot_params->shave_nn_fw_base);
drivers/accel/ivpu/ivpu_fw.c-563-
drivers/accel/ivpu/ivpu_fw.c:564: ivpu_dbg(vdev, FW_BOOT, "boot_params.watchdog_irq_mss = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-565- boot_params->watchdog_irq_mss);
drivers/accel/ivpu/ivpu_fw.c:566: ivpu_dbg(vdev, FW_BOOT, "boot_params.watchdog_irq_nce = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-567- boot_params->watchdog_irq_nce);
drivers/accel/ivpu/ivpu_fw.c-568-
drivers/accel/ivpu/ivpu_fw.c:569: ivpu_dbg(vdev, FW_BOOT, "boot_params.host_version_id = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-570- boot_params->host_version_id);
drivers/accel/ivpu/ivpu_fw.c:571: ivpu_dbg(vdev, FW_BOOT, "boot_params.si_stepping = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-572- boot_params->si_stepping);
drivers/accel/ivpu/ivpu_fw.c:573: ivpu_dbg(vdev, FW_BOOT, "boot_params.device_id = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-574- boot_params->device_id);
drivers/accel/ivpu/ivpu_fw.c:575: ivpu_dbg(vdev, FW_BOOT, "boot_params.feature_exclusion = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-576- boot_params->feature_exclusion);
drivers/accel/ivpu/ivpu_fw.c:577: ivpu_dbg(vdev, FW_BOOT, "boot_params.sku = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-578- boot_params->sku);
drivers/accel/ivpu/ivpu_fw.c:579: ivpu_dbg(vdev, FW_BOOT, "boot_params.min_freq_pll_ratio = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-580- boot_params->min_freq_pll_ratio);
drivers/accel/ivpu/ivpu_fw.c:581: ivpu_dbg(vdev, FW_BOOT, "boot_params.pn_freq_pll_ratio = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-582- boot_params->pn_freq_pll_ratio);
drivers/accel/ivpu/ivpu_fw.c:583: ivpu_dbg(vdev, FW_BOOT, "boot_params.max_freq_pll_ratio = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-584- boot_params->max_freq_pll_ratio);
drivers/accel/ivpu/ivpu_fw.c:585: ivpu_dbg(vdev, FW_BOOT, "boot_params.default_trace_level = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-586- boot_params->default_trace_level);
drivers/accel/ivpu/ivpu_fw.c:587: ivpu_dbg(vdev, FW_BOOT, "boot_params.tracing_buff_message_format_mask = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-588- boot_params->tracing_buff_message_format_mask);
drivers/accel/ivpu/ivpu_fw.c:589: ivpu_dbg(vdev, FW_BOOT, "boot_params.trace_destination_mask = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-590- boot_params->trace_destination_mask);
drivers/accel/ivpu/ivpu_fw.c:591: ivpu_dbg(vdev, FW_BOOT, "boot_params.trace_hw_component_mask = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-592- boot_params->trace_hw_component_mask);
drivers/accel/ivpu/ivpu_fw.c:593: ivpu_dbg(vdev, FW_BOOT, "boot_params.boot_type = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-594- boot_params->boot_type);
drivers/accel/ivpu/ivpu_fw.c:595: ivpu_dbg(vdev, FW_BOOT, "boot_params.punit_telemetry_sram_base = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-596- boot_params->punit_telemetry_sram_base);
drivers/accel/ivpu/ivpu_fw.c:597: ivpu_dbg(vdev, FW_BOOT, "boot_params.punit_telemetry_sram_size = 0x%llx\n",
drivers/accel/ivpu/ivpu_fw.c-598- boot_params->punit_telemetry_sram_size);
drivers/accel/ivpu/ivpu_fw.c:599: ivpu_dbg(vdev, FW_BOOT, "boot_params.vpu_telemetry_enable = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-600- boot_params->vpu_telemetry_enable);
drivers/accel/ivpu/ivpu_fw.c:601: ivpu_dbg(vdev, FW_BOOT, "boot_params.vpu_scheduling_mode = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-602- boot_params->vpu_scheduling_mode);
drivers/accel/ivpu/ivpu_fw.c:603: ivpu_dbg(vdev, FW_BOOT, "boot_params.dvfs_mode = %u\n",
drivers/accel/ivpu/ivpu_fw.c-604- boot_params->dvfs_mode);
drivers/accel/ivpu/ivpu_fw.c:605: ivpu_dbg(vdev, FW_BOOT, "boot_params.d0i3_delayed_entry = %d\n",
drivers/accel/ivpu/ivpu_fw.c-606- boot_params->d0i3_delayed_entry);
drivers/accel/ivpu/ivpu_fw.c:607: ivpu_dbg(vdev, FW_BOOT, "boot_params.d0i3_residency_time_us = %lld\n",
drivers/accel/ivpu/ivpu_fw.c-608- boot_params->d0i3_residency_time_us);
drivers/accel/ivpu/ivpu_fw.c:609: ivpu_dbg(vdev, FW_BOOT, "boot_params.d0i3_entry_vpu_ts = %llu\n",
drivers/accel/ivpu/ivpu_fw.c-610- boot_params->d0i3_entry_vpu_ts);
drivers/accel/ivpu/ivpu_fw.c:611: ivpu_dbg(vdev, FW_BOOT, "boot_params.system_time_us = %llu\n",
drivers/accel/ivpu/ivpu_fw.c-612- boot_params->system_time_us);
drivers/accel/ivpu/ivpu_fw.c:613: ivpu_dbg(vdev, FW_BOOT, "boot_params.power_profile = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-614- boot_params->power_profile);
drivers/accel/ivpu/ivpu_fw.c:615: ivpu_dbg(vdev, FW_BOOT, "boot_params.vpu_uses_ecc_mca_signal = 0x%x\n",
drivers/accel/ivpu/ivpu_fw.c-616- boot_params->vpu_uses_ecc_mca_signal);
drivers/accel/ivpu/ivpu_fw.c:617: ivpu_dbg(vdev, FW_BOOT, "boot_params.boot_type = 0x%x\n", boot_params->boot_type);
drivers/accel/ivpu/ivpu_fw.c-618-}
--
drivers/accel/ivpu/ivpu_fw.c=620=void ivpu_fw_boot_params_setup(struct ivpu_device *vdev, struct vpu_boot_params *boot_params)
--
drivers/accel/ivpu/ivpu_fw.c-625- if (ivpu_fw_is_warm_boot(vdev)) {
drivers/accel/ivpu/ivpu_fw.c:626: boot_params->d0i3_residency_time_us =
drivers/accel/ivpu/ivpu_fw.c-627- ktime_us_delta(ktime_get_boottime(), vdev->hw->d0i3_entry_host_ts);
drivers/accel/ivpu/ivpu_fw.c:628: boot_params->d0i3_entry_vpu_ts = vdev->hw->d0i3_entry_vpu_ts;
drivers/accel/ivpu/ivpu_fw.c:629: boot_params->system_time_us = ktime_to_us(ktime_get_real());
drivers/accel/ivpu/ivpu_fw.c-630-
drivers/accel/ivpu/ivpu_fw.c:631: ivpu_dbg(vdev, FW_BOOT, "boot_params.d0i3_residency_time_us = %lld\n",
drivers/accel/ivpu/ivpu_fw.c-632- boot_params->d0i3_residency_time_us);
drivers/accel/ivpu/ivpu_fw.c:633: ivpu_dbg(vdev, FW_BOOT, "boot_params.d0i3_entry_vpu_ts = %llu\n",
drivers/accel/ivpu/ivpu_fw.c-634- boot_params->d0i3_entry_vpu_ts);
drivers/accel/ivpu/ivpu_fw.c:635: ivpu_dbg(vdev, FW_BOOT, "boot_params.system_time_us = %llu\n",
drivers/accel/ivpu/ivpu_fw.c-636- boot_params->system_time_us);
drivers/accel/ivpu/ivpu_fw.c:637: ivpu_dbg(vdev, FW_BOOT, "boot_params.boot_type = 0x%x\n", boot_params->boot_type);
drivers/accel/ivpu/ivpu_fw.c-638-
drivers/accel/ivpu/ivpu_fw.c:639: boot_params->save_restore_ret_address = 0;
drivers/accel/ivpu/ivpu_fw.c:640: boot_params->boot_type = VPU_BOOT_TYPE_WARMBOOT;
drivers/accel/ivpu/ivpu_fw.c-641- wmb(); /* Flush WC buffers after writing save_restore_ret_address */
--
drivers/accel/ivpu/ivpu_fw.c-645- memset(boot_params, 0, sizeof(*boot_params));
drivers/accel/ivpu/ivpu_fw.c:646: boot_params->boot_type = VPU_BOOT_TYPE_COLDBOOT;
drivers/accel/ivpu/ivpu_fw.c:647: boot_params->magic = VPU_BOOT_PARAMS_MAGIC;
drivers/accel/ivpu/ivpu_fw.c:648: boot_params->vpu_id = to_pci_dev(vdev->drm.dev)->bus->number;
drivers/accel/ivpu/ivpu_fw.c-649-
--
drivers/accel/ivpu/ivpu_fw.c-654- */
drivers/accel/ivpu/ivpu_fw.c:655: boot_params->perf_clk_frequency = ivpu_hw_profiling_freq_get(vdev);
drivers/accel/ivpu/ivpu_fw.c-656-
--
drivers/accel/ivpu/ivpu_fw.c-660- */
drivers/accel/ivpu/ivpu_fw.c:661: boot_params->shared_region_base = vdev->hw->ranges.global.start;
drivers/accel/ivpu/ivpu_fw.c:662: boot_params->shared_region_size = vdev->hw->ranges.global.end -
drivers/accel/ivpu/ivpu_fw.c-663- vdev->hw->ranges.global.start;
drivers/accel/ivpu/ivpu_fw.c-664-
drivers/accel/ivpu/ivpu_fw.c:665: boot_params->ipc_header_area_start = ipc_mem_rx->vpu_addr;
drivers/accel/ivpu/ivpu_fw.c:666: boot_params->ipc_header_area_size = ivpu_bo_size(ipc_mem_rx) / 2;
drivers/accel/ivpu/ivpu_fw.c-667-
drivers/accel/ivpu/ivpu_fw.c:668: boot_params->ipc_payload_area_start = ipc_mem_rx->vpu_addr + ivpu_bo_size(ipc_mem_rx) / 2;
drivers/accel/ivpu/ivpu_fw.c:669: boot_params->ipc_payload_area_size = ivpu_bo_size(ipc_mem_rx) / 2;
]
]
|
| 38/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 51642
output: 48
thoughts: 468
Thoughts: **Analyzing a Potential Syzkaller-Induced Kernel Crash**
Okay, first things first. I need to understand how `boot_params` is being manipulated, since that seems to be the culprit. Wait, `boot_params` is a global variable, defined in `arch/x86/include/asm/setup.h` or something similar, right? My initial thought is: is there any way syzkaller could be modifying this directly?
Syzkaller typically doesn't directly mess with memory in the kernel space unless itβs using `/dev/mem` or `/dev/kmem`, but those are usually disabled for security reasons, so that's probably not it. Hmm, what if syzkaller is leveraging `kexec` to load a new kernel? `kexec` *could* provide its own, potentially malicious `boot_params`. But the kernel usually throws a warning about this, and this wasnβt mentioned in the report, so that seems unlikely.
Okay, let's step back. I remember `boot_params` being used by `pcibios_device_add`, to find the ROM, specifically: `pa_data = boot_params.hdr.setup_data;`. `setup_data` is a linked list of structures, which makes this even more interesting. If syzkaller can modify `boot_params.hdr.setup_data` *or* the memory it points to, then we've got a potential vulnerability.
Could `boot_params` be writable via debugfs? Let me check... Ah, here it is: `arch/x86/kernel/kdebugfs.c:160:static struct debugfs_blob_wrapper boot_params_blob = { .data = &boot_params, .size = sizeof(boot_params) };` and `debugfs_create_blob("boot_params", 0444, parent, &boot_params_blob);`. The file permissions on this are `0444`, so it's read-only. Thatβs probably not the direct cause of the issue, then.
Wait a minute... `boot_params.hdr.setup_data` is a *physical address*. If we're talking about a VM, like QEMU, the VMM itself provides this `setup_data`. If syzkaller is fuzzing the VMM (like in its `/dev/kvm` mode), it *could* provide arbitrary, malicious `setup_data`. That's a strong possibility. But... the bug report mentions `Comm: syz.5.5717`, which indicates a process *inside* the VM. If the VM *was* booted with a malformed `setup_data`, why didn't it crash during the initial boot? That seems strange. Let me go back and re-examine `pcibios_device_add` and see if anything else jumps out.
|
| 39/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/pci/common.c IncludeLines:true Name:pcibios_device_add]
Results: map[SourceCode: 643: int pcibios_device_add(struct pci_dev *dev)
644: {
645: struct pci_setup_rom *rom;
646: struct irq_domain *msidom;
647: struct setup_data *data;
648: u64 pa_data;
649:
650: pa_data = boot_params.hdr.setup_data;
651: while (pa_data) {
652: data = memremap(pa_data, sizeof(*rom), MEMREMAP_WB);
653: if (!data)
654: return -ENOMEM;
655:
656: if (data->type == SETUP_PCI) {
657: rom = (struct pci_setup_rom *)data;
658:
659: if ((pci_domain_nr(dev->bus) == rom->segment) &&
660: (dev->bus->number == rom->bus) &&
661: (PCI_SLOT(dev->devfn) == rom->device) &&
662: (PCI_FUNC(dev->devfn) == rom->function) &&
663: (dev->vendor == rom->vendor) &&
664: (dev->device == rom->devid)) {
665: dev->rom = pa_data +
666: offsetof(struct pci_setup_rom, romdata);
667: dev->romlen = rom->pcilen;
668: }
669: }
670: pa_data = data->next;
671: memunmap(data);
672: }
673: set_dev_domain_options(dev);
674:
675: /*
676: * Setup the initial MSI domain of the device. If the underlying
677: * bus has a PCI/MSI irqdomain associated use the bus domain,
678: * otherwise set the default domain. This ensures that special irq
679: * domains e.g. VMD are preserved. The default ensures initial
680: * operation if irq remapping is not active. If irq remapping is
681: * active it will overwrite the domain pointer when the device is
682: * associated to a remapping domain.
683: */
684: msidom = dev_get_msi_domain(&dev->bus->dev);
685: if (!msidom)
686: msidom = x86_pci_msi_default_domain;
687: dev_set_msi_domain(&dev->dev, msidom);
688: return 0;
689: }
SourceFile:arch/x86/pci/common.c]
|
| 40/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 53585
output: 48
thoughts: 260
Thoughts: **Debugging a Suspect Memory Mapping Issue**
Okay, so I'm looking at this code and trying to understand why I'm getting a warning related to an invalid physical address when adding a PCI device. The logic seems straightforward: If `pa_data` is valid, `memremap` maps it. Then we move on to the next piece of data with `pa_data = data->next;`. The problem arises if `data->next` points to an invalid physical address. In that scenario, the loop just keeps going, and `memremap` is called with that garbage address.
The specific scenario that triggered this warning involves a `setup_data` chain where the final elementβs `next` pointer is an invalid address, like `4ff4208dd89fe53e`. That should, theoretically, cause `pcibios_device_add` to trigger a warning. But that doesnβt make sense! If that was the root cause, I should have seen this warning during boot when the *first* PCI device was being added.
So why isn't this warning coming up on boot? My instinct is to revisit `memremap` and its behavior during boot. Perhaps `memremap` behaves differently? Maybe it skips `ioremap_cache` somehow during boot? Let me double-check. No, `memremap` calls `arch_memremap_wb`, which in turn, always calls `ioremap_cache`. Wait a minute... is `ioremap_cache` itself an alias for something else, like `ioremap_wc`? I need to check `arch_memremap_wb` again.
|
| 41/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/mm/ioremap.c IncludeLines:true Name:arch_memremap_wb]
Results: map[SourceCode: 505: void *arch_memremap_wb(phys_addr_t phys_addr, size_t size, unsigned long flags)
506: {
507: if ((flags & MEMREMAP_DEC) || cc_platform_has(CC_ATTR_HOST_MEM_ENCRYPT))
508: return (void __force *)ioremap_cache(phys_addr, size);
509:
510: return (void __force *)ioremap_encrypted(phys_addr, size);
511: }
SourceFile:arch/x86/mm/ioremap.c]
|
| 42/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 54423
output: 45
thoughts: 146
Thoughts: **Analyzing the Memory Remapping Logic**
Okay, so I'm diving into this `arch_memremap_wb` function. My initial observation is that it only invokes `ioremap_cache` under very specific conditions. It checks if either `MEMREMAP_DEC` is flagged or, crucially, if the system is configured with host memory encryption, specifically detected by `cc_platform_has(CC_ATTR_HOST_MEM_ENCRYPT)`.
Now, digging deeper, I see that the `flags` parameter passed to this function, particularly within the context of `pcibios_device_add`, defaults to `MEMREMAP_WB`. I see that `MEMREMAP_DEC` isn't set. So, this means `ioremap_cache` gets called if and only if the host has memory encryption enabled. Otherwise, the code paths to `ioremap_encrypted` instead.
That's interesting. I just noticed something I need to clarify: It seems `ioremap_encrypted` also leverages `__ioremap_caller`! I need to ensure the appropriate caching mechanism is set for this path, since it's going through what is likely the low-level remapping code.
|
| 43/2 |
2026/05/26 05:46 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/mm/ioremap.c IncludeLines:true Name:ioremap_encrypted]
Results: map[SourceCode: 427: void __iomem *ioremap_encrypted(resource_size_t phys_addr, unsigned long size)
428: {
429: return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
430: __builtin_return_address(0), true);
431: }
SourceFile:arch/x86/mm/ioremap.c]
|
| 44/2 |
2026/05/26 05:46 |
llm |
expert |
0m
Model:
Tokens:
input: 54999
output: 19
thoughts: 537
Thoughts: **Investigating a Kernel Warning Triggered by `__ioremap_caller`**
Okay, so both instances reported by syzkaller lead to `__ioremap_caller`. That function *should* have been called during boot, so why didn't the warning pop then? Hang on, let's look at the `WARN_ON_ONCE`:
```c
if (!phys_addr_valid(phys_addr)) {
printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
(unsigned long long)phys_addr);
WARN_ON_ONCE(1);
return NULL;
}
```
If it *had* been triggered during boot, that `WARN_ON_ONCE` would've set its flag, so the warning wouldn't re-occur. But syzkaller reported it, which means it saw the output. Syzkaller parses the kernel log. If the warning happened during boot, it would be associated with the boot process in the syzkaller report, and not attributed to `syz.5.5717`.
Unless... could `setup_data` be modified *after* boot? How? Are there sysfs files related to it? I checked β they're read-only. Hmm, what if syzkaller is using `kexec_file_load` or `kexec_load` to load a new kernel, and something goes wrong and it *somehow* modifies `boot_params`? No, `kexec` creates a *new* `boot_params` for the new kernel, not modifies the current one.
Wait, what if `boot_params` is in memory that syzkaller *can* write to? Where is `boot_params` located? It's a global variable in the kernel's `.bss` or `.data` section:
```c
struct boot_params boot_params;
```
That's not writable by unprivileged users, right? Okay... Wait, could `data->next` be modified? `data` is mapped via `memremap`. It points to physical memory. Could the physical memory containing `setup_data` be modified? How can syzkaller modify *physical* memory? `/dev/mem`? No, syzkaller doesn't have access to it. Through a driver?
Hang on... `setup_data` is parsed during boot. Let's see if there's a driver that somehow messes with it.
|
| 45/2 |
2026/05/26 05:47 |
tool |
grepper |
0m
Args: map[Expression:setup_data.*=]
Results: map[Output:
Full output is too long, showing 500 out of 570 lines.
Use more precise expression if possible.
[Documentation/arch/x86/boot.rst=941=sections::
--
Documentation/arch/x86/boot.rst-943- setup_header = .data
Documentation/arch/x86/boot.rst:944: boot_params/setup_data = .bss
Documentation/arch/x86/boot.rst-945-
--
arch/powerpc/platforms/512x/clock-commonclk.c=515=struct mclk_setup_data {
--
arch/powerpc/platforms/512x/clock-commonclk.c-560-
arch/powerpc/platforms/512x/clock-commonclk.c:561:static struct mclk_setup_data mclk_psc_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-562- MCLK_SETUP_DATA_PSC(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-575-
arch/powerpc/platforms/512x/clock-commonclk.c:576:static struct mclk_setup_data mclk_mscan_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-577- MCLK_SETUP_DATA_MSCAN(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-582-
arch/powerpc/platforms/512x/clock-commonclk.c:583:static struct mclk_setup_data mclk_spdif_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-584- MCLK_SETUP_DATA_SPDIF,
--
arch/powerpc/platforms/512x/clock-commonclk.c-586-
arch/powerpc/platforms/512x/clock-commonclk.c:587:static struct mclk_setup_data mclk_outclk_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-588- MCLK_SETUP_DATA_OUTCLK(0),
--
arch/x86/boot/compressed/efi.c=87=static struct efi_setup_data *get_kexec_setup_data(struct boot_params *bp,
--
arch/x86/boot/compressed/efi.c-90-#ifdef CONFIG_X86_64
arch/x86/boot/compressed/efi.c:91: struct efi_setup_data *esd = NULL;
arch/x86/boot/compressed/efi.c-92- struct setup_data *data;
--
arch/x86/boot/startup/sev-shared.c=530=struct cc_blob_sev_info *find_cc_blob_setup_data(struct boot_params *bp)
arch/x86/boot/startup/sev-shared.c-531-{
arch/x86/boot/startup/sev-shared.c:532: struct cc_setup_data *sd = NULL;
arch/x86/boot/startup/sev-shared.c-533- struct setup_data *hdr;
--
arch/x86/kernel/jailhouse.c=198=static void __init jailhouse_init_platform(void)
--
arch/x86/kernel/jailhouse.c-241- pa_data += offsetof(struct setup_data, data);
arch/x86/kernel/jailhouse.c:242: setup_data_len = min_t(unsigned long, sizeof(setup_data),
arch/x86/kernel/jailhouse.c-243- (unsigned long)header.len);
--
arch/x86/kernel/jailhouse.c-247-
arch/x86/kernel/jailhouse.c:248: if (setup_data.hdr.version == 0 ||
arch/x86/kernel/jailhouse.c:249: setup_data.hdr.compatible_version !=
arch/x86/kernel/jailhouse.c-250- JAILHOUSE_SETUP_REQUIRED_VERSION ||
arch/x86/kernel/jailhouse.c:251: (setup_data.hdr.version == 1 && header.len < SETUP_DATA_V1_LEN) ||
arch/x86/kernel/jailhouse.c:252: (setup_data.hdr.version >= 2 && header.len < SETUP_DATA_V2_LEN))
arch/x86/kernel/jailhouse.c-253- goto unsupported;
--
arch/x86/kernel/kdebugfs.c=29=static ssize_t setup_data_read(struct file *file, char __user *user_buf,
--
arch/x86/kernel/kdebugfs.c-31-{
arch/x86/kernel/kdebugfs.c:32: struct setup_data_node *node = file->private_data;
arch/x86/kernel/kdebugfs.c-33- unsigned long remain;
--
arch/x86/kernel/kdebugfs.c-68-
arch/x86/kernel/kdebugfs.c:69:static const struct file_operations fops_setup_data = {
arch/x86/kernel/kdebugfs.c-70- .read = setup_data_read,
--
arch/x86/kernel/kexec-bzimage64.c=125=setup_rng_seed(struct boot_params *params, unsigned long params_load_addr,
--
arch/x86/kernel/kexec-bzimage64.c-127-{
arch/x86/kernel/kexec-bzimage64.c:128: struct setup_data *sd = (void *)params + rng_seed_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-129- unsigned long setup_data_phys;
--
arch/x86/kernel/kexec-bzimage64.c-136- get_random_bytes(sd->data, RNG_SEED_LENGTH);
arch/x86/kernel/kexec-bzimage64.c:137: setup_data_phys = params_load_addr + rng_seed_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-138- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:139: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-140-}
--
arch/x86/kernel/kexec-bzimage64.c=165=prepare_add_efi_setup_data(struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-169- unsigned long setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c:170: struct setup_data *sd = (void *)params + efi_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:171: struct efi_setup_data *esd = (void *)sd + sizeof(struct setup_data);
arch/x86/kernel/kexec-bzimage64.c-172-
--
arch/x86/kernel/kexec-bzimage64.c-180- /* Add setup data */
arch/x86/kernel/kexec-bzimage64.c:181: setup_data_phys = params_load_addr + efi_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-182- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:183: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-184-
--
arch/x86/kernel/kexec-bzimage64.c=226=static void setup_dtb(struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-229-{
arch/x86/kernel/kexec-bzimage64.c:230: struct setup_data *sd = (void *)params + dtb_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-231- unsigned long setup_data_phys, dtb_len;
--
arch/x86/kernel/kexec-bzimage64.c-240- /* Add setup data */
arch/x86/kernel/kexec-bzimage64.c:241: setup_data_phys = params_load_addr + dtb_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-242- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:243: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-244-}
--
arch/x86/kernel/kexec-bzimage64.c=248=setup_ima_state(const struct kimage *image, struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-252-#ifdef CONFIG_IMA_KEXEC
arch/x86/kernel/kexec-bzimage64.c:253: struct setup_data *sd = (void *)params + ima_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-254- unsigned long setup_data_phys;
--
arch/x86/kernel/kexec-bzimage64.c-267- /* Add setup data */
arch/x86/kernel/kexec-bzimage64.c:268: setup_data_phys = params_load_addr + ima_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-269- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:270: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-271-#endif /* CONFIG_IMA_KEXEC */
--
arch/x86/kernel/kexec-bzimage64.c=274=static void setup_kho(const struct kimage *image, struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-277-{
arch/x86/kernel/kexec-bzimage64.c:278: struct setup_data *sd = (void *)params + setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-279- struct kho_data *kho = (void *)sd + sizeof(*sd);
--
arch/x86/kernel/kexec-bzimage64.c-296- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:297: params->hdr.setup_data = params_load_addr + setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-298-}
--
arch/x86/kernel/kexec-bzimage64.c=301=setup_boot_parameters(struct kimage *image, struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-367- setup_data_offset);
arch/x86/kernel/kexec-bzimage64.c:368: setup_data_offset += sizeof(struct setup_data) +
arch/x86/kernel/kexec-bzimage64.c-369- sizeof(struct efi_setup_data);
--
arch/x86/kernel/kexec-bzimage64.c-374- setup_dtb(params, params_load_addr, setup_data_offset);
arch/x86/kernel/kexec-bzimage64.c:375: setup_data_offset += sizeof(struct setup_data) +
arch/x86/kernel/kexec-bzimage64.c-376- fdt_totalsize(initial_boot_params);
--
arch/x86/kernel/kexec-bzimage64.c-386- setup_data_offset);
arch/x86/kernel/kexec-bzimage64.c:387: setup_data_offset += sizeof(struct setup_data) +
arch/x86/kernel/kexec-bzimage64.c-388- sizeof(struct ima_setup_data);
--
arch/x86/kernel/kexec-bzimage64.c-393- setup_kho(image, params, params_load_addr, setup_data_offset);
arch/x86/kernel/kexec-bzimage64.c:394: setup_data_offset += sizeof(struct setup_data) +
arch/x86/kernel/kexec-bzimage64.c-395- sizeof(struct kho_data);
--
arch/x86/kernel/kexec-bzimage64.c=475=static void *bzImage64_load(struct kimage *image, char *kernel,
--
arch/x86/kernel/kexec-bzimage64.c-593- efi_map_offset = params_cmdline_sz;
arch/x86/kernel/kexec-bzimage64.c:594: efi_setup_data_offset = efi_map_offset + ALIGN(efi_map_sz, 16);
arch/x86/kernel/kexec-bzimage64.c-595-
--
arch/x86/kernel/ksysfs.c=248=static struct bin_attribute data_attr __ro_after_init = {
--
arch/x86/kernel/ksysfs.c-255-
arch/x86/kernel/ksysfs.c:256:static struct attribute *setup_data_type_attrs[] = {
arch/x86/kernel/ksysfs.c-257- &type_attr.attr,
--
arch/x86/kernel/ksysfs.c-260-
arch/x86/kernel/ksysfs.c:261:static const struct bin_attribute *const setup_data_data_attrs[] = {
arch/x86/kernel/ksysfs.c-262- &data_attr,
--
arch/x86/kernel/ksysfs.c-265-
arch/x86/kernel/ksysfs.c:266:static const struct attribute_group setup_data_attr_group = {
arch/x86/kernel/ksysfs.c-267- .attrs = setup_data_type_attrs,
--
arch/x86/kernel/ksysfs.c=327=static int __init create_setup_data_nodes(struct kobject *parent)
--
arch/x86/kernel/ksysfs.c-336-
arch/x86/kernel/ksysfs.c:337: setup_data_kobj = kobject_create_and_add("setup_data", parent);
arch/x86/kernel/ksysfs.c-338- if (!setup_data_kobj) {
--
arch/x86/mm/ioremap.c=641=static bool __ref __memremap_is_setup_data(resource_size_t phys_addr, bool early)
arch/x86/mm/ioremap.c-642-{
arch/x86/mm/ioremap.c:643: unsigned int setup_data_sz = sizeof(struct setup_data);
arch/x86/mm/ioremap.c-644- struct setup_indirect *indirect;
--
drivers/ata/pata_cmd640.c=52=static void cmd640_set_piomode(struct ata_port *ap, struct ata_device *adev)
--
drivers/ata/pata_cmd640.c-57- const unsigned long T = 1000000 / 33;
drivers/ata/pata_cmd640.c:58: const u8 setup_data[] = { 0x40, 0x40, 0x40, 0x80, 0x00 };
drivers/ata/pata_cmd640.c-59- u8 reg;
--
drivers/ata/pata_cmd64x.c=94=static void cmd64x_set_timing(struct ata_port *ap, struct ata_device *adev, u8 mode)
--
drivers/ata/pata_cmd64x.c-98- const unsigned long T = 1000000 / 33;
drivers/ata/pata_cmd64x.c:99: const u8 setup_data[] = { 0x40, 0x40, 0x40, 0x80, 0x00 };
drivers/ata/pata_cmd64x.c-100-
--
drivers/firmware/efi/libstub/x86-stub.c=115=static void setup_efi_pci(struct boot_params *params)
--
drivers/firmware/efi/libstub/x86-stub.c-149- else
drivers/firmware/efi/libstub/x86-stub.c:150: params->hdr.setup_data = (unsigned long)rom;
drivers/firmware/efi/libstub/x86-stub.c-151-
--
drivers/firmware/efi/libstub/x86-stub.c=156=static void retrieve_apple_device_properties(struct boot_params *boot_params)
--
drivers/firmware/efi/libstub/x86-stub.c-197- if (!data) {
drivers/firmware/efi/libstub/x86-stub.c:198: boot_params->hdr.setup_data = (unsigned long)new;
drivers/firmware/efi/libstub/x86-stub.c-199- } else {
--
drivers/firmware/efi/libstub/x86-stub.c=551=static void add_e820ext(struct boot_params *params,
--
drivers/firmware/efi/libstub/x86-stub.c-567- else
drivers/firmware/efi/libstub/x86-stub.c:568: params->hdr.setup_data = (unsigned long)e820ext;
drivers/firmware/efi/libstub/x86-stub.c-569-}
--
drivers/firmware/efi/libstub/x86-stub.c=757=static efi_status_t exit_boot(struct boot_params *boot_params, void *handle)
drivers/firmware/efi/libstub/x86-stub.c-758-{
drivers/firmware/efi/libstub/x86-stub.c:759: struct setup_data *e820ext = NULL;
drivers/firmware/efi/libstub/x86-stub.c-760- __u32 e820ext_size = 0;
--
drivers/i2c/busses/i2c-mlxbf.c=1158=static const struct mlxbf_i2c_timings mlxbf_i2c_timings[] = {
--
drivers/i2c/busses/i2c-mlxbf.c-1164- .setup_stop = 4000,
drivers/i2c/busses/i2c-mlxbf.c:1165: .setup_data = 250,
drivers/i2c/busses/i2c-mlxbf.c-1166- .sda_rise = 50,
--
drivers/i2c/busses/i2c-mlxbf.c-1180- .setup_stop = 600,
drivers/i2c/busses/i2c-mlxbf.c:1181: .setup_data = 100,
drivers/i2c/busses/i2c-mlxbf.c-1182- .sda_rise = 50,
--
drivers/i2c/busses/i2c-mlxbf.c-1196- .setup_stop = 260,
drivers/i2c/busses/i2c-mlxbf.c:1197: .setup_data = 50,
drivers/i2c/busses/i2c-mlxbf.c-1198- .sda_rise = 50,
--
drivers/i2c/busses/i2c-rk3x.c=745=static int rk3x_i2c_v1_calc_timings(unsigned long clk_rate,
--
drivers/i2c/busses/i2c-rk3x.c-835- * 1000000, clk_rate_khz);
drivers/i2c/busses/i2c-rk3x.c:836: min_setup_data_ns = DIV_ROUND_UP(((8 - sda_update_cfg)
drivers/i2c/busses/i2c-rk3x.c-837- * (t_calc->div_low) + 1)
--
drivers/net/ethernet/freescale/fs_enet/mac-fcc.c=559=const struct fs_ops fs_fcc_ops = {
drivers/net/ethernet/freescale/fs_enet/mac-fcc.c:560: .setup_data = setup_data,
drivers/net/ethernet/freescale/fs_enet/mac-fcc.c-561- .cleanup_data = cleanup_data,
--
drivers/net/ethernet/freescale/fs_enet/mac-fec.c=448=const struct fs_ops fs_fec_ops = {
drivers/net/ethernet/freescale/fs_enet/mac-fec.c:449: .setup_data = setup_data,
drivers/net/ethernet/freescale/fs_enet/mac-fec.c-450- .cleanup_data = cleanup_data,
--
drivers/net/ethernet/freescale/fs_enet/mac-scc.c=456=const struct fs_ops fs_scc_ops = {
drivers/net/ethernet/freescale/fs_enet/mac-scc.c:457: .setup_data = setup_data,
drivers/net/ethernet/freescale/fs_enet/mac-scc.c-458- .cleanup_data = cleanup_data,
--
drivers/usb/gadget/udc/pch_udc.c=2307=static void pch_udc_svc_control_out(struct pch_udc_dev *dev)
--
drivers/usb/gadget/udc/pch_udc.c-2324- dev->ep[UDC_EP0OUT_IDX].halted = 0;
drivers/usb/gadget/udc/pch_udc.c:2325: dev->setup_data = ep->td_stp->request;
drivers/usb/gadget/udc/pch_udc.c-2326- pch_udc_init_setup_buff(ep->td_stp);
--
drivers/usb/gadget/udc/pch_udc.c-2334- /* If Mass storage Reset */
drivers/usb/gadget/udc/pch_udc.c:2335: if ((dev->setup_data.bRequestType == 0x21) &&
drivers/usb/gadget/udc/pch_udc.c:2336: (dev->setup_data.bRequest == 0xFF))
drivers/usb/gadget/udc/pch_udc.c-2337- dev->prot_stall = 0;
--
drivers/usb/gadget/udc/pch_udc.c=2556=static void pch_udc_svc_intf_interrupt(struct pch_udc_dev *dev)
--
drivers/usb/gadget/udc/pch_udc.c-2568- memset(&dev->setup_data, 0 , sizeof dev->setup_data);
drivers/usb/gadget/udc/pch_udc.c:2569: dev->setup_data.bRequest = USB_REQ_SET_INTERFACE;
drivers/usb/gadget/udc/pch_udc.c:2570: dev->setup_data.bRequestType = USB_RECIP_INTERFACE;
drivers/usb/gadget/udc/pch_udc.c:2571: dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_alt);
drivers/usb/gadget/udc/pch_udc.c:2572: dev->setup_data.wIndex = cpu_to_le16(dev->cfg_data.cur_intf);
drivers/usb/gadget/udc/pch_udc.c-2573- /* programm the Endpoint Cfg registers */
--
drivers/usb/gadget/udc/pch_udc.c=2595=static void pch_udc_svc_cfg_interrupt(struct pch_udc_dev *dev)
--
drivers/usb/gadget/udc/pch_udc.c-2605- memset(&dev->setup_data, 0 , sizeof dev->setup_data);
drivers/usb/gadget/udc/pch_udc.c:2606: dev->setup_data.bRequest = USB_REQ_SET_CONFIGURATION;
drivers/usb/gadget/udc/pch_udc.c:2607: dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_cfg);
drivers/usb/gadget/udc/pch_udc.c-2608- /* program the NE registers */
--
drivers/usb/gadget/udc/snps_udc_core.c=2425=__acquires(dev->lock)
--
drivers/usb/gadget/udc/snps_udc_core.c-2473-
drivers/usb/gadget/udc/snps_udc_core.c:2474: setup_data.data[0] =
drivers/usb/gadget/udc/snps_udc_core.c-2475- dev->ep[UDC_EP0OUT_IX].td_stp->data12;
drivers/usb/gadget/udc/snps_udc_core.c:2476: setup_data.data[1] =
drivers/usb/gadget/udc/snps_udc_core.c-2477- dev->ep[UDC_EP0OUT_IX].td_stp->data34;
--
drivers/usb/gadget/udc/snps_udc_core.c-2486- /* determine direction of control data */
drivers/usb/gadget/udc/snps_udc_core.c:2487: if ((setup_data.request.bRequestType & USB_DIR_IN) != 0) {
drivers/usb/gadget/udc/snps_udc_core.c-2488- dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IX].ep;
--
drivers/usb/gadget/udc/snps_udc_core.c-2525- */
drivers/usb/gadget/udc/snps_udc_core.c:2526: if (setup_data.data[0] == UDC_MSCRES_DWORD0
drivers/usb/gadget/udc/snps_udc_core.c:2527: && setup_data.data[1] == UDC_MSCRES_DWORD1) {
drivers/usb/gadget/udc/snps_udc_core.c-2528- DBG(dev, "MSC Reset\n");
--
drivers/usb/gadget/udc/snps_udc_core.c=2741=__acquires(dev->lock)
--
drivers/usb/gadget/udc/snps_udc_core.c-2762- memset(&setup_data, 0 , sizeof(union udc_setup_data));
drivers/usb/gadget/udc/snps_udc_core.c:2763: setup_data.request.bRequest = USB_REQ_SET_CONFIGURATION;
drivers/usb/gadget/udc/snps_udc_core.c:2764: setup_data.request.wValue = cpu_to_le16(dev->cur_config);
drivers/usb/gadget/udc/snps_udc_core.c-2765-
--
drivers/usb/gadget/udc/snps_udc_core.c-2810- memset(&setup_data, 0 , sizeof(union udc_setup_data));
drivers/usb/gadget/udc/snps_udc_core.c:2811: setup_data.request.bRequest = USB_REQ_SET_INTERFACE;
drivers/usb/gadget/udc/snps_udc_core.c:2812: setup_data.request.bRequestType = USB_RECIP_INTERFACE;
drivers/usb/gadget/udc/snps_udc_core.c:2813: setup_data.request.wValue = cpu_to_le16(dev->cur_alt);
drivers/usb/gadget/udc/snps_udc_core.c:2814: setup_data.request.wIndex = cpu_to_le16(dev->cur_intf);
drivers/usb/gadget/udc/snps_udc_core.c-2815-
--
fs/lockd/clntproc.c=343=static struct rpc_task *__nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops)
--
fs/lockd/clntproc.c-346- struct rpc_clnt *clnt;
fs/lockd/clntproc.c:347: struct rpc_task_setup task_setup_data = {
fs/lockd/clntproc.c-348- .rpc_message = msg,
--
fs/lockd/clntproc.c-361- msg->rpc_proc = &clnt->cl_procinfo[proc];
fs/lockd/clntproc.c:362: task_setup_data.rpc_client = clnt;
fs/lockd/clntproc.c-363-
--
fs/nfs/nfs42proc.c=639=static int nfs42_do_offload_cancel_async(struct file *dst,
--
fs/nfs/nfs42proc.c-649- };
fs/nfs/nfs42proc.c:650: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs42proc.c-651- .rpc_client = dst_server->client,
--
fs/nfs/nfs42proc.c-671- msg.rpc_resp = &data->res;
fs/nfs/nfs42proc.c:672: task_setup_data.callback_data = data;
fs/nfs/nfs42proc.c-673- nfs4_init_sequence(dst_server->nfs_client, &data->args.osa_seq_args,
--
fs/nfs/nfs4proc.c=2431=static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
--
fs/nfs/nfs4proc.c-2440- };
fs/nfs/nfs4proc.c:2441: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-2442- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c=2594=static int nfs4_run_open_task(struct nfs4_opendata *data,
--
fs/nfs/nfs4proc.c-2608- };
fs/nfs/nfs4proc.c:2609: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-2610- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c-2619- if (nfs_server_capable(dir, NFS_CAP_MOVEABLE))
fs/nfs/nfs4proc.c:2620: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/nfs4proc.c-2621-
--
fs/nfs/nfs4proc.c-2629- data->is_recover = true;
fs/nfs/nfs4proc.c:2630: task_setup_data.flags |= RPC_TASK_TIMEOUT;
fs/nfs/nfs4proc.c-2631- } else {
--
fs/nfs/nfs4proc.c=3750=int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
--
fs/nfs/nfs4proc.c-3761- };
fs/nfs/nfs4proc.c:3762: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-3763- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c-3771- if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE))
fs/nfs/nfs4proc.c:3772: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/nfs4proc.c-3773-
--
fs/nfs/nfs4proc.c-3808- msg.rpc_resp = &calldata->res;
fs/nfs/nfs4proc.c:3809: task_setup_data.callback_data = calldata;
fs/nfs/nfs4proc.c-3810- task = rpc_run_task(&task_setup_data);
--
fs/nfs/nfs4proc.c=6550=int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
--
fs/nfs/nfs4proc.c-6565- };
fs/nfs/nfs4proc.c:6566: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-6567- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c=6802=static int _nfs4_proc_delegreturn(struct inode *inode, const struct cred *cred,
--
fs/nfs/nfs4proc.c-6813- };
fs/nfs/nfs4proc.c:6814: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-6815- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c-6822- if (nfs_server_capable(inode, NFS_CAP_MOVEABLE))
fs/nfs/nfs4proc.c:6823: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/nfs4proc.c-6824-
--
fs/nfs/nfs4proc.c-6873-
fs/nfs/nfs4proc.c:6874: task_setup_data.callback_data = data;
fs/nfs/nfs4proc.c-6875- msg.rpc_argp = &data->args;
--
fs/nfs/nfs4proc.c=7145=static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
--
fs/nfs/nfs4proc.c-7155- };
fs/nfs/nfs4proc.c:7156: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-7157- .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
--
fs/nfs/nfs4proc.c-7164- if (nfs_server_capable(lsp->ls_state->inode, NFS_CAP_MOVEABLE))
fs/nfs/nfs4proc.c:7165: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/nfs4proc.c-7166-
--
fs/nfs/nfs4proc.c-7185- msg.rpc_resp = &data->res;
fs/nfs/nfs4proc.c:7186: task_setup_data.callback_data = data;
fs/nfs/nfs4proc.c-7187- return rpc_run_task(&task_setup_data);
--
fs/nfs/nfs4proc.c=7429=static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
--
fs/nfs/nfs4proc.c-7437- };
fs/nfs/nfs4proc.c:7438: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-7439- .rpc_client = NFS_CLIENT(state->inode),
--
fs/nfs/nfs4proc.c-7447- if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE))
fs/nfs/nfs4proc.c:7448: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/nfs4proc.c-7449-
--
fs/nfs/nfs4proc.c-7460- msg.rpc_resp = &data->res;
fs/nfs/nfs4proc.c:7461: task_setup_data.callback_data = data;
fs/nfs/nfs4proc.c-7462- if (recovery_type > NFS_LOCK_NEW) {
--
fs/nfs/nfs4proc.c=8116=static int _nfs41_proc_get_locations(struct nfs_server *server,
--
fs/nfs/nfs4proc.c-8146- };
fs/nfs/nfs4proc.c:8147: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-8148- .rpc_client = clnt,
--
fs/nfs/nfs4proc.c=8444=int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
--
fs/nfs/nfs4proc.c-8462- };
fs/nfs/nfs4proc.c:8463: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-8464- .rpc_client = clnt,
--
fs/nfs/nfs4proc.c=8689=nfs4_run_exchange_id(struct nfs_client *clp, const struct cred *cred,
--
fs/nfs/nfs4proc.c-8695- };
fs/nfs/nfs4proc.c:8696: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-8697- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c-8749- if (xprt) {
fs/nfs/nfs4proc.c:8750: task_setup_data.rpc_xprt = xprt;
fs/nfs/nfs4proc.c:8751: task_setup_data.flags |= RPC_TASK_SOFTCONN;
fs/nfs/nfs4proc.c-8752- memcpy(calldata->args.verifier.data, clp->cl_confirm.data,
--
fs/nfs/nfs4proc.c-8764- msg.rpc_resp = &calldata->res;
fs/nfs/nfs4proc.c:8765: task_setup_data.callback_data = calldata;
fs/nfs/nfs4proc.c-8766-
--
fs/nfs/nfs4proc.c=9376=static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
--
fs/nfs/nfs4proc.c-9385- };
fs/nfs/nfs4proc.c:9386: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9387- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c-9406- calldata->clp = clp;
fs/nfs/nfs4proc.c:9407: task_setup_data.callback_data = calldata;
fs/nfs/nfs4proc.c-9408-
--
fs/nfs/nfs4proc.c=9530=static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
--
fs/nfs/nfs4proc.c-9537- };
fs/nfs/nfs4proc.c:9538: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9539- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c-9554- msg.rpc_resp = &calldata->res;
fs/nfs/nfs4proc.c:9555: task_setup_data.callback_data = calldata;
fs/nfs/nfs4proc.c-9556- status = nfs4_call_sync_custom(&task_setup_data);
--
fs/nfs/nfs4proc.c=9693=nfs4_proc_layoutget(struct nfs4_layoutget *lgp,
--
fs/nfs/nfs4proc.c-9704- };
fs/nfs/nfs4proc.c:9705: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9706- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c=9850=int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, unsigned int flags)
--
fs/nfs/nfs4proc.c-9859- };
fs/nfs/nfs4proc.c:9860: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9861- .rpc_client = NFS_SERVER(lrp->args.inode)->client,
--
fs/nfs/nfs4proc.c-9877- }
fs/nfs/nfs4proc.c:9878: task_setup_data.flags |= RPC_TASK_ASYNC;
fs/nfs/nfs4proc.c-9879- }
--
fs/nfs/nfs4proc.c=10002=nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
--
fs/nfs/nfs4proc.c-10009- };
fs/nfs/nfs4proc.c:10010: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-10011- .task = &data->task,
--
fs/nfs/nfs4proc.c-10031- }
fs/nfs/nfs4proc.c:10032: task_setup_data.flags = RPC_TASK_ASYNC;
fs/nfs/nfs4proc.c-10033- }
--
fs/nfs/pagelist.c=733=int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr,
--
fs/nfs/pagelist.c-743- };
fs/nfs/pagelist.c:744: struct rpc_task_setup task_setup_data = {
fs/nfs/pagelist.c-745- .rpc_client = clnt,
--
fs/nfs/pagelist.c-754- if (nfs_server_capable(hdr->inode, NFS_CAP_MOVEABLE))
fs/nfs/pagelist.c:755: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/pagelist.c-756-
--
fs/nfs/unlink.c=89=static void nfs_do_call_unlink(struct inode *inode, struct nfs_unlinkdata *data)
--
fs/nfs/unlink.c-95- };
fs/nfs/unlink.c:96: struct rpc_task_setup task_setup_data = {
fs/nfs/unlink.c-97- .rpc_message = &msg,
--
fs/nfs/unlink.c-106- if (nfs_server_capable(inode, NFS_CAP_MOVEABLE))
fs/nfs/unlink.c:107: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/unlink.c-108-
--
fs/nfs/unlink.c-114-
fs/nfs/unlink.c:115: task_setup_data.rpc_client = NFS_CLIENT(dir);
fs/nfs/unlink.c-116- task = rpc_run_task(&task_setup_data);
--
fs/nfs/unlink.c=340=nfs_async_rename(struct inode *old_dir, struct inode *new_dir,
--
fs/nfs/unlink.c-345- struct rpc_message msg = { };
fs/nfs/unlink.c:346: struct rpc_task_setup task_setup_data = {
fs/nfs/unlink.c-347- .rpc_message = &msg,
--
fs/nfs/unlink.c-355- nfs_server_capable(new_dir, NFS_CAP_MOVEABLE))
fs/nfs/unlink.c:356: task_setup_data.flags |= RPC_TASK_MOVEABLE;
fs/nfs/unlink.c-357-
]
]
|
| 46/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 68494
output: 45
thoughts: 818
Thoughts: **Analyzing a Potential Kernel Vulnerability**
Okay, so I'm looking at this bug report and the first thing that jumps out is that `setup_data` is implemented as a linked list in memory. That structure definition is right there:
```c
struct setup_data {
__u64 next;
__u32 type;
__u32 len;
__u8 data[];
};
```
The issue seems to stem from a problem with either `boot_params.hdr.setup_data` itself, or the `next` pointer within any of those `setup_data` elements. Modifying either could be the root cause. My immediate thought is, "Can Syzkaller even touch those things?"
`boot_params` is in the `.bss` or `.data` section, so it should be in memory somewhere, and I'd be interested if any sysfs files allow writing to this region. I quickly checked `boot_params_data_attr`, and it's marked read-only (`S_IRUGO`), so that's a dead end. What about the `setup_data` sysfs files? `setup_data_data_attrs` are also read-only. Hmm.
I'm thinking about how Syzkaller works, and it hits me: what about `kexec_file_load`? That function allows us to load a new kernel. Does it actually touch the `boot_params` of the *current* kernel, or does it set up a new `boot_params` for the *new* kernel? Nope, the new kernel gets its own, so that's not the issue.
What about something lower level, like `/dev/port` or `/dev/mem`? Syzkaller usually doesn't have access to those unless it's running as root, and `CONFIG_STRICT_DEVMEM` is disabled, but Syzkaller *usually* runs as root inside its VM. The bug report says `CPU: 0 UID: 0 PID: 30414 Comm: syz.5.5717`. UID 0 means root, so we have to consider that. Root access can mean that `/dev/mem` becomes a real possibility *if* it's enabled. However, these bugs are usually more interesting if unprivileged users can trigger them, or if the crash shouldn't happen even as root.
Hold on a second, the warning is triggered by `dev_rescan_store`, which requires root. Writing to `/sys/bus/pci/devices/.../rescan` calls `dev_rescan_store`. It looks like an invalid `boot_params.hdr.setup_data` leads to a warning in `pcibios_device_add`. What's causing it to be invalid?
Could it be that the memory where the `setup_data` structure lives is valid during boot, but then gets freed or unmapped? Then a subsequent call to `memremap` fails, perhaps? No, `memremap` maps *physical* memory. It doesn't care if that memory has been freed. It just maps it.
Right, the warning is actually saying: `ioremap: invalid physical address 4ff4208dd89fe53e`. That address is clearly garbage. How did `pa_data` get that value? `pa_data` is either read from `boot_params.hdr.setup_data` or a `data->next` pointer. If `data->next` has a garbage value, then the `setup_data` structure in physical memory *contains* garbage.
How can a `setup_data` structure in physical memory contain garbage? It must be that memory was allocated during boot, then *freed*, and then *reused* and overwritten with something else! That's the key. Let's check to see if that `setup_data` physical memory is reserved during boot. I need to look for that.
|
| 47/2 |
2026/05/26 05:47 |
tool |
codesearch-definition-source |
0m
Error:
Args: map[ContextFile:arch/x86/kernel/setup.c IncludeLines:true Name:reserve_setup_data]
Results: map[SourceCode: SourceFile:]
|
| 48/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 70243
output: 17
thoughts: 24
Thoughts: Here's my thought process, as it just occurred to me:
**Finding the Setup Function**
Okay, so I need to find where the `setup_data` structure is initialized, right? That's the key to understanding how the kernel configures the system at boot. Given this is x86, the initialization is probably going to be in `arch/x86/kernel/`. That feels like the logical place to start. Now, I vaguely recall something about a `setup.c` file being the usual suspect for low-level platform-specific initializations. Let me just search for `setup_data` within `arch/x86/kernel/setup.c`. That should hopefully pinpoint exactly where I need to look. Hopefully, that will lead me to the relevant data structure and the functions that manipulate it.
|
| 49/2 |
2026/05/26 05:47 |
tool |
grepper |
0m
Args: map[Expression:setup_data]
Results: map[Output:
Full output is too long, showing 500 out of 1983 lines.
Use more precise expression if possible.
[Documentation/ABI/testing/sysfs-kernel-boot_params=4=Description: The /sys/kernel/boot_params directory contains two
Documentation/ABI/testing/sysfs-kernel-boot_params:5: files: "data" and "version" and one subdirectory "setup_data".
Documentation/ABI/testing/sysfs-kernel-boot_params-6- It is used to export the kernel boot parameters of an x86
--
Documentation/ABI/testing/sysfs-kernel-boot_params-8-
Documentation/ABI/testing/sysfs-kernel-boot_params:9: If there's no setup_data in boot_params the subdirectory will
Documentation/ABI/testing/sysfs-kernel-boot_params-10- not be created.
--
Documentation/ABI/testing/sysfs-kernel-boot_params-16-
Documentation/ABI/testing/sysfs-kernel-boot_params:17: "setup_data" subdirectory contains the setup_data data
Documentation/ABI/testing/sysfs-kernel-boot_params:18: structure in boot_params. setup_data is maintained in kernel
Documentation/ABI/testing/sysfs-kernel-boot_params:19: as a link list. In "setup_data" subdirectory there's one
Documentation/ABI/testing/sysfs-kernel-boot_params-20- subdirectory for each link list node named with the number
--
Documentation/ABI/testing/sysfs-kernel-boot_params-22- files "type" and "data". "type" file is the string
Documentation/ABI/testing/sysfs-kernel-boot_params:23: representation of setup_data type. "data" file is the binary
Documentation/ABI/testing/sysfs-kernel-boot_params:24: representation of setup_data payload.
Documentation/ABI/testing/sysfs-kernel-boot_params-25-
--
Documentation/ABI/testing/sysfs-kernel-boot_params-29- |__ data
Documentation/ABI/testing/sysfs-kernel-boot_params:30: |__ setup_data
Documentation/ABI/testing/sysfs-kernel-boot_params-31- | |__ 0
--
Documentation/arch/x86/boot.rst=54=Protocol 2.09 (Kernel 2.6.26) Added a field of 64-bit physical
Documentation/arch/x86/boot.rst:55: pointer to single linked list of struct setup_data.
Documentation/arch/x86/boot.rst-56-
--
Documentation/arch/x86/boot.rst=187=Offset/Size Proto Name Meaning
--
Documentation/arch/x86/boot.rst-222-024C/4 2.08+ payload_length Length of kernel payload
Documentation/arch/x86/boot.rst:223:0250/8 2.09+ setup_data 64-bit physical pointer to linked list
Documentation/arch/x86/boot.rst:224: of struct setup_data
Documentation/arch/x86/boot.rst-225-0258/8 2.10+ pref_address Preferred loading address
--
Documentation/arch/x86/boot.rst=794=Protocol: 2.08+
--
Documentation/arch/x86/boot.rst-799-============ ===============
Documentation/arch/x86/boot.rst:800:Field name: setup_data
Documentation/arch/x86/boot.rst-801-Type: write (special)
--
Documentation/arch/x86/boot.rst=803=Protocol: 2.09+
--
Documentation/arch/x86/boot.rst-806- The 64-bit physical pointer to NULL terminated single linked list of
Documentation/arch/x86/boot.rst:807: struct setup_data. This is used to define a more extensible boot
Documentation/arch/x86/boot.rst:808: parameters passing mechanism. The definition of struct setup_data is
Documentation/arch/x86/boot.rst-809- as follow::
Documentation/arch/x86/boot.rst-810-
Documentation/arch/x86/boot.rst:811: struct setup_data {
Documentation/arch/x86/boot.rst-812- __u64 next;
--
Documentation/arch/x86/boot.rst-827-
Documentation/arch/x86/boot.rst:828: The setup_data is a bit awkward to use for extremely large data objects,
Documentation/arch/x86/boot.rst:829: both because the setup_data header has to be adjacent to the data object
Documentation/arch/x86/boot.rst-830- and because it has a 32-bit length field. However, it is important that
--
Documentation/arch/x86/boot.rst-849- Let's give an example how to point to SETUP_E820_EXT data using setup_indirect.
Documentation/arch/x86/boot.rst:850: In this case setup_data and setup_indirect will look like this::
Documentation/arch/x86/boot.rst-851-
Documentation/arch/x86/boot.rst:852: struct setup_data {
Documentation/arch/x86/boot.rst:853: .next = 0, /* or <addr_of_next_setup_data_struct> */
Documentation/arch/x86/boot.rst-854- .type = SETUP_INDIRECT,
--
Documentation/arch/x86/boot.rst=941=sections::
--
Documentation/arch/x86/boot.rst-943- setup_header = .data
Documentation/arch/x86/boot.rst:944: boot_params/setup_data = .bss
Documentation/arch/x86/boot.rst-945-
--
Documentation/arch/x86/boot.rst=952=Also, the BIOS stub is responsible for creating boot_params, so it isn't
Documentation/arch/x86/boot.rst:953:available to a BIOS-based loader (setup_data is, though).
Documentation/arch/x86/boot.rst-954-
--
Documentation/arch/x86/boot.rst=962=boot_params proper is limited to 4096 bytes, but can be arbitrarily extended
Documentation/arch/x86/boot.rst:963:by adding setup_data entries. It cannot be used to communicate properties of
Documentation/arch/x86/boot.rst-964-the kernel image, because it is .bss and has no image-provided content.
--
Documentation/arch/x86/boot.rst=969=necessary it can still contain data items that an enabled bootloader would be
Documentation/arch/x86/boot.rst:970:expected to copy into a setup_data chunk.
Documentation/arch/x86/boot.rst-971-
--
Documentation/arch/x86/boot.rst=1035=Offset/size: 0x000c/4
--
Documentation/arch/x86/boot.rst-1037-
Documentation/arch/x86/boot.rst:1038: This field contains maximal allowed type for setup_data and setup_indirect structs.
Documentation/arch/x86/boot.rst-1039-
--
Documentation/arch/x86/booting-dt.rst=3=DeviceTree Booting
--
Documentation/arch/x86/booting-dt.rst-10- Documentation/arch/x86/boot.rst
Documentation/arch/x86/booting-dt.rst:11: The physical pointer to the device-tree block is passed via setup_data
Documentation/arch/x86/booting-dt.rst-12- which requires at least boot protocol 2.09.
--
arch/powerpc/platforms/512x/clock-commonclk.c=508=enum mclk_type {
--
arch/powerpc/platforms/512x/clock-commonclk.c-514-
arch/powerpc/platforms/512x/clock-commonclk.c:515:struct mclk_setup_data {
arch/powerpc/platforms/512x/clock-commonclk.c-516- enum mclk_type type;
--
arch/powerpc/platforms/512x/clock-commonclk.c-560-
arch/powerpc/platforms/512x/clock-commonclk.c:561:static struct mclk_setup_data mclk_psc_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-562- MCLK_SETUP_DATA_PSC(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-575-
arch/powerpc/platforms/512x/clock-commonclk.c:576:static struct mclk_setup_data mclk_mscan_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-577- MCLK_SETUP_DATA_MSCAN(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-582-
arch/powerpc/platforms/512x/clock-commonclk.c:583:static struct mclk_setup_data mclk_spdif_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-584- MCLK_SETUP_DATA_SPDIF,
--
arch/powerpc/platforms/512x/clock-commonclk.c-586-
arch/powerpc/platforms/512x/clock-commonclk.c:587:static struct mclk_setup_data mclk_outclk_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-588- MCLK_SETUP_DATA_OUTCLK(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-594-/* setup the MCLK clock subtree of an individual PSC/MSCAN/SPDIF */
arch/powerpc/platforms/512x/clock-commonclk.c:595:static void __init mpc512x_clk_setup_mclk(struct mclk_setup_data *entry, size_t idx)
arch/powerpc/platforms/512x/clock-commonclk.c-596-{
--
arch/x86/boot/compressed/efi.c=60=unsigned long efi_get_system_table(struct boot_params *bp)
--
arch/x86/boot/compressed/efi.c-83- * not be accessible for the kexec'd kernel. To address this, kexec provides
arch/x86/boot/compressed/efi.c:84: * the initial physical address via a struct setup_data entry, which is
arch/x86/boot/compressed/efi.c-85- * checked for here, along with some sanity checks.
arch/x86/boot/compressed/efi.c-86- */
arch/x86/boot/compressed/efi.c:87:static struct efi_setup_data *get_kexec_setup_data(struct boot_params *bp,
arch/x86/boot/compressed/efi.c-88- enum efi_type et)
--
arch/x86/boot/compressed/efi.c-90-#ifdef CONFIG_X86_64
arch/x86/boot/compressed/efi.c:91: struct efi_setup_data *esd = NULL;
arch/x86/boot/compressed/efi.c:92: struct setup_data *data;
arch/x86/boot/compressed/efi.c-93- u64 pa_data;
arch/x86/boot/compressed/efi.c-94-
arch/x86/boot/compressed/efi.c:95: pa_data = bp->hdr.setup_data;
arch/x86/boot/compressed/efi.c-96- while (pa_data) {
arch/x86/boot/compressed/efi.c:97: data = (struct setup_data *)pa_data;
arch/x86/boot/compressed/efi.c-98- if (data->type == SETUP_EFI) {
arch/x86/boot/compressed/efi.c:99: esd = (struct efi_setup_data *)(pa_data + sizeof(struct setup_data));
arch/x86/boot/compressed/efi.c-100- break;
--
arch/x86/boot/compressed/efi.c=131=int efi_get_conf_table(struct boot_params *bp, unsigned long *cfg_tbl_pa,
--
arch/x86/boot/compressed/efi.c-148- efi_system_table_64_t *stbl = (efi_system_table_64_t *)sys_tbl_pa;
arch/x86/boot/compressed/efi.c:149: struct efi_setup_data *esd;
arch/x86/boot/compressed/efi.c-150-
arch/x86/boot/compressed/efi.c-151- /* kexec provides an alternative EFI conf table, check for it. */
arch/x86/boot/compressed/efi.c:152: esd = get_kexec_setup_data(bp, et);
arch/x86/boot/compressed/efi.c-153-
--
arch/x86/boot/compressed/ident_map_64.c=110=void initialize_identity_maps(void *rmode)
--
arch/x86/boot/compressed/ident_map_64.c-112- unsigned long cmdline;
arch/x86/boot/compressed/ident_map_64.c:113: struct setup_data *sd;
arch/x86/boot/compressed/ident_map_64.c-114-
--
arch/x86/boot/compressed/ident_map_64.c-168- /*
arch/x86/boot/compressed/ident_map_64.c:169: * Also map the setup_data entries passed via boot_params in case they
arch/x86/boot/compressed/ident_map_64.c-170- * need to be accessed by uncompressed kernel via the identity mapping.
arch/x86/boot/compressed/ident_map_64.c-171- */
arch/x86/boot/compressed/ident_map_64.c:172: sd = (struct setup_data *)boot_params_ptr->hdr.setup_data;
arch/x86/boot/compressed/ident_map_64.c-173- while (sd) {
--
arch/x86/boot/compressed/ident_map_64.c-176- kernel_add_identity_map(sd_addr, sd_addr + sizeof(*sd) + sd->len);
arch/x86/boot/compressed/ident_map_64.c:177: sd = (struct setup_data *)sd->next;
arch/x86/boot/compressed/ident_map_64.c-178- }
--
arch/x86/boot/compressed/kaslr.c=354=static void mem_avoid_init(unsigned long input, unsigned long input_size,
--
arch/x86/boot/compressed/kaslr.c-389-
arch/x86/boot/compressed/kaslr.c:390: /* We don't need to set a mapping for setup_data. */
arch/x86/boot/compressed/kaslr.c-391-
--
arch/x86/boot/compressed/kaslr.c=403=static bool mem_avoid_overlap(struct mem_vector *img,
--
arch/x86/boot/compressed/kaslr.c-406- int i;
arch/x86/boot/compressed/kaslr.c:407: struct setup_data *ptr;
arch/x86/boot/compressed/kaslr.c-408- u64 earliest = img->start + img->size;
--
arch/x86/boot/compressed/kaslr.c-419-
arch/x86/boot/compressed/kaslr.c:420: /* Avoid all entries in the setup_data linked list. */
arch/x86/boot/compressed/kaslr.c:421: ptr = (struct setup_data *)(unsigned long)boot_params_ptr->hdr.setup_data;
arch/x86/boot/compressed/kaslr.c-422- while (ptr) {
--
arch/x86/boot/compressed/kaslr.c-445-
arch/x86/boot/compressed/kaslr.c:446: ptr = (struct setup_data *)(unsigned long)ptr->next;
arch/x86/boot/compressed/kaslr.c-447- }
--
arch/x86/boot/compressed/kaslr.c=767=static bool process_kho_entries(unsigned long minimum, unsigned long image_size)
--
arch/x86/boot/compressed/kaslr.c-769- struct kho_scratch *kho_scratch;
arch/x86/boot/compressed/kaslr.c:770: struct setup_data *ptr;
arch/x86/boot/compressed/kaslr.c-771- struct kho_data *kho;
--
arch/x86/boot/compressed/kaslr.c-776-
arch/x86/boot/compressed/kaslr.c:777: ptr = (struct setup_data *)(unsigned long)boot_params_ptr->hdr.setup_data;
arch/x86/boot/compressed/kaslr.c-778- while (ptr) {
--
arch/x86/boot/compressed/kaslr.c-785-
arch/x86/boot/compressed/kaslr.c:786: ptr = (struct setup_data *)(unsigned long)ptr->next;
arch/x86/boot/compressed/kaslr.c-787- }
--
arch/x86/boot/compressed/kernel_info.S=9=kernel_info:
--
arch/x86/boot/compressed/kernel_info.S-16-
arch/x86/boot/compressed/kernel_info.S:17: /* Maximal allowed type for setup_data and setup_indirect structs. */
arch/x86/boot/compressed/kernel_info.S-18- .long SETUP_TYPE_MAX
--
arch/x86/boot/compressed/sev.c=238=static struct cc_blob_sev_info *find_cc_blob_efi(struct boot_params *bp)
--
arch/x86/boot/compressed/sev.c-258- * - via an entry in the EFI config table
arch/x86/boot/compressed/sev.c:259: * - via a setup_data structure, as defined by the Linux Boot Protocol
arch/x86/boot/compressed/sev.c-260- *
--
arch/x86/boot/compressed/sev.c=263=static struct cc_blob_sev_info *find_cc_blob(struct boot_params *bp)
--
arch/x86/boot/compressed/sev.c-270-
arch/x86/boot/compressed/sev.c:271: cc_info = find_cc_blob_setup_data(bp);
arch/x86/boot/compressed/sev.c-272- if (!cc_info)
--
arch/x86/boot/header.S=394=payload_length: .long ZO_z_input_len
arch/x86/boot/header.S-395-
arch/x86/boot/header.S:396:setup_data: .quad 0 # 64-bit physical pointer to
arch/x86/boot/header.S-397- # single linked list of
arch/x86/boot/header.S:398: # struct setup_data
arch/x86/boot/header.S-399-
--
arch/x86/boot/startup/sev-shared.c-11-
arch/x86/boot/startup/sev-shared.c:12:#include <asm/setup_data.h>
arch/x86/boot/startup/sev-shared.c-13-
--
arch/x86/boot/startup/sev-shared.c=442=void do_vc_no_ghcb(struct pt_regs *regs, unsigned long exit_code)
--
arch/x86/boot/startup/sev-shared.c-519-
arch/x86/boot/startup/sev-shared.c:520:struct cc_setup_data {
arch/x86/boot/startup/sev-shared.c:521: struct setup_data header;
arch/x86/boot/startup/sev-shared.c-522- u32 cc_blob_address;
--
arch/x86/boot/startup/sev-shared.c-525-/*
arch/x86/boot/startup/sev-shared.c:526: * Search for a Confidential Computing blob passed in as a setup_data entry
arch/x86/boot/startup/sev-shared.c-527- * via the Linux Boot Protocol.
--
arch/x86/boot/startup/sev-shared.c=529=static __init
arch/x86/boot/startup/sev-shared.c:530:struct cc_blob_sev_info *find_cc_blob_setup_data(struct boot_params *bp)
arch/x86/boot/startup/sev-shared.c-531-{
arch/x86/boot/startup/sev-shared.c:532: struct cc_setup_data *sd = NULL;
arch/x86/boot/startup/sev-shared.c:533: struct setup_data *hdr;
arch/x86/boot/startup/sev-shared.c-534-
arch/x86/boot/startup/sev-shared.c:535: hdr = (struct setup_data *)bp->hdr.setup_data;
arch/x86/boot/startup/sev-shared.c-536-
--
arch/x86/boot/startup/sev-shared.c-538- if (hdr->type == SETUP_CC_BLOB) {
arch/x86/boot/startup/sev-shared.c:539: sd = (struct cc_setup_data *)hdr;
arch/x86/boot/startup/sev-shared.c-540- return (struct cc_blob_sev_info *)(unsigned long)sd->cc_blob_address;
arch/x86/boot/startup/sev-shared.c-541- }
arch/x86/boot/startup/sev-shared.c:542: hdr = (struct setup_data *)hdr->next;
arch/x86/boot/startup/sev-shared.c-543- }
--
arch/x86/boot/startup/sev-startup.c=92=void __init early_snp_set_memory_shared(unsigned long vaddr, unsigned long paddr,
--
arch/x86/boot/startup/sev-startup.c-122- * - when booted directly by firmware/bootloader (e.g. CONFIG_PVH):
arch/x86/boot/startup/sev-startup.c:123: * - via a setup_data entry, as defined by the Linux Boot Protocol
arch/x86/boot/startup/sev-startup.c-124- *
--
arch/x86/boot/startup/sev-startup.c=127=static struct cc_blob_sev_info *__init find_cc_blob(struct boot_params *bp)
--
arch/x86/boot/startup/sev-startup.c-139- * boot/decompression kernel, the CC blob may have been passed via
arch/x86/boot/startup/sev-startup.c:140: * setup_data instead.
arch/x86/boot/startup/sev-startup.c-141- */
arch/x86/boot/startup/sev-startup.c:142: cc_info = find_cc_blob_setup_data(bp);
arch/x86/boot/startup/sev-startup.c-143- if (!cc_info)
--
arch/x86/include/asm/setup_data.h-4-
arch/x86/include/asm/setup_data.h:5:#include <uapi/asm/setup_data.h>
arch/x86/include/asm/setup_data.h-6-
--
arch/x86/include/asm/setup_data.h=9=struct pci_setup_rom {
arch/x86/include/asm/setup_data.h:10: struct setup_data data;
arch/x86/include/asm/setup_data.h-11- uint16_t vendor;
--
arch/x86/include/asm/setup_data.h-21-/* kexec external ABI */
arch/x86/include/asm/setup_data.h:22:struct efi_setup_data {
arch/x86/include/asm/setup_data.h-23- u64 fw_vendor;
--
arch/x86/include/uapi/asm/bootparam.h-4-
arch/x86/include/uapi/asm/bootparam.h:5:#include <asm/setup_data.h>
arch/x86/include/uapi/asm/bootparam.h-6-
--
arch/x86/include/uapi/asm/bootparam.h=38=struct setup_header {
--
arch/x86/include/uapi/asm/bootparam.h-72- __u32 payload_length;
arch/x86/include/uapi/asm/bootparam.h:73: __u64 setup_data;
arch/x86/include/uapi/asm/bootparam.h-74- __u64 pref_address;
--
arch/x86/include/uapi/asm/bootparam.h=93=struct efi_info {
--
arch/x86/include/uapi/asm/bootparam.h-110-/*
arch/x86/include/uapi/asm/bootparam.h:111: * Smallest compatible version of jailhouse_setup_data required by this kernel.
arch/x86/include/uapi/asm/bootparam.h-112- */
--
arch/x86/include/uapi/asm/setup_data.h-4-
arch/x86/include/uapi/asm/setup_data.h:5:/* setup_data/setup_indirect types */
arch/x86/include/uapi/asm/setup_data.h-6-#define SETUP_NONE 0
--
arch/x86/include/uapi/asm/setup_data.h-26-/* extensible setup data list node */
arch/x86/include/uapi/asm/setup_data.h:27:struct setup_data {
arch/x86/include/uapi/asm/setup_data.h-28- __u64 next;
--
arch/x86/include/uapi/asm/setup_data.h=45=struct boot_e820_entry {
--
arch/x86/include/uapi/asm/setup_data.h-54- */
arch/x86/include/uapi/asm/setup_data.h:55:struct jailhouse_setup_data {
arch/x86/include/uapi/asm/setup_data.h-56- struct {
--
arch/x86/include/uapi/asm/setup_data.h-76- */
arch/x86/include/uapi/asm/setup_data.h:77:struct ima_setup_data {
arch/x86/include/uapi/asm/setup_data.h-78- __u64 addr;
--
arch/x86/kernel/devicetree.c=36=void __init add_dtb(u64 data)
arch/x86/kernel/devicetree.c-37-{
arch/x86/kernel/devicetree.c:38: initial_dtb = data + offsetof(struct setup_data, data);
arch/x86/kernel/devicetree.c-39-}
--
arch/x86/kernel/e820.c=724=__init void e820__reallocate_tables(void)
--
arch/x86/kernel/e820.c-748- * the remaining (if any) entries are passed via the SETUP_E820_EXT node of
arch/x86/kernel/e820.c:749: * struct setup_data, which is parsed here.
arch/x86/kernel/e820.c-750- */
arch/x86/kernel/e820.c=751=__init void e820__memory_setup_extended(u64 phys_addr, u32 data_len)
--
arch/x86/kernel/e820.c-754- struct boot_e820_entry *extmap;
arch/x86/kernel/e820.c:755: struct setup_data *sdata;
arch/x86/kernel/e820.c-756-
--
arch/x86/kernel/jailhouse.c-27-
arch/x86/kernel/jailhouse.c:28:static struct jailhouse_setup_data setup_data;
arch/x86/kernel/jailhouse.c:29:#define SETUP_DATA_V1_LEN (sizeof(setup_data.hdr) + sizeof(setup_data.v1))
arch/x86/kernel/jailhouse.c:30:#define SETUP_DATA_V2_LEN (SETUP_DATA_V1_LEN + sizeof(setup_data.v2))
arch/x86/kernel/jailhouse.c-31-
--
arch/x86/kernel/jailhouse.c=65=static void __init jailhouse_timer_init(void)
arch/x86/kernel/jailhouse.c-66-{
arch/x86/kernel/jailhouse.c:67: lapic_timer_period = setup_data.v1.apic_khz * (1000 / HZ);
arch/x86/kernel/jailhouse.c-68-}
--
arch/x86/kernel/jailhouse.c=93=static void __init jailhouse_parse_smp_config(void)
--
arch/x86/kernel/jailhouse.c-104-
arch/x86/kernel/jailhouse.c:105: for (cpu = 0; cpu < setup_data.v1.num_cpus; cpu++)
arch/x86/kernel/jailhouse.c:106: topology_register_apic(setup_data.v1.cpu_ids[cpu], CPU_ACPIID_INVALID, true);
arch/x86/kernel/jailhouse.c-107-
--
arch/x86/kernel/jailhouse.c-109-
arch/x86/kernel/jailhouse.c:110: if (setup_data.v1.standard_ioapic) {
arch/x86/kernel/jailhouse.c-111- mp_register_ioapic(0, 0xfec00000, gsi_top, &ioapic_cfg);
--
arch/x86/kernel/jailhouse.c-113- if (IS_ENABLED(CONFIG_SERIAL_8250) &&
arch/x86/kernel/jailhouse.c:114: setup_data.hdr.version < 2) {
arch/x86/kernel/jailhouse.c-115- /* Register 1:1 mapping for legacy UART IRQs 3 and 4 */
--
arch/x86/kernel/jailhouse.c=128=static int __init jailhouse_pci_arch_init(void)
--
arch/x86/kernel/jailhouse.c-140-#ifdef CONFIG_PCI_MMCONFIG
arch/x86/kernel/jailhouse.c:141: if (setup_data.v1.pci_mmconfig_base) {
arch/x86/kernel/jailhouse.c-142- pci_mmconfig_add(0, 0, pcibios_last_bus,
arch/x86/kernel/jailhouse.c:143: setup_data.v1.pci_mmconfig_base);
arch/x86/kernel/jailhouse.c-144- pci_mmcfg_arch_init();
--
arch/x86/kernel/jailhouse.c=152=static inline bool jailhouse_uart_enabled(unsigned int uart_nr)
arch/x86/kernel/jailhouse.c-153-{
arch/x86/kernel/jailhouse.c:154: return setup_data.v2.flags & BIT(uart_nr);
arch/x86/kernel/jailhouse.c-155-}
--
arch/x86/kernel/jailhouse.c=179=static void __init jailhouse_serial_workaround(void)
--
arch/x86/kernel/jailhouse.c-181- /*
arch/x86/kernel/jailhouse.c:182: * There are flags inside setup_data that indicate availability of
arch/x86/kernel/jailhouse.c-183- * platform UARTs since setup data version 2.
--
arch/x86/kernel/jailhouse.c-188- */
arch/x86/kernel/jailhouse.c:189: if (setup_data.hdr.version > 1)
arch/x86/kernel/jailhouse.c-190- serial8250_set_isa_configurator(jailhouse_serial_fixup);
--
arch/x86/kernel/jailhouse.c=198=static void __init jailhouse_init_platform(void)
arch/x86/kernel/jailhouse.c-199-{
arch/x86/kernel/jailhouse.c:200: u64 pa_data = boot_params.hdr.setup_data;
arch/x86/kernel/jailhouse.c:201: unsigned long setup_data_len;
arch/x86/kernel/jailhouse.c:202: struct setup_data header;
arch/x86/kernel/jailhouse.c-203- void *mapping;
--
arch/x86/kernel/jailhouse.c-237- /* setup data must at least contain the header */
arch/x86/kernel/jailhouse.c:238: if (header.len < sizeof(setup_data.hdr))
arch/x86/kernel/jailhouse.c-239- goto unsupported;
arch/x86/kernel/jailhouse.c-240-
arch/x86/kernel/jailhouse.c:241: pa_data += offsetof(struct setup_data, data);
arch/x86/kernel/jailhouse.c:242: setup_data_len = min_t(unsigned long, sizeof(setup_data),
arch/x86/kernel/jailhouse.c-243- (unsigned long)header.len);
arch/x86/kernel/jailhouse.c:244: mapping = early_memremap(pa_data, setup_data_len);
arch/x86/kernel/jailhouse.c:245: memcpy(&setup_data, mapping, setup_data_len);
arch/x86/kernel/jailhouse.c:246: early_memunmap(mapping, setup_data_len);
arch/x86/kernel/jailhouse.c-247-
arch/x86/kernel/jailhouse.c:248: if (setup_data.hdr.version == 0 ||
arch/x86/kernel/jailhouse.c:249: setup_data.hdr.compatible_version !=
arch/x86/kernel/jailhouse.c-250- JAILHOUSE_SETUP_REQUIRED_VERSION ||
arch/x86/kernel/jailhouse.c:251: (setup_data.hdr.version == 1 && header.len < SETUP_DATA_V1_LEN) ||
arch/x86/kernel/jailhouse.c:252: (setup_data.hdr.version >= 2 && header.len < SETUP_DATA_V2_LEN))
arch/x86/kernel/jailhouse.c-253- goto unsupported;
arch/x86/kernel/jailhouse.c-254-
arch/x86/kernel/jailhouse.c:255: pmtmr_ioport = setup_data.v1.pm_timer_address;
arch/x86/kernel/jailhouse.c-256- pr_debug("Jailhouse: PM-Timer IO Port: %#x\n", pmtmr_ioport);
arch/x86/kernel/jailhouse.c-257-
arch/x86/kernel/jailhouse.c:258: precalibrated_tsc_khz = setup_data.v1.tsc_khz;
arch/x86/kernel/jailhouse.c-259- setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ);
--
arch/x86/kernel/kdebugfs.c=20=EXPORT_SYMBOL(arch_debugfs_dir);
--
arch/x86/kernel/kdebugfs.c-22-#ifdef CONFIG_DEBUG_BOOT_PARAMS
arch/x86/kernel/kdebugfs.c:23:struct setup_data_node {
arch/x86/kernel/kdebugfs.c-24- u64 paddr;
--
arch/x86/kernel/kdebugfs.c-28-
arch/x86/kernel/kdebugfs.c:29:static ssize_t setup_data_read(struct file *file, char __user *user_buf,
arch/x86/kernel/kdebugfs.c-30- size_t count, loff_t *ppos)
arch/x86/kernel/kdebugfs.c-31-{
arch/x86/kernel/kdebugfs.c:32: struct setup_data_node *node = file->private_data;
arch/x86/kernel/kdebugfs.c-33- unsigned long remain;
--
arch/x86/kernel/kdebugfs.c-50- if (!(node->type & SETUP_INDIRECT) || node->type == SETUP_INDIRECT)
arch/x86/kernel/kdebugfs.c:51: pa += sizeof(struct setup_data);
arch/x86/kernel/kdebugfs.c-52-
--
arch/x86/kernel/kdebugfs.c-68-
arch/x86/kernel/kdebugfs.c:69:static const struct file_operations fops_setup_data = {
arch/x86/kernel/kdebugfs.c:70: .read = setup_data_read,
arch/x86/kernel/kdebugfs.c-71- .open = simple_open,
--
arch/x86/kernel/kdebugfs.c=75=static void __init
arch/x86/kernel/kdebugfs.c:76:create_setup_data_node(struct dentry *parent, int no,
arch/x86/kernel/kdebugfs.c:77: struct setup_data_node *node)
arch/x86/kernel/kdebugfs.c-78-{
--
arch/x86/kernel/kdebugfs.c-85- debugfs_create_x32("type", S_IRUGO, d, &node->type);
arch/x86/kernel/kdebugfs.c:86: debugfs_create_file("data", S_IRUGO, d, node, &fops_setup_data);
arch/x86/kernel/kdebugfs.c-87-}
arch/x86/kernel/kdebugfs.c-88-
arch/x86/kernel/kdebugfs.c:89:static int __init create_setup_data_nodes(struct dentry *parent)
arch/x86/kernel/kdebugfs.c-90-{
arch/x86/kernel/kdebugfs.c-91- struct setup_indirect *indirect;
arch/x86/kernel/kdebugfs.c:92: struct setup_data_node *node;
arch/x86/kernel/kdebugfs.c:93: struct setup_data *data;
arch/x86/kernel/kdebugfs.c-94- u64 pa_data, pa_next;
--
arch/x86/kernel/kdebugfs.c-99-
arch/x86/kernel/kdebugfs.c:100: d = debugfs_create_dir("setup_data", parent);
arch/x86/kernel/kdebugfs.c-101-
arch/x86/kernel/kdebugfs.c:102: pa_data = boot_params.hdr.setup_data;
arch/x86/kernel/kdebugfs.c-103-
--
arch/x86/kernel/kdebugfs.c-145-
arch/x86/kernel/kdebugfs.c:146: create_setup_data_node(d, no, node);
arch/x86/kernel/kdebugfs.c-147- pa_data = pa_next;
--
arch/x86/kernel/kdebugfs.c=165=static int __init boot_params_kdebugfs_init(void)
--
arch/x86/kernel/kdebugfs.c-174-
arch/x86/kernel/kdebugfs.c:175: error = create_setup_data_nodes(dbp);
arch/x86/kernel/kdebugfs.c-176- if (error)
--
arch/x86/kernel/kexec-bzimage64.c=125=setup_rng_seed(struct boot_params *params, unsigned long params_load_addr,
arch/x86/kernel/kexec-bzimage64.c:126: unsigned int rng_seed_setup_data_offset)
arch/x86/kernel/kexec-bzimage64.c-127-{
arch/x86/kernel/kexec-bzimage64.c:128: struct setup_data *sd = (void *)params + rng_seed_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:129: unsigned long setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-130-
--
arch/x86/kernel/kexec-bzimage64.c-136- get_random_bytes(sd->data, RNG_SEED_LENGTH);
arch/x86/kernel/kexec-bzimage64.c:137: setup_data_phys = params_load_addr + rng_seed_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:138: sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:139: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-140-}
--
arch/x86/kernel/kexec-bzimage64.c=164=static int
arch/x86/kernel/kexec-bzimage64.c:165:prepare_add_efi_setup_data(struct boot_params *params,
arch/x86/kernel/kexec-bzimage64.c-166- unsigned long params_load_addr,
arch/x86/kernel/kexec-bzimage64.c:167: unsigned int efi_setup_data_offset)
arch/x86/kernel/kexec-bzimage64.c-168-{
arch/x86/kernel/kexec-bzimage64.c:169: unsigned long setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c:170: struct setup_data *sd = (void *)params + efi_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:171: struct efi_setup_data *esd = (void *)sd + sizeof(struct setup_data);
arch/x86/kernel/kexec-bzimage64.c-172-
--
arch/x86/kernel/kexec-bzimage64.c-177- sd->type = SETUP_EFI;
arch/x86/kernel/kexec-bzimage64.c:178: sd->len = sizeof(struct efi_setup_data);
arch/x86/kernel/kexec-bzimage64.c-179-
arch/x86/kernel/kexec-bzimage64.c-180- /* Add setup data */
arch/x86/kernel/kexec-bzimage64.c:181: setup_data_phys = params_load_addr + efi_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:182: sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:183: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-184-
--
arch/x86/kernel/kexec-bzimage64.c=189=setup_efi_state(struct boot_params *params, unsigned long params_load_addr,
arch/x86/kernel/kexec-bzimage64.c-190- unsigned int efi_map_offset, unsigned int efi_map_sz,
]
]
|
| 50/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 82377
output: 51
thoughts: 64
Thoughts: **Diving into `__memremap_is_setup_data`**
Okay, so I'm looking at `arch/x86/mm/ioremap.c:641` and specifically the `__memremap_is_setup_data` function. That's interesting, let's take a closer look at what this function is doing. I'm assuming it's related to some setup data for memory mapping, given the name. The function signature hints it checks something about a physical address, `phys_addr`, potentially related to the early stages of the boot process judging by the `early` boolean. It is likely used to determine if a particular physical memory region has been initialized with the necessary data structures for later mapping or usage. Need to understand the logic flow here.
|
| 51/2 |
2026/05/26 05:47 |
tool |
codesearch-definition-source |
0m
Error:
Args: map[ContextFile:arch/x86/mm/ioremap.c IncludeLines:true Name:__memremap_is_setup_data]
Results: map[SourceCode: SourceFile:]
|
| 52/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 82683
output: 50
thoughts: 18
Thoughts: Okay, here's my summary, in the first person, as requested:
**Navigating the Labyrinth of Data Structures**
Hmm, now that I'm looking at this again, I think I might have been barking up the wrong tree initially. Instead of the obvious candidate, could it be the function or data structure named `memremap_is_setup_data`? That feels like it's a closer fit to the kind of information that I'm trying to find, given the context. I'll need to dig into its definition and associated usage, but that feels like a more promising avenue to explore.
|
| 53/2 |
2026/05/26 05:47 |
tool |
codesearch-definition-source |
0m
Error:
Args: map[ContextFile:arch/x86/mm/ioremap.c IncludeLines:true Name:memremap_is_setup_data]
Results: map[SourceCode: SourceFile:]
|
| 54/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 82903
output: 24
thoughts: 26
Thoughts: Here's my attempt at summarizing the thought process, tailored for an expert audience:
**Diving into the ioremap.c Source**
Okay, time to get my hands dirty. I'm going to jump into the `arch/x86/mm/ioremap.c` file. Specifically, I'm focusing around line 641. I'm hoping to understand a particular aspect of the I/O memory mapping implementation, and knowing how it's handled in the x86 architecture is key. I'm expecting to find the core logic for... well, that's what I'm about to find out! Let's get to it.
|
| 55/2 |
2026/05/26 05:47 |
tool |
grepper |
0m
Args: map[Expression:__memremap_is_setup_data]
Results: map[Output:arch/x86/mm/ioremap.c=603=static bool memremap_is_efi_data(resource_size_t phys_addr)
--
arch/x86/mm/ioremap.c-640- */
arch/x86/mm/ioremap.c:641:static bool __ref __memremap_is_setup_data(resource_size_t phys_addr, bool early)
arch/x86/mm/ioremap.c-642-{
--
arch/x86/mm/ioremap.c=714=static bool memremap_is_setup_data(resource_size_t phys_addr)
arch/x86/mm/ioremap.c-715-{
arch/x86/mm/ioremap.c:716: return __memremap_is_setup_data(phys_addr, false);
arch/x86/mm/ioremap.c-717-}
--
arch/x86/mm/ioremap.c=719=static bool __init early_memremap_is_setup_data(resource_size_t phys_addr)
arch/x86/mm/ioremap.c-720-{
arch/x86/mm/ioremap.c:721: return __memremap_is_setup_data(phys_addr, true);
arch/x86/mm/ioremap.c-722-}
]
|
| 56/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 83464
output: 51
thoughts: 31
Thoughts: Here's my analysis of the provided text, rendered as though I'm processing the thought process myself, as a kernel memory expert:
**Diving into the `ioremap` Details**
Okay, so the instruction is to look at `__memremap_is_setup_data` within `arch/x86/mm/ioremap.c`. That's a good starting point. My mind immediately starts to pull up mental maps of the x86 memory management architecture. I'm expecting this function, given its name and location, to be involved in the crucial setup phase of ioremap. It's likely checking some sort of internal flag or data structure related to a memory region before mapping it into the kernel's virtual address space, particularly for device memory. It should be dealing with the physical-to-virtual mappings of I/O resources and making sure all the preconditions are met before a memory region is truly considered ready for use via `ioremap`. Probably checking, perhaps, if it's already mapped, or if its alignment is correct. Let's see if my mental model is accurate.
|
| 57/2 |
2026/05/26 05:47 |
tool |
codesearch-definition-source |
0m
Error:
Args: map[ContextFile:arch/x86/mm/ioremap.c IncludeLines:true Name:__memremap_is_setup_data]
Results: map[SourceCode: SourceFile:]
|
| 58/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 83802
output: 25
thoughts: 32
Thoughts: Okay, here's my interpretation of those thoughts, tailored for an expert audience, presented in the first person:
**Potential Static Function Hiccup**
Hmm, so the tool isn't picking up this function. My initial hunch is that it might be due to the function being declared as `static`. Sometimes, these tools can have trouble with static members, especially if they're relying on reflection or specific code analysis techniques that don't always handle static scope correctly. It's a classic gotcha, really.
My first thought is to bypass the tool altogether for this and take a more direct approach. Let's try `grepper` or just `read-file` to manually search the codebase for the function name. A quick manual inspection with those old reliable techniques should give me a definitive answer very quickly. Might be a simple fix, or I might need to consider a different approach if this initial test reveals something unexpected about the function's declaration or usage.
|
| 59/2 |
2026/05/26 05:47 |
tool |
grepper |
0m
Args: map[Expression:__memremap_is_setup_data.*]
Results: map[Output:arch/x86/mm/ioremap.c=603=static bool memremap_is_efi_data(resource_size_t phys_addr)
--
arch/x86/mm/ioremap.c-640- */
arch/x86/mm/ioremap.c:641:static bool __ref __memremap_is_setup_data(resource_size_t phys_addr, bool early)
arch/x86/mm/ioremap.c-642-{
--
arch/x86/mm/ioremap.c=714=static bool memremap_is_setup_data(resource_size_t phys_addr)
arch/x86/mm/ioremap.c-715-{
arch/x86/mm/ioremap.c:716: return __memremap_is_setup_data(phys_addr, false);
arch/x86/mm/ioremap.c-717-}
--
arch/x86/mm/ioremap.c=719=static bool __init early_memremap_is_setup_data(resource_size_t phys_addr)
arch/x86/mm/ioremap.c-720-{
arch/x86/mm/ioremap.c:721: return __memremap_is_setup_data(phys_addr, true);
arch/x86/mm/ioremap.c-722-}
]
|
| 60/2 |
2026/05/26 05:47 |
llm |
expert |
0m
Model:
Tokens:
input: 84427
output: 28
thoughts: 29
Thoughts: Okay, let's dive into this. Here's my take on those lines of code:
**Analyzing the x86 I/O Remapping Logic**
Alright, I'm going to focus on lines 640 to 710 in `arch/x86/mm/ioremap.c`. This section should reveal some critical details regarding how the kernel handles I/O memory remapping on x86 architectures. I'm especially keen to see how the system translates physical addresses used by hardware into virtual addresses accessible by the kernel, particularly given the potential complexities of dealing with different memory maps and devices. My intuition tells me this chunk will involve page table manipulations, potentially dealing with the identity mapping or handling specific memory regions. I'm looking for where it handles the mapping from physical memory to virtual memory. I'll be watching to see if there's any special handling of different memory types (e.g., write-combining, uncached) and how that's achieved at the page table level. And hopefully there's a pointer to how these mapped regions are managed. I'm expecting to see calls to functions like `pgd_offset`, `pud_offset`, `pmd_offset`, and `pte_offset_kernel`βthese are the standard tools for navigating the page table hierarchy. It would be helpful if the section clearly illustrates the protection flags applied to the newly mapped regions. In the back of my mind, I'm also thinking about potential security implications, so I'll be keeping an eye out for how this code addresses access control and prevents unauthorized access to I/O memory.
|
| 61/2 |
2026/05/26 05:47 |
tool |
grepper |
0m
Error:
Args: map[Expression:__memremap_is_setup_data.*\{.*\}]
Results:
|
| 62/2 |
2026/05/26 05:48 |
llm |
expert |
0m
Model:
Tokens:
input: 84840
output: 27
thoughts: 13
Thoughts: Okay, here's my attempt at summarizing the thought process, as if it were my own, assuming the user is an expert.
**The Initial Spark: Parsing the Input**
Alright, the objective here is clear: process some textual data. My first instinct, given the context, is to reach for a foundational tool β the `read-file` function. It's a tried-and-true method for bringing the data into the environment, and I'll extract lines as the initial unit of processing. This approach keeps things manageable and allows for iteration, making subsequent analyses more straightforward. It's the most pragmatic first step. Now, let's see what we can do with these lines.
|
| 63/2 |
2026/05/26 05:48 |
tool |
read-file |
0m
Args: map[File:arch/x86/mm/ioremap.c]
Results: map[Contents:// SPDX-License-Identifier: GPL-2.0-only
/*
* Re-map IO memory to kernel address space so that we can access it.
* This is needed for high PCI addresses that aren't mapped in the
* 640k-1MB IO memory area on PC's
*
* (C) Copyright 1995 1996 Linus Torvalds
*/
#include <linux/memblock.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/ioremap.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mmiotrace.h>
#include <linux/cc_platform.h>
#include <linux/efi.h>
#include <linux/pgtable.h>
#include <linux/kmsan.h>
#include <asm/set_memory.h>
#include <asm/e820/api.h>
#include <asm/efi.h>
#include <asm/fixmap.h>
#include <asm/tlbflush.h>
#include <asm/pgalloc.h>
#include <asm/memtype.h>
#include <asm/setup.h>
#include "physaddr.h"
/*
* Descriptor controlling ioremap() behavior.
*/
struct ioremap_desc {
unsigned int flags;
};
/*
* Fix up the linear direct mapping of the kernel to avoid cache attribute
* conflicts.
*/
int ioremap_change_attr(unsigned long vaddr, unsigned long size,
enum page_cache_mode pcm)
{
unsigned long nrpages = size >> PAGE_SHIFT;
int err;
switch (pcm) {
case _PAGE_CACHE_MODE_UC:
default:
err = _set_memory_uc(vaddr, nrpages);
break;
case _PAGE_CACHE_MODE_WC:
err = _set_memory_wc(vaddr, nrpages);
break;
case _PAGE_CACHE_MODE_WT:
err = _set_memory_wt(vaddr, nrpages);
break;
case _PAGE_CACHE_MODE_WB:
err = _set_memory_wb(vaddr, nrpages);
break;
}
return err;
}
/* Does the range (or a subset of) contain normal RAM? */
static unsigned int __ioremap_check_ram(struct resource *res)
{
unsigned long start_pfn, stop_pfn;
unsigned long pfn;
if ((res->flags & IORESOURCE_SYSTEM_RAM) != IORESOURCE_SYSTEM_RAM)
return 0;
start_pfn = (res->start + PAGE_SIZE - 1) >> PAGE_SHIFT;
stop_pfn = (res->end + 1) >> PAGE_SHIFT;
if (stop_pfn > start_pfn) {
for_each_valid_pfn(pfn, start_pfn, stop_pfn)
if (!PageReserved(pfn_to_page(pfn)))
return IORES_MAP_SYSTEM_RAM;
}
return 0;
}
/*
* In a SEV guest, NONE and RESERVED should not be mapped encrypted because
* there the whole memory is already encrypted.
*/
static unsigned int __ioremap_check_encrypted(struct resource *res)
{
if (!cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT))
return 0;
switch (res->desc) {
case IORES_DESC_NONE:
case IORES_DESC_RESERVED:
break;
default:
return IORES_MAP_ENCRYPTED;
}
return 0;
}
/*
* The EFI runtime services data area is not covered by walk_mem_res(), but must
* be mapped encrypted when SEV is active.
*/
static void __ioremap_check_other(resource_size_t addr, struct ioremap_desc *desc)
{
if (!cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT))
return;
if (x86_platform.hyper.is_private_mmio(addr)) {
desc->flags |= IORES_MAP_ENCRYPTED;
return;
}
if (!IS_ENABLED(CONFIG_EFI))
return;
if (efi_mem_type(addr) == EFI_RUNTIME_SERVICES_DATA ||
(efi_mem_type(addr) == EFI_BOOT_SERVICES_DATA &&
efi_mem_attributes(addr) & EFI_MEMORY_RUNTIME))
desc->flags |= IORES_MAP_ENCRYPTED;
}
static int __ioremap_collect_map_flags(struct resource *res, void *arg)
{
struct ioremap_desc *desc = arg;
if (!(desc->flags & IORES_MAP_SYSTEM_RAM))
desc->flags |= __ioremap_check_ram(res);
if (!(desc->flags & IORES_MAP_ENCRYPTED))
desc->flags |= __ioremap_check_encrypted(res);
return ((desc->flags & (IORES_MAP_SYSTEM_RAM | IORES_MAP_ENCRYPTED)) ==
(IORES_MAP_SYSTEM_RAM | IORES_MAP_ENCRYPTED));
}
/*
* To avoid multiple resource walks, this function walks resources marked as
* IORESOURCE_MEM and IORESOURCE_BUSY and looking for system RAM and/or a
* resource described not as IORES_DESC_NONE (e.g. IORES_DESC_ACPI_TABLES).
*
* After that, deal with misc other ranges in __ioremap_check_other() which do
* not fall into the above category.
*/
static void __ioremap_check_mem(resource_size_t addr, unsigned long size,
struct ioremap_desc *desc)
{
u64 start, end;
start = (u64)addr;
end = start + size - 1;
memset(desc, 0, sizeof(struct ioremap_desc));
walk_mem_res(start, end, desc, __ioremap_collect_map_flags);
__ioremap_check_other(addr, desc);
}
/*
* Remap an arbitrary physical address space into the kernel virtual
* address space. It transparently creates kernel huge I/O mapping when
* the physical address is aligned by a huge page size (1GB or 2MB) and
* the requested size is at least the huge page size.
*
* NOTE: MTRRs can override PAT memory types with a 4KB granularity.
* Therefore, the mapping code falls back to use a smaller page toward 4KB
* when a mapping range is covered by non-WB type of MTRRs.
*
* NOTE! We need to allow non-page-aligned mappings too: we will obviously
* have to convert them into an offset in a page-aligned mapping, but the
* caller shouldn't need to know that small detail.
*/
static void __iomem *
__ioremap_caller(resource_size_t phys_addr, unsigned long size,
enum page_cache_mode pcm, void *caller, bool encrypted)
{
unsigned long offset, vaddr;
resource_size_t last_addr;
const resource_size_t unaligned_phys_addr = phys_addr;
const unsigned long unaligned_size = size;
struct ioremap_desc io_desc;
struct vm_struct *area;
enum page_cache_mode new_pcm;
pgprot_t prot;
int retval;
void __iomem *ret_addr;
/* Don't allow wraparound or zero size */
last_addr = phys_addr + size - 1;
if (!size || last_addr < phys_addr)
return NULL;
if (!phys_addr_valid(phys_addr)) {
printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
(unsigned long long)phys_addr);
WARN_ON_ONCE(1);
return NULL;
}
__ioremap_check_mem(phys_addr, size, &io_desc);
/*
* Don't allow anybody to remap normal RAM that we're using..
*/
if (io_desc.flags & IORES_MAP_SYSTEM_RAM) {
WARN_ONCE(1, "ioremap on RAM at %pa - %pa\n",
&phys_addr, &last_addr);
return NULL;
}
/*
* Mappings have to be page-aligned
*/
offset = phys_addr & ~PAGE_MASK;
phys_addr &= PAGE_MASK;
size = PAGE_ALIGN(last_addr+1) - phys_addr;
/*
* Mask out any bits not part of the actual physical
* address, like memory encryption bits.
*/
phys_addr &= PHYSICAL_PAGE_MASK;
retval = memtype_reserve(phys_addr, (u64)phys_addr + size,
pcm, &new_pcm);
if (retval) {
printk(KERN_ERR "ioremap memtype_reserve failed %d\n", retval);
return NULL;
}
if (pcm != new_pcm) {
if (!is_new_memtype_allowed(phys_addr, size, pcm, new_pcm)) {
printk(KERN_ERR
"ioremap error for 0x%llx-0x%llx, requested 0x%x, got 0x%x\n",
(unsigned long long)phys_addr,
(unsigned long long)(phys_addr + size),
pcm, new_pcm);
goto err_free_memtype;
}
pcm = new_pcm;
}
/*
* If the page being mapped is in memory and SEV is active then
* make sure the memory encryption attribute is enabled in the
* resulting mapping.
* In TDX guests, memory is marked private by default. If encryption
* is not requested (using encrypted), explicitly set decrypt
* attribute in all IOREMAPPED memory.
*/
prot = PAGE_KERNEL_IO;
if ((io_desc.flags & IORES_MAP_ENCRYPTED) || encrypted)
prot = pgprot_encrypted(prot);
else
prot = pgprot_decrypted(prot);
switch (pcm) {
case _PAGE_CACHE_MODE_UC:
default:
prot = __pgprot(pgprot_val(prot) |
cachemode2protval(_PAGE_CACHE_MODE_UC));
break;
case _PAGE_CACHE_MODE_UC_MINUS:
prot = __pgprot(pgprot_val(prot) |
cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS));
break;
case _PAGE_CACHE_MODE_WC:
prot = __pgprot(pgprot_val(prot) |
cachemode2protval(_PAGE_CACHE_MODE_WC));
break;
case _PAGE_CACHE_MODE_WT:
prot = __pgprot(pgprot_val(prot) |
cachemode2protval(_PAGE_CACHE_MODE_WT));
break;
case _PAGE_CACHE_MODE_WB:
break;
}
/*
* Ok, go for it..
*/
area = get_vm_area_caller(size, VM_IOREMAP, caller);
if (!area)
goto err_free_memtype;
area->phys_addr = phys_addr;
vaddr = (unsigned long) area->addr;
if (memtype_kernel_map_sync(phys_addr, size, pcm))
goto err_free_area;
if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot))
goto err_free_area;
ret_addr = (void __iomem *) (vaddr + offset);
mmiotrace_ioremap(unaligned_phys_addr, unaligned_size, ret_addr);
/*
* Check if the request spans more than any BAR in the iomem resource
* tree.
*/
if (iomem_map_sanity_check(unaligned_phys_addr, unaligned_size))
pr_warn("caller %pS mapping multiple BARs\n", caller);
return ret_addr;
err_free_area:
free_vm_area(area);
err_free_memtype:
memtype_free(phys_addr, phys_addr + size);
return NULL;
}
/**
* ioremap - map bus memory into CPU space
* @phys_addr: bus address of the memory
* @size: size of the resource to map
*
* ioremap performs a platform specific sequence of operations to
* make bus memory CPU accessible via the readb/readw/readl/writeb/
* writew/writel functions and the other mmio helpers. The returned
* address is not guaranteed to be usable directly as a virtual
* address.
*
* This version of ioremap ensures that the memory is marked uncachable
* on the CPU as well as honouring existing caching rules from things like
* the PCI bus. Note that there are other caches and buffers on many
* busses. In particular driver authors should read up on PCI writes
*
* It's useful if some control registers are in such an area and
* write combining or read caching is not desirable:
*
* Must be freed with iounmap.
*/
void __iomem *ioremap(resource_size_t phys_addr, unsigned long size)
{
/*
* Ideally, this should be:
* pat_enabled() ? _PAGE_CACHE_MODE_UC : _PAGE_CACHE_MODE_UC_MINUS;
*
* Till we fix all X drivers to use ioremap_wc(), we will use
* UC MINUS. Drivers that are certain they need or can already
* be converted over to strong UC can use ioremap_uc().
*/
enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC_MINUS;
return __ioremap_caller(phys_addr, size, pcm,
__builtin_return_address(0), false);
}
EXPORT_SYMBOL(ioremap);
/**
* ioremap_uc - map bus memory into CPU space as strongly uncachable
* @phys_addr: bus address of the memory
* @size: size of the resource to map
*
* ioremap_uc performs a platform specific sequence of operations to
* make bus memory CPU accessible via the readb/readw/readl/writeb/
* writew/writel functions and the other mmio helpers. The returned
* address is not guaranteed to be usable directly as a virtual
* address.
*
* This version of ioremap ensures that the memory is marked with a strong
* preference as completely uncachable on the CPU when possible. For non-PAT
* systems this ends up setting page-attribute flags PCD=1, PWT=1. For PAT
* systems this will set the PAT entry for the pages as strong UC. This call
* will honor existing caching rules from things like the PCI bus. Note that
* there are other caches and buffers on many busses. In particular driver
* authors should read up on PCI writes.
*
* It's useful if some control registers are in such an area and
* write combining or read caching is not desirable:
*
* Must be freed with iounmap.
*/
void __iomem *ioremap_uc(resource_size_t phys_addr, unsigned long size)
{
enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC;
return __ioremap_caller(phys_addr, size, pcm,
__builtin_return_address(0), false);
}
EXPORT_SYMBOL_GPL(ioremap_uc);
/**
* ioremap_wc - map memory into CPU space write combined
* @phys_addr: bus address of the memory
* @size: size of the resource to map
*
* This version of ioremap ensures that the memory is marked write combining.
* Write combining allows faster writes to some hardware devices.
*
* Must be freed with iounmap.
*/
void __iomem *ioremap_wc(resource_size_t phys_addr, unsigned long size)
{
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WC,
__builtin_return_address(0), false);
}
EXPORT_SYMBOL(ioremap_wc);
/**
* ioremap_wt - map memory into CPU space write through
* @phys_addr: bus address of the memory
* @size: size of the resource to map
*
* This version of ioremap ensures that the memory is marked write through.
* Write through stores data into memory while keeping the cache up-to-date.
*
* Must be freed with iounmap.
*/
void __iomem *ioremap_wt(resource_size_t phys_addr, unsigned long size)
{
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WT,
__builtin_return_address(0), false);
}
EXPORT_SYMBOL(ioremap_wt);
void __iomem *ioremap_encrypted(resource_size_t phys_addr, unsigned long size)
{
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
__builtin_return_address(0), true);
}
EXPORT_SYMBOL(ioremap_encrypted);
void __iomem *ioremap_cache(resource_size_t phys_addr, unsigned long size)
{
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
__builtin_return_address(0), false);
}
EXPORT_SYMBOL(ioremap_cache);
void __iomem *ioremap_prot(resource_size_t phys_addr, unsigned long size,
pgprot_t prot)
{
return __ioremap_caller(phys_addr, size,
pgprot2cachemode(prot),
__builtin_return_address(0), false);
}
EXPORT_SYMBOL(ioremap_prot);
/**
* iounmap - Free a IO remapping
* @addr: virtual address from ioremap_*
*
* Caller must ensure there is only one unmapping for the same pointer.
*/
void iounmap(volatile void __iomem *addr)
{
struct vm_struct *p, *o;
if (WARN_ON_ONCE(!is_ioremap_addr((void __force *)addr)))
return;
/*
* The PCI/ISA range special-casing was removed from __ioremap()
* so this check, in theory, can be removed. However, there are
* cases where iounmap() is called for addresses not obtained via
* ioremap() (vga16fb for example). Add a warning so that these
* cases can be caught and fixed.
*/
if ((void __force *)addr >= phys_to_virt(ISA_START_ADDRESS) &&
(void __force *)addr < phys_to_virt(ISA_END_ADDRESS)) {
WARN(1, "iounmap() called for ISA range not obtained using ioremap()\n");
return;
}
mmiotrace_iounmap(addr);
addr = (volatile void __iomem *)
(PAGE_MASK & (unsigned long __force)addr);
/* Use the vm area unlocked, assuming the caller
ensures there isn't another iounmap for the same address
in parallel. Reuse of the virtual address is prevented by
leaving it in the global lists until we're done with it.
cpa takes care of the direct mappings. */
p = find_vm_area((void __force *)addr);
if (!p) {
printk(KERN_ERR "iounmap: bad address %p\n", addr);
dump_stack();
return;
}
kmsan_iounmap_page_range((unsigned long)addr,
(unsigned long)addr + get_vm_area_size(p));
memtype_free(p->phys_addr, p->phys_addr + get_vm_area_size(p));
/* Finally remove it */
o = remove_vm_area((void __force *)addr);
BUG_ON(p != o || o == NULL);
kfree(p);
}
EXPORT_SYMBOL(iounmap);
void *arch_memremap_wb(phys_addr_t phys_addr, size_t size, unsigned long flags)
{
if ((flags & MEMREMAP_DEC) || cc_platform_has(CC_ATTR_HOST_MEM_ENCRYPT))
return (void __force *)ioremap_cache(phys_addr, size);
return (void __force *)ioremap_encrypted(phys_addr, size);
}
/*
* Convert a physical pointer to a virtual kernel pointer for /dev/mem
* access
*/
void *xlate_dev_mem_ptr(phys_addr_t phys)
{
unsigned long start = phys & PAGE_MASK;
unsigned long offset = phys & ~PAGE_MASK;
void *vaddr;
/* memremap() maps if RAM, otherwise falls back to ioremap() */
vaddr = memremap(start, PAGE_SIZE, MEMREMAP_WB);
/* Only add the offset on success and return NULL if memremap() failed */
if (vaddr)
vaddr += offset;
return vaddr;
}
void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
{
memunmap((void *)((unsigned long)addr & PAGE_MASK));
}
#ifdef CONFIG_AMD_MEM_ENCRYPT
/*
* Examine the physical address to determine if it is an area of memory
* that should be mapped decrypted. If the memory is not part of the
* kernel usable area it was accessed and created decrypted, so these
* areas should be mapped decrypted. And since the encryption key can
* change across reboots, persistent memory should also be mapped
* decrypted.
*
* If SEV is active, that implies that BIOS/UEFI also ran encrypted so
* only persistent memory should be mapped decrypted.
*/
static bool memremap_should_map_decrypted(resource_size_t phys_addr,
unsigned long size)
{
int is_pmem;
/*
* Check if the address is part of a persistent memory region.
* This check covers areas added by E820, EFI and ACPI.
*/
is_pmem = region_intersects(phys_addr, size, IORESOURCE_MEM,
IORES_DESC_PERSISTENT_MEMORY);
if (is_pmem != REGION_DISJOINT)
return true;
/*
* Check if the non-volatile attribute is set for an EFI
* reserved area.
*/
if (efi_enabled(EFI_BOOT)) {
switch (efi_mem_type(phys_addr)) {
case EFI_RESERVED_TYPE:
if (efi_mem_attributes(phys_addr) & EFI_MEMORY_NV)
return true;
break;
default:
break;
}
}
/* Check if the address is outside kernel usable area */
switch (e820__get_entry_type(phys_addr, phys_addr + size - 1)) {
case E820_TYPE_RESERVED:
case E820_TYPE_ACPI:
case E820_TYPE_NVS:
case E820_TYPE_UNUSABLE:
/* For SEV, these areas are encrypted */
if (cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT))
break;
fallthrough;
case E820_TYPE_PRAM:
return true;
default:
break;
}
return false;
}
/*
* Examine the physical address to determine if it is EFI data. Check
* it against the boot params structure and EFI tables and memory types.
*/
static bool memremap_is_efi_data(resource_size_t phys_addr)
{
u64 paddr;
/* Check if the address is part of EFI boot/runtime data */
if (!efi_enabled(EFI_BOOT))
return false;
paddr = boot_params.efi_info.efi_memmap_hi;
paddr <<= 32;
paddr |= boot_params.efi_info.efi_memmap;
if (phys_addr == paddr)
return true;
paddr = boot_params.efi_info.efi_systab_hi;
paddr <<= 32;
paddr |= boot_params.efi_info.efi_systab;
if (phys_addr == paddr)
return true;
if (efi_is_table_address(phys_addr))
return true;
switch (efi_mem_type(phys_addr)) {
case EFI_BOOT_SERVICES_DATA:
case EFI_RUNTIME_SERVICES_DATA:
return true;
default:
break;
}
return false;
}
/*
* Examine the physical address to determine if it is boot data by checking
* it against the boot params setup_data chain.
*/
static bool __ref __memremap_is_setup_data(resource_size_t phys_addr, bool early)
{
unsigned int setup_data_sz = sizeof(struct setup_data);
struct setup_indirect *indirect;
struct setup_data *data;
u64 paddr, paddr_next;
paddr = boot_params.hdr.setup_data;
while (paddr) {
unsigned int len, size;
if (phys_addr == paddr)
return true;
if (early)
data = early_memremap_decrypted(paddr, setup_data_sz);
else
data = memremap(paddr, setup_data_sz, MEMREMAP_WB | MEMREMAP_DEC);
if (!data) {
pr_warn("failed to remap setup_data entry\n");
return false;
}
size = setup_data_sz;
paddr_next = data->next;
len = data->len;
if ((phys_addr > paddr) &&
(phys_addr < (paddr + setup_data_sz + len))) {
if (early)
early_memunmap(data, setup_data_sz);
else
memunmap(data);
return true;
}
if (data->type == SETUP_INDIRECT) {
size += len;
if (early) {
early_memunmap(data, setup_data_sz);
data = early_memremap_decrypted(paddr, size);
} else {
memunmap(data);
data = memremap(paddr, size, MEMREMAP_WB | MEMREMAP_DEC);
}
if (!data) {
pr_warn("failed to remap indirect setup_data\n");
return false;
}
indirect = (struct setup_indirect *)data->data;
if (indirect->type != SETUP_INDIRECT) {
paddr = indirect->addr;
len = indirect->len;
}
}
if (early)
early_memunmap(data, size);
else
memunmap(data);
if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
return true;
paddr = paddr_next;
}
return false;
}
static bool memremap_is_setup_data(resource_size_t phys_addr)
{
return __memremap_is_setup_data(phys_addr, false);
}
static bool __init early_memremap_is_setup_data(resource_size_t phys_addr)
{
return __memremap_is_setup_data(phys_addr, true);
}
/*
* Architecture function to determine if RAM remap is allowed. By default, a
* RAM remap will map the data as encrypted. Determine if a RAM remap should
* not be done so that the data will be mapped decrypted.
*/
bool arch_memremap_can_ram_remap(resource_size_t phys_addr, unsigned long size,
unsigned long flags)
{
if (!cc_platform_has(CC_ATTR_MEM_ENCRYPT))
return true;
if (flags & MEMREMAP_ENC)
return true;
if (flags & MEMREMAP_DEC)
return false;
if (cc_platform_has(CC_ATTR_HOST_MEM_ENCRYPT)) {
if (memremap_is_setup_data(phys_addr) ||
memremap_is_efi_data(phys_addr))
return false;
}
return !memremap_should_map_decrypted(phys_addr, size);
}
/*
* Architecture override of __weak function to adjust the protection attributes
* used when remapping memory. By default, early_memremap() will map the data
* as encrypted. Determine if an encrypted mapping should not be done and set
* the appropriate protection attributes.
*/
pgprot_t __init early_memremap_pgprot_adjust(resource_size_t phys_addr,
unsigned long size,
pgprot_t prot)
{
bool encrypted_prot;
if (!cc_platform_has(CC_ATTR_MEM_ENCRYPT))
return prot;
encrypted_prot = true;
if (cc_platform_has(CC_ATTR_HOST_MEM_ENCRYPT)) {
if (early_memremap_is_setup_data(phys_addr) ||
memremap_is_efi_data(phys_addr))
encrypted_prot = false;
}
if (encrypted_prot && memremap_should_map_decrypted(phys_addr, size))
encrypted_prot = false;
return encrypted_prot ? pgprot_encrypted(prot)
: pgprot_decrypted(prot);
}
bool phys_mem_access_encrypted(unsigned long phys_addr, unsigned long size)
{
return arch_memremap_can_ram_remap(phys_addr, size, 0);
}
/* Remap memory with encryption */
void __init *early_memremap_encrypted(resource_size_t phys_addr,
unsigned long size)
{
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC);
}
/*
* Remap memory with encryption and write-protected - cannot be called
* before pat_init() is called
*/
void __init *early_memremap_encrypted_wp(resource_size_t phys_addr,
unsigned long size)
{
if (!x86_has_pat_wp())
return NULL;
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC_WP);
}
/* Remap memory without encryption */
void __init *early_memremap_decrypted(resource_size_t phys_addr,
unsigned long size)
{
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC);
}
/*
* Remap memory without encryption and write-protected - cannot be called
* before pat_init() is called
*/
void __init *early_memremap_decrypted_wp(resource_size_t phys_addr,
unsigned long size)
{
if (!x86_has_pat_wp())
return NULL;
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC_WP);
}
#endif /* CONFIG_AMD_MEM_ENCRYPT */
static pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)] __page_aligned_bss;
static inline pmd_t * __init early_ioremap_pmd(unsigned long addr)
{
/* Don't assume we're using swapper_pg_dir at this point */
pgd_t *base = __va(read_cr3_pa());
pgd_t *pgd = &base[pgd_index(addr)];
p4d_t *p4d = p4d_offset(pgd, addr);
pud_t *pud = pud_offset(p4d, addr);
pmd_t *pmd = pmd_offset(pud, addr);
return pmd;
}
static inline pte_t * __init early_ioremap_pte(unsigned long addr)
{
return &bm_pte[pte_index(addr)];
}
bool __init is_early_ioremap_ptep(pte_t *ptep)
{
return ptep >= &bm_pte[0] && ptep < &bm_pte[PAGE_SIZE/sizeof(pte_t)];
}
void __init early_ioremap_init(void)
{
pmd_t *pmd;
#ifdef CONFIG_X86_64
BUILD_BUG_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
#else
WARN_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
#endif
early_ioremap_setup();
pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
memset(bm_pte, 0, sizeof(bm_pte));
pmd_populate_kernel(&init_mm, pmd, bm_pte);
/*
* The boot-ioremap range spans multiple pmds, for which
* we are not prepared:
*/
#define __FIXADDR_TOP (-PAGE_SIZE)
BUILD_BUG_ON((__fix_to_virt(FIX_BTMAP_BEGIN) >> PMD_SHIFT)
!= (__fix_to_virt(FIX_BTMAP_END) >> PMD_SHIFT));
#undef __FIXADDR_TOP
if (pmd != early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END))) {
WARN_ON(1);
printk(KERN_WARNING "pmd %p != %p\n",
pmd, early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END)));
printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
fix_to_virt(FIX_BTMAP_BEGIN));
printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END): %08lx\n",
fix_to_virt(FIX_BTMAP_END));
printk(KERN_WARNING "FIX_BTMAP_END: %d\n", FIX_BTMAP_END);
printk(KERN_WARNING "FIX_BTMAP_BEGIN: %d\n",
FIX_BTMAP_BEGIN);
}
}
void __init __early_set_fixmap(enum fixed_addresses idx,
phys_addr_t phys, pgprot_t flags)
{
unsigned long addr = __fix_to_virt(idx);
pte_t *pte;
if (idx >= __end_of_fixed_addresses) {
BUG();
return;
}
pte = early_ioremap_pte(addr);
/* Sanitize 'prot' against any unsupported bits: */
pgprot_val(flags) &= __supported_pte_mask;
if (pgprot_val(flags))
set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
else
pte_clear(&init_mm, addr, pte);
flush_tlb_one_kernel(addr);
}
]
|
| 64/2 |
2026/05/26 05:48 |
llm |
expert |
0m
Model:
Tokens:
input: 93839
output: 44
thoughts: 1062
Thoughts: **Analyzing the Memremap and Setup Data Interaction**
Okay, so I'm looking at this `__memremap_is_setup_data` function, and it's iterating over `boot_params.hdr.setup_data`. My initial thought was, "Uh oh, this seems problematic." Specifically, it looks like this:
`__memremap_is_setup_data` iterates over the `boot_params.hdr.setup_data`, using `memremap`.
I saw a potential for recursion because `memremap` calls `arch_memremap_can_ram_remap`, which calls `memremap_is_setup_data`, which calls `__memremap_is_setup_data` again. It seemed like an infinite loop was possible: `memremap` -> `try_ram_remap` -> `arch_memremap_can_ram_remap` -> `memremap_is_setup_data` -> `__memremap_is_setup_data` -> `memremap`.
But then I realized there's a guard. In `__memremap_is_setup_data`, it calls `memremap` with the `MEMREMAP_DEC` flag. Critically, `arch_memremap_can_ram_remap` checks for this flag: if `MEMREMAP_DEC` is set, it returns `false` immediately, thus breaking the recursion.
Now, my focus shifted to `pcibios_device_add`, which calls `memremap` with `MEMREMAP_WB` but *not* `MEMREMAP_DEC`. So now, there is no guard, and it ends up going through the cycle again. This seemed like a problem.
Let me think. I realized if the address is invalid, `memremap` eventually will call `ioremap_cache` and `__ioremap_caller`, and `phys_addr_valid` will be checked and trigger the warning. So, if `boot_params.hdr.setup_data` contains an invalid physical address, `__memremap_is_setup_data` is going to trigger a warning when it tries to map that invalid address, and we should be able to trigger this somehow.
I then noted that `__memremap_is_setup_data` is called whenever any RAM `memremap` is performed if `cc_platform_has(CC_ATTR_HOST_MEM_ENCRYPT)` is true. This happens when AMD SME or SEV is enabled, so if SME/SEV is enabled, ANY `memremap` will trigger this.
The key observation is: if there were invalid setup data addresses, they should have been triggered during boot, when `early_memremap_is_setup_data` is called, which calls `early_memremap_decrypted`.
Now, the question is, does `early_memremap_decrypted` check for a valid physical address? I need to check `early_memremap_decrypted` itself to confirm this.
|
| 65/2 |
2026/05/26 05:48 |
tool |
codesearch-definition-source |
0m
Error:
Args: map[ContextFile:mm/early_ioremap.c IncludeLines:true Name:early_memremap_prot]
Results: map[SourceCode: SourceFile:]
|
| 66/2 |
2026/05/26 05:48 |
llm |
expert |
0m
Model:
Tokens:
input: 95635
output: 42
thoughts: 22
Thoughts: Here's my take on those thoughts, tailored for an expert audience:
**Diving into `early_ioremap.c`**
Okay, time to get my hands dirty. I need to take a look at the `early_memremap` function within `mm/early_ioremap.c`. Given the context, I'm likely dealing with very early memory mapping, probably during the boot process or in some pre-paging environment. This suggests the code handles low-level hardware accesses before the full virtual memory infrastructure is online. I'm immediately expecting to see things like direct physical address mappings, potential considerations for platform-specific MMU configurations (or lack thereof), and maybe some clever tricks to avoid the more complex page table setup. My primary interest is in understanding how it handles the initial ioremap phase β how it actually gets those early addresses mapped for peripheral access. Iβll be especially interested in the error handling here, since that is often a point of vulnerability. I'll need to pay close attention to the architecture-specific aspects, too, as early memory mapping is often tightly bound to the platformβs hardware.
|
| 67/2 |
2026/05/26 05:48 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:mm/early_ioremap.c IncludeLines:true Name:early_memremap]
Results: map[SourceCode: 224: /* Remap memory */
225: void __init *
226: early_memremap(resource_size_t phys_addr, unsigned long size)
227: {
228: pgprot_t prot = early_memremap_pgprot_adjust(phys_addr, size,
229: FIXMAP_PAGE_NORMAL);
230:
231: return (__force void *)__early_ioremap(phys_addr, size, prot);
232: }
SourceFile:mm/early_ioremap.c]
|
| 68/2 |
2026/05/26 05:48 |
llm |
expert |
0m
Model:
Tokens:
input: 96110
output: 42
thoughts: 9
Thoughts: Okay, here's my interpretation of that thought process, tailored for an expert audience, and written in the first person:
**Early I/O Remapping β Where Are We Now?**
Right, so we're looking at memory mapping, particularly within the kernel's initialization phase. The question that immediately pops into my head is: *`__early_ioremap`?* That's the core of how we're going to get access to device registers before the full memory management system is up and running. I'm thinking about the implications β the limitations, the potential for issues. I'm wondering if there are any specific challenges at this stage, any dependencies or potential conflicts with the underlying architecture. What's the current state of that function within this project? Has it been touched recently? Are there any known bugs? Have we considered the implications for the new hardware we're targeting? Itβs crucial to know this. I want to be certain that the basic memory mapping is established correctly. After all, so much of the rest of the work relies on this initial step.
|
| 69/2 |
2026/05/26 05:48 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:mm/early_ioremap.c IncludeLines:true Name:__early_ioremap]
Results: map[SourceCode: 107: static void __init __iomem *
108: __early_ioremap(resource_size_t phys_addr, unsigned long size, pgprot_t prot)
109: {
110: unsigned long offset;
111: resource_size_t last_addr;
112: unsigned int nrpages;
113: enum fixed_addresses idx;
114: int i, slot;
115:
116: WARN_ON(system_state >= SYSTEM_RUNNING);
117:
118: slot = -1;
119: for (i = 0; i < FIX_BTMAPS_SLOTS; i++) {
120: if (!prev_map[i]) {
121: slot = i;
122: break;
123: }
124: }
125:
126: if (WARN(slot < 0, "%s(%pa, %08lx) not found slot\n",
127: __func__, &phys_addr, size))
128: return NULL;
129:
130: /* Don't allow wraparound or zero size */
131: last_addr = phys_addr + size - 1;
132: if (WARN_ON(!size || last_addr < phys_addr))
133: return NULL;
134:
135: prev_size[slot] = size;
136: /*
137: * Mappings have to be page-aligned
138: */
139: offset = offset_in_page(phys_addr);
140: phys_addr &= PAGE_MASK;
141: size = PAGE_ALIGN(last_addr + 1) - phys_addr;
142:
143: /*
144: * Mappings have to fit in the FIX_BTMAP area.
145: */
146: nrpages = size >> PAGE_SHIFT;
147: if (WARN_ON(nrpages > NR_FIX_BTMAPS))
148: return NULL;
149:
150: early_ioremap_dbg("%s(%pa, %08lx) [%d] => %08lx + %08lx\n",
151: __func__, &phys_addr, size, slot, slot_virt[slot], offset);
152:
153: /*
154: * Ok, go for it..
155: */
156: idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*slot;
157: while (nrpages > 0) {
158: if (after_paging_init)
159: __late_set_fixmap(idx, phys_addr, prot);
160: else
161: __early_set_fixmap(idx, phys_addr, prot);
162: phys_addr += PAGE_SIZE;
163: --idx;
164: --nrpages;
165: }
166:
167: prev_map[slot] = (void __iomem *)(offset + slot_virt[slot]);
168: return prev_map[slot];
169: }
SourceFile:mm/early_ioremap.c]
|
| 70/2 |
2026/05/26 05:48 |
llm |
expert |
0m
Model:
Tokens:
input: 97344
output: 26
thoughts: 828
Thoughts: **Analyzing the Mysterious Invalid Physical Address**
Okay, so here's the situation. `__early_ioremap` is the culprit. It doesn't validate the physical address before mapping it. This means that during the boot process, if `early_memremap_is_setup_data` gets an invalid physical address, it will just map it and happily read whatever garbage is there. Initially, I thought this would lead to an immediate crash or an infinite loop when `data->next` pointed to garbage, causing it to map more garbage addresses. I then thought, depending on the system, reading from an invalid physical address could return all ones (0xFFFFFFFF) or trigger a machine check exception. In a VM, it's very common for it to return 0xFFFFFFFF, which would cause an infinite loop of attempting to map `0xFFFFFFFFFFFFFFFF`. I realized this could still be the case, even though that's not a valid physical address, because `__early_ioremap` *would* just map it!
But then I saw the bug report: `boot_params.hdr.setup_data` is `4ff4208dd89fe53e`. That's an *invalid* address! And the warning: `"ioremap: invalid physical address 4ff4208dd89fe53e"`. This warning comes from `memremap` -> `arch_memremap_wb` -> `ioremap_cache` -> `__ioremap_caller`. The key is that the caller is `pcibios_device_add`. Within `pcibios_device_add`, it's clear: `boot_params.hdr.setup_data` is used directly with `memremap`, which will trigger the warning.
Here's the problem: `pcibios_device_add` is called for *every* PCI device. If `boot_params.hdr.setup_data` was already `4ff4208dd89fe53e` during boot, the warning would have been triggered *then*. But it wasn't! I recalled the use of `WARN_ON_ONCE`. This means that if it warned during boot, it would not warn again. So, the invalid address *must* have appeared *after* boot.
Now the question is: how could `boot_params.hdr.setup_data` change after boot? I need to check the code. Are there any writes to `boot_params.hdr.setup_data`? That's the key to understanding the root cause.
|
| 71/2 |
2026/05/26 05:48 |
tool |
grepper |
0m
Error:
Args: map[Expression:boot_params\.hdr\.setup_data\s*=]
Results:
|
| 72/2 |
2026/05/26 05:48 |
llm |
expert |
0m
Model:
Tokens:
input: 98770
output: 20
thoughts: 11
Thoughts: Okay, let's dive into this. Here's my thought process on this task:
**Analyzing the `setup_data` Assignments**
Alright, my initial instinct is to zero in on the `setup_data` assignments. I need to be absolutely certain of what's happening there, right from the get-go. With my background, I understand the critical importance of foundational data structures. Any subtle error in how `setup_data` is handled can ripple outwards, causing significant problems down the line. I want to carefully examine each variable or object assigned within `setup_data`. I will trace them and make sure nothing is missed.
|
| 73/2 |
2026/05/26 05:48 |
tool |
grepper |
0m
Args: map[Expression:setup_data\s*=]
Results: map[Output:Documentation/arch/x86/boot.rst=941=sections::
--
Documentation/arch/x86/boot.rst-943- setup_header = .data
Documentation/arch/x86/boot.rst:944: boot_params/setup_data = .bss
Documentation/arch/x86/boot.rst-945-
--
arch/x86/kernel/kdebugfs.c=29=static ssize_t setup_data_read(struct file *file, char __user *user_buf,
--
arch/x86/kernel/kdebugfs.c-68-
arch/x86/kernel/kdebugfs.c:69:static const struct file_operations fops_setup_data = {
arch/x86/kernel/kdebugfs.c-70- .read = setup_data_read,
--
arch/x86/kernel/kexec-bzimage64.c=125=setup_rng_seed(struct boot_params *params, unsigned long params_load_addr,
--
arch/x86/kernel/kexec-bzimage64.c-138- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:139: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-140-}
--
arch/x86/kernel/kexec-bzimage64.c=165=prepare_add_efi_setup_data(struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-182- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:183: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-184-
--
arch/x86/kernel/kexec-bzimage64.c=226=static void setup_dtb(struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-242- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:243: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-244-}
--
arch/x86/kernel/kexec-bzimage64.c=248=setup_ima_state(const struct kimage *image, struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-269- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:270: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-271-#endif /* CONFIG_IMA_KEXEC */
--
arch/x86/kernel/kexec-bzimage64.c=274=static void setup_kho(const struct kimage *image, struct boot_params *params,
--
arch/x86/kernel/kexec-bzimage64.c-296- sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:297: params->hdr.setup_data = params_load_addr + setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c-298-}
--
drivers/firmware/efi/libstub/x86-stub.c=115=static void setup_efi_pci(struct boot_params *params)
--
drivers/firmware/efi/libstub/x86-stub.c-149- else
drivers/firmware/efi/libstub/x86-stub.c:150: params->hdr.setup_data = (unsigned long)rom;
drivers/firmware/efi/libstub/x86-stub.c-151-
--
drivers/firmware/efi/libstub/x86-stub.c=156=static void retrieve_apple_device_properties(struct boot_params *boot_params)
--
drivers/firmware/efi/libstub/x86-stub.c-197- if (!data) {
drivers/firmware/efi/libstub/x86-stub.c:198: boot_params->hdr.setup_data = (unsigned long)new;
drivers/firmware/efi/libstub/x86-stub.c-199- } else {
--
drivers/firmware/efi/libstub/x86-stub.c=551=static void add_e820ext(struct boot_params *params,
--
drivers/firmware/efi/libstub/x86-stub.c-567- else
drivers/firmware/efi/libstub/x86-stub.c:568: params->hdr.setup_data = (unsigned long)e820ext;
drivers/firmware/efi/libstub/x86-stub.c-569-}
--
drivers/i2c/busses/i2c-mlxbf.c=1158=static const struct mlxbf_i2c_timings mlxbf_i2c_timings[] = {
--
drivers/i2c/busses/i2c-mlxbf.c-1164- .setup_stop = 4000,
drivers/i2c/busses/i2c-mlxbf.c:1165: .setup_data = 250,
drivers/i2c/busses/i2c-mlxbf.c-1166- .sda_rise = 50,
--
drivers/i2c/busses/i2c-mlxbf.c-1180- .setup_stop = 600,
drivers/i2c/busses/i2c-mlxbf.c:1181: .setup_data = 100,
drivers/i2c/busses/i2c-mlxbf.c-1182- .sda_rise = 50,
--
drivers/i2c/busses/i2c-mlxbf.c-1196- .setup_stop = 260,
drivers/i2c/busses/i2c-mlxbf.c:1197: .setup_data = 50,
drivers/i2c/busses/i2c-mlxbf.c-1198- .sda_rise = 50,
--
drivers/net/ethernet/freescale/fs_enet/mac-fcc.c=559=const struct fs_ops fs_fcc_ops = {
drivers/net/ethernet/freescale/fs_enet/mac-fcc.c:560: .setup_data = setup_data,
drivers/net/ethernet/freescale/fs_enet/mac-fcc.c-561- .cleanup_data = cleanup_data,
--
drivers/net/ethernet/freescale/fs_enet/mac-fec.c=448=const struct fs_ops fs_fec_ops = {
drivers/net/ethernet/freescale/fs_enet/mac-fec.c:449: .setup_data = setup_data,
drivers/net/ethernet/freescale/fs_enet/mac-fec.c-450- .cleanup_data = cleanup_data,
--
drivers/net/ethernet/freescale/fs_enet/mac-scc.c=456=const struct fs_ops fs_scc_ops = {
drivers/net/ethernet/freescale/fs_enet/mac-scc.c:457: .setup_data = setup_data,
drivers/net/ethernet/freescale/fs_enet/mac-scc.c-458- .cleanup_data = cleanup_data,
--
drivers/usb/gadget/udc/pch_udc.c=2307=static void pch_udc_svc_control_out(struct pch_udc_dev *dev)
--
drivers/usb/gadget/udc/pch_udc.c-2324- dev->ep[UDC_EP0OUT_IDX].halted = 0;
drivers/usb/gadget/udc/pch_udc.c:2325: dev->setup_data = ep->td_stp->request;
drivers/usb/gadget/udc/pch_udc.c-2326- pch_udc_init_setup_buff(ep->td_stp);
--
fs/lockd/clntproc.c=343=static struct rpc_task *__nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops)
--
fs/lockd/clntproc.c-346- struct rpc_clnt *clnt;
fs/lockd/clntproc.c:347: struct rpc_task_setup task_setup_data = {
fs/lockd/clntproc.c-348- .rpc_message = msg,
--
fs/nfs/nfs42proc.c=639=static int nfs42_do_offload_cancel_async(struct file *dst,
--
fs/nfs/nfs42proc.c-649- };
fs/nfs/nfs42proc.c:650: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs42proc.c-651- .rpc_client = dst_server->client,
--
fs/nfs/nfs4proc.c=2431=static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
--
fs/nfs/nfs4proc.c-2440- };
fs/nfs/nfs4proc.c:2441: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-2442- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c=2594=static int nfs4_run_open_task(struct nfs4_opendata *data,
--
fs/nfs/nfs4proc.c-2608- };
fs/nfs/nfs4proc.c:2609: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-2610- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c=3750=int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
--
fs/nfs/nfs4proc.c-3761- };
fs/nfs/nfs4proc.c:3762: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-3763- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c=6550=int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
--
fs/nfs/nfs4proc.c-6565- };
fs/nfs/nfs4proc.c:6566: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-6567- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c=6802=static int _nfs4_proc_delegreturn(struct inode *inode, const struct cred *cred,
--
fs/nfs/nfs4proc.c-6813- };
fs/nfs/nfs4proc.c:6814: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-6815- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c=7145=static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
--
fs/nfs/nfs4proc.c-7155- };
fs/nfs/nfs4proc.c:7156: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-7157- .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
--
fs/nfs/nfs4proc.c=7429=static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
--
fs/nfs/nfs4proc.c-7437- };
fs/nfs/nfs4proc.c:7438: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-7439- .rpc_client = NFS_CLIENT(state->inode),
--
fs/nfs/nfs4proc.c=8116=static int _nfs41_proc_get_locations(struct nfs_server *server,
--
fs/nfs/nfs4proc.c-8146- };
fs/nfs/nfs4proc.c:8147: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-8148- .rpc_client = clnt,
--
fs/nfs/nfs4proc.c=8444=int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
--
fs/nfs/nfs4proc.c-8462- };
fs/nfs/nfs4proc.c:8463: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-8464- .rpc_client = clnt,
--
fs/nfs/nfs4proc.c=8689=nfs4_run_exchange_id(struct nfs_client *clp, const struct cred *cred,
--
fs/nfs/nfs4proc.c-8695- };
fs/nfs/nfs4proc.c:8696: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-8697- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c=9376=static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
--
fs/nfs/nfs4proc.c-9385- };
fs/nfs/nfs4proc.c:9386: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9387- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c=9530=static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
--
fs/nfs/nfs4proc.c-9537- };
fs/nfs/nfs4proc.c:9538: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9539- .rpc_client = clp->cl_rpcclient,
--
fs/nfs/nfs4proc.c=9693=nfs4_proc_layoutget(struct nfs4_layoutget *lgp,
--
fs/nfs/nfs4proc.c-9704- };
fs/nfs/nfs4proc.c:9705: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9706- .rpc_client = server->client,
--
fs/nfs/nfs4proc.c=9850=int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, unsigned int flags)
--
fs/nfs/nfs4proc.c-9859- };
fs/nfs/nfs4proc.c:9860: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-9861- .rpc_client = NFS_SERVER(lrp->args.inode)->client,
--
fs/nfs/nfs4proc.c=10002=nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
--
fs/nfs/nfs4proc.c-10009- };
fs/nfs/nfs4proc.c:10010: struct rpc_task_setup task_setup_data = {
fs/nfs/nfs4proc.c-10011- .task = &data->task,
--
fs/nfs/pagelist.c=733=int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr,
--
fs/nfs/pagelist.c-743- };
fs/nfs/pagelist.c:744: struct rpc_task_setup task_setup_data = {
fs/nfs/pagelist.c-745- .rpc_client = clnt,
--
fs/nfs/unlink.c=89=static void nfs_do_call_unlink(struct inode *inode, struct nfs_unlinkdata *data)
--
fs/nfs/unlink.c-95- };
fs/nfs/unlink.c:96: struct rpc_task_setup task_setup_data = {
fs/nfs/unlink.c-97- .rpc_message = &msg,
--
fs/nfs/unlink.c=340=nfs_async_rename(struct inode *old_dir, struct inode *new_dir,
--
fs/nfs/unlink.c-345- struct rpc_message msg = { };
fs/nfs/unlink.c:346: struct rpc_task_setup task_setup_data = {
fs/nfs/unlink.c-347- .rpc_message = &msg,
--
fs/nfs/write.c=1624=int nfs_initiate_commit(struct rpc_clnt *clnt, struct nfs_commit_data *data,
--
fs/nfs/write.c-1636- };
fs/nfs/write.c:1637: struct rpc_task_setup task_setup_data = {
fs/nfs/write.c-1638- .task = &data->task,
--
net/sunrpc/auth_tls.c=50=static int tls_probe(struct rpc_clnt *clnt)
--
net/sunrpc/auth_tls.c-54- };
net/sunrpc/auth_tls.c:55: struct rpc_task_setup task_setup_data = {
net/sunrpc/auth_tls.c-56- .rpc_client = clnt,
--
net/sunrpc/clnt.c=1253=int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
--
net/sunrpc/clnt.c-1255- struct rpc_task *task;
net/sunrpc/clnt.c:1256: struct rpc_task_setup task_setup_data = {
net/sunrpc/clnt.c-1257- .rpc_client = clnt,
--
net/sunrpc/clnt.c=1289=rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
--
net/sunrpc/clnt.c-1292- struct rpc_task *task;
net/sunrpc/clnt.c:1293: struct rpc_task_setup task_setup_data = {
net/sunrpc/clnt.c-1294- .rpc_client = clnt,
--
net/sunrpc/clnt.c=1318=struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
--
net/sunrpc/clnt.c-1321- struct rpc_task *task;
net/sunrpc/clnt.c:1322: struct rpc_task_setup task_setup_data = {
net/sunrpc/clnt.c-1323- .callback_ops = &rpc_default_ops,
--
net/sunrpc/clnt.c=2860=struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt,
--
net/sunrpc/clnt.c-2866- };
net/sunrpc/clnt.c:2867: struct rpc_task_setup task_setup_data = {
net/sunrpc/clnt.c-2868- .rpc_client = clnt,
--
net/sunrpc/clnt.c=2903=static int rpc_ping_noreply(struct rpc_clnt *clnt)
--
net/sunrpc/clnt.c-2907- };
net/sunrpc/clnt.c:2908: struct rpc_task_setup task_setup_data = {
net/sunrpc/clnt.c-2909- .rpc_client = clnt,
--
net/sunrpc/rpcb_clnt.c=620=static struct rpc_task *rpcb_call_async(struct rpc_clnt *rpcb_clnt,
--
net/sunrpc/rpcb_clnt.c-627- };
net/sunrpc/rpcb_clnt.c:628: struct rpc_task_setup task_setup_data = {
net/sunrpc/rpcb_clnt.c-629- .rpc_client = rpcb_clnt,
]
|
| 74/2 |
2026/05/26 05:48 |
llm |
expert |
1m
Model:
Tokens:
input: 104739
output: 44
thoughts: 610
Thoughts: **Debugging a Potential Kernel Corruption**
Okay, so I'm trying to wrap my head around this `ioremap` error with the funky physical address `4ff4208dd89fe53e`. I was initially thinking about `kexec` and whether a fuzzing attempt could somehow corrupt the *current* kernel's `boot_params`. But after rereading the `kexec_file_load` code, specifically in `arch/x86/kernel/kexec-bzimage64.c`, I see that it's only modifying the `boot_params` for the *new* kernel being loaded, right? The `params` pointer points to freshly allocated memory, so no direct corruption there.
So, scratch the `kexec` angle, at least directly. That address is just pure noise, almost certainly not a valid pointer. This means `data->next` is garbage, therefore `data` was read from physical memory and that physical memory contains garbage. But *how*?
I'm thinking this has to be a memory map issue. If the bootloader, QEMU in this case, allocates memory for `setup_data` *but* doesn't declare it as reserved in the E820 map, the kernel's going to happily use that region for whatever allocations it needs, right? Slab allocations, page cache, you name it. Then, later, say when `pcibios_device_add` gets called, maybe through a sysfs rescan or something, it reads `boot_params.hdr.setup_data`. But hold on, the `boot_params.hdr.setup_data` holds a physical address! If the memory at *that* physical address has been overwritten by kernel allocations, then `data->next` will obviously contain the garbage we're seeing!
It looks like I need to confirm that `setup_data` is properly reserved during boot. That's the key.
|
| 75/2 |
2026/05/26 05:49 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/setup.c IncludeLines:true Name:reserve_initrd]
Results: map[SourceCode: 362: static void __init reserve_initrd(void)
363: {
364: /* Assume only end is not page aligned */
365: u64 ramdisk_image = get_ramdisk_image();
366: u64 ramdisk_size = get_ramdisk_size();
367: u64 ramdisk_end = PAGE_ALIGN(ramdisk_image + ramdisk_size);
368:
369: if (!boot_params.hdr.type_of_loader ||
370: !ramdisk_image || !ramdisk_size)
371: return; /* No initrd provided by bootloader */
372:
373: initrd_start = 0;
374:
375: printk(KERN_INFO "RAMDISK: [mem %#010llx-%#010llx]\n", ramdisk_image,
376: ramdisk_end - 1);
377:
378: if (pfn_range_is_mapped(PFN_DOWN(ramdisk_image),
379: PFN_DOWN(ramdisk_end))) {
380: /* All are mapped, easy case */
381: initrd_start = ramdisk_image + PAGE_OFFSET;
382: initrd_end = initrd_start + ramdisk_size;
383: return;
384: }
385:
386: relocate_initrd();
387:
388: memblock_phys_free(ramdisk_image, ramdisk_end - ramdisk_image);
389: }
SourceFile:arch/x86/kernel/setup.c]
|
| 76/2 |
2026/05/26 05:49 |
llm |
expert |
0m
Model:
Tokens:
input: 106301
output: 17
thoughts: 35
Thoughts: Okay, here's my interpretation of that thought process, from an expert's perspective:
**Investigating Potential Data Structure for Setup**
Alright, I need to figure out if we have a reserved area or a specific data structure to manage setup information. My initial instinct is to check for a `reserve_setup_data` function or macro. It's a fairly common pattern. If I find something like that, it'll provide a direct pointer to the relevant structures.
However, I'll need to locate where this data is defined and handled. Instead of simply looking for `reserve_setup_data`, I should broaden the search to look at how "setup_data" is managed. The most logical place to start digging is `arch/x86/kernel/setup.c`. That's the go-to location for architecture-specific initialization on x86, and "setup" is a pretty broad term that could cover a lot of ground during those early stages. That file will almost certainly hold the keys to understanding how early system configuration data is being handled. Let's see what's there.
|
| 77/2 |
2026/05/26 05:49 |
tool |
grepper |
0m
Args: map[Expression:setup_data]
Results: map[Output:
Full output is too long, showing 500 out of 1983 lines.
Use more precise expression if possible.
[Documentation/ABI/testing/sysfs-kernel-boot_params=4=Description: The /sys/kernel/boot_params directory contains two
Documentation/ABI/testing/sysfs-kernel-boot_params:5: files: "data" and "version" and one subdirectory "setup_data".
Documentation/ABI/testing/sysfs-kernel-boot_params-6- It is used to export the kernel boot parameters of an x86
--
Documentation/ABI/testing/sysfs-kernel-boot_params-8-
Documentation/ABI/testing/sysfs-kernel-boot_params:9: If there's no setup_data in boot_params the subdirectory will
Documentation/ABI/testing/sysfs-kernel-boot_params-10- not be created.
--
Documentation/ABI/testing/sysfs-kernel-boot_params-16-
Documentation/ABI/testing/sysfs-kernel-boot_params:17: "setup_data" subdirectory contains the setup_data data
Documentation/ABI/testing/sysfs-kernel-boot_params:18: structure in boot_params. setup_data is maintained in kernel
Documentation/ABI/testing/sysfs-kernel-boot_params:19: as a link list. In "setup_data" subdirectory there's one
Documentation/ABI/testing/sysfs-kernel-boot_params-20- subdirectory for each link list node named with the number
--
Documentation/ABI/testing/sysfs-kernel-boot_params-22- files "type" and "data". "type" file is the string
Documentation/ABI/testing/sysfs-kernel-boot_params:23: representation of setup_data type. "data" file is the binary
Documentation/ABI/testing/sysfs-kernel-boot_params:24: representation of setup_data payload.
Documentation/ABI/testing/sysfs-kernel-boot_params-25-
--
Documentation/ABI/testing/sysfs-kernel-boot_params-29- |__ data
Documentation/ABI/testing/sysfs-kernel-boot_params:30: |__ setup_data
Documentation/ABI/testing/sysfs-kernel-boot_params-31- | |__ 0
--
Documentation/arch/x86/boot.rst=54=Protocol 2.09 (Kernel 2.6.26) Added a field of 64-bit physical
Documentation/arch/x86/boot.rst:55: pointer to single linked list of struct setup_data.
Documentation/arch/x86/boot.rst-56-
--
Documentation/arch/x86/boot.rst=187=Offset/Size Proto Name Meaning
--
Documentation/arch/x86/boot.rst-222-024C/4 2.08+ payload_length Length of kernel payload
Documentation/arch/x86/boot.rst:223:0250/8 2.09+ setup_data 64-bit physical pointer to linked list
Documentation/arch/x86/boot.rst:224: of struct setup_data
Documentation/arch/x86/boot.rst-225-0258/8 2.10+ pref_address Preferred loading address
--
Documentation/arch/x86/boot.rst=794=Protocol: 2.08+
--
Documentation/arch/x86/boot.rst-799-============ ===============
Documentation/arch/x86/boot.rst:800:Field name: setup_data
Documentation/arch/x86/boot.rst-801-Type: write (special)
--
Documentation/arch/x86/boot.rst=803=Protocol: 2.09+
--
Documentation/arch/x86/boot.rst-806- The 64-bit physical pointer to NULL terminated single linked list of
Documentation/arch/x86/boot.rst:807: struct setup_data. This is used to define a more extensible boot
Documentation/arch/x86/boot.rst:808: parameters passing mechanism. The definition of struct setup_data is
Documentation/arch/x86/boot.rst-809- as follow::
Documentation/arch/x86/boot.rst-810-
Documentation/arch/x86/boot.rst:811: struct setup_data {
Documentation/arch/x86/boot.rst-812- __u64 next;
--
Documentation/arch/x86/boot.rst-827-
Documentation/arch/x86/boot.rst:828: The setup_data is a bit awkward to use for extremely large data objects,
Documentation/arch/x86/boot.rst:829: both because the setup_data header has to be adjacent to the data object
Documentation/arch/x86/boot.rst-830- and because it has a 32-bit length field. However, it is important that
--
Documentation/arch/x86/boot.rst-849- Let's give an example how to point to SETUP_E820_EXT data using setup_indirect.
Documentation/arch/x86/boot.rst:850: In this case setup_data and setup_indirect will look like this::
Documentation/arch/x86/boot.rst-851-
Documentation/arch/x86/boot.rst:852: struct setup_data {
Documentation/arch/x86/boot.rst:853: .next = 0, /* or <addr_of_next_setup_data_struct> */
Documentation/arch/x86/boot.rst-854- .type = SETUP_INDIRECT,
--
Documentation/arch/x86/boot.rst=941=sections::
--
Documentation/arch/x86/boot.rst-943- setup_header = .data
Documentation/arch/x86/boot.rst:944: boot_params/setup_data = .bss
Documentation/arch/x86/boot.rst-945-
--
Documentation/arch/x86/boot.rst=952=Also, the BIOS stub is responsible for creating boot_params, so it isn't
Documentation/arch/x86/boot.rst:953:available to a BIOS-based loader (setup_data is, though).
Documentation/arch/x86/boot.rst-954-
--
Documentation/arch/x86/boot.rst=962=boot_params proper is limited to 4096 bytes, but can be arbitrarily extended
Documentation/arch/x86/boot.rst:963:by adding setup_data entries. It cannot be used to communicate properties of
Documentation/arch/x86/boot.rst-964-the kernel image, because it is .bss and has no image-provided content.
--
Documentation/arch/x86/boot.rst=969=necessary it can still contain data items that an enabled bootloader would be
Documentation/arch/x86/boot.rst:970:expected to copy into a setup_data chunk.
Documentation/arch/x86/boot.rst-971-
--
Documentation/arch/x86/boot.rst=1035=Offset/size: 0x000c/4
--
Documentation/arch/x86/boot.rst-1037-
Documentation/arch/x86/boot.rst:1038: This field contains maximal allowed type for setup_data and setup_indirect structs.
Documentation/arch/x86/boot.rst-1039-
--
Documentation/arch/x86/booting-dt.rst=3=DeviceTree Booting
--
Documentation/arch/x86/booting-dt.rst-10- Documentation/arch/x86/boot.rst
Documentation/arch/x86/booting-dt.rst:11: The physical pointer to the device-tree block is passed via setup_data
Documentation/arch/x86/booting-dt.rst-12- which requires at least boot protocol 2.09.
--
arch/powerpc/platforms/512x/clock-commonclk.c=508=enum mclk_type {
--
arch/powerpc/platforms/512x/clock-commonclk.c-514-
arch/powerpc/platforms/512x/clock-commonclk.c:515:struct mclk_setup_data {
arch/powerpc/platforms/512x/clock-commonclk.c-516- enum mclk_type type;
--
arch/powerpc/platforms/512x/clock-commonclk.c-560-
arch/powerpc/platforms/512x/clock-commonclk.c:561:static struct mclk_setup_data mclk_psc_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-562- MCLK_SETUP_DATA_PSC(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-575-
arch/powerpc/platforms/512x/clock-commonclk.c:576:static struct mclk_setup_data mclk_mscan_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-577- MCLK_SETUP_DATA_MSCAN(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-582-
arch/powerpc/platforms/512x/clock-commonclk.c:583:static struct mclk_setup_data mclk_spdif_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-584- MCLK_SETUP_DATA_SPDIF,
--
arch/powerpc/platforms/512x/clock-commonclk.c-586-
arch/powerpc/platforms/512x/clock-commonclk.c:587:static struct mclk_setup_data mclk_outclk_data[] = {
arch/powerpc/platforms/512x/clock-commonclk.c-588- MCLK_SETUP_DATA_OUTCLK(0),
--
arch/powerpc/platforms/512x/clock-commonclk.c-594-/* setup the MCLK clock subtree of an individual PSC/MSCAN/SPDIF */
arch/powerpc/platforms/512x/clock-commonclk.c:595:static void __init mpc512x_clk_setup_mclk(struct mclk_setup_data *entry, size_t idx)
arch/powerpc/platforms/512x/clock-commonclk.c-596-{
--
arch/x86/boot/compressed/efi.c=60=unsigned long efi_get_system_table(struct boot_params *bp)
--
arch/x86/boot/compressed/efi.c-83- * not be accessible for the kexec'd kernel. To address this, kexec provides
arch/x86/boot/compressed/efi.c:84: * the initial physical address via a struct setup_data entry, which is
arch/x86/boot/compressed/efi.c-85- * checked for here, along with some sanity checks.
arch/x86/boot/compressed/efi.c-86- */
arch/x86/boot/compressed/efi.c:87:static struct efi_setup_data *get_kexec_setup_data(struct boot_params *bp,
arch/x86/boot/compressed/efi.c-88- enum efi_type et)
--
arch/x86/boot/compressed/efi.c-90-#ifdef CONFIG_X86_64
arch/x86/boot/compressed/efi.c:91: struct efi_setup_data *esd = NULL;
arch/x86/boot/compressed/efi.c:92: struct setup_data *data;
arch/x86/boot/compressed/efi.c-93- u64 pa_data;
arch/x86/boot/compressed/efi.c-94-
arch/x86/boot/compressed/efi.c:95: pa_data = bp->hdr.setup_data;
arch/x86/boot/compressed/efi.c-96- while (pa_data) {
arch/x86/boot/compressed/efi.c:97: data = (struct setup_data *)pa_data;
arch/x86/boot/compressed/efi.c-98- if (data->type == SETUP_EFI) {
arch/x86/boot/compressed/efi.c:99: esd = (struct efi_setup_data *)(pa_data + sizeof(struct setup_data));
arch/x86/boot/compressed/efi.c-100- break;
--
arch/x86/boot/compressed/efi.c=131=int efi_get_conf_table(struct boot_params *bp, unsigned long *cfg_tbl_pa,
--
arch/x86/boot/compressed/efi.c-148- efi_system_table_64_t *stbl = (efi_system_table_64_t *)sys_tbl_pa;
arch/x86/boot/compressed/efi.c:149: struct efi_setup_data *esd;
arch/x86/boot/compressed/efi.c-150-
arch/x86/boot/compressed/efi.c-151- /* kexec provides an alternative EFI conf table, check for it. */
arch/x86/boot/compressed/efi.c:152: esd = get_kexec_setup_data(bp, et);
arch/x86/boot/compressed/efi.c-153-
--
arch/x86/boot/compressed/ident_map_64.c=110=void initialize_identity_maps(void *rmode)
--
arch/x86/boot/compressed/ident_map_64.c-112- unsigned long cmdline;
arch/x86/boot/compressed/ident_map_64.c:113: struct setup_data *sd;
arch/x86/boot/compressed/ident_map_64.c-114-
--
arch/x86/boot/compressed/ident_map_64.c-168- /*
arch/x86/boot/compressed/ident_map_64.c:169: * Also map the setup_data entries passed via boot_params in case they
arch/x86/boot/compressed/ident_map_64.c-170- * need to be accessed by uncompressed kernel via the identity mapping.
arch/x86/boot/compressed/ident_map_64.c-171- */
arch/x86/boot/compressed/ident_map_64.c:172: sd = (struct setup_data *)boot_params_ptr->hdr.setup_data;
arch/x86/boot/compressed/ident_map_64.c-173- while (sd) {
--
arch/x86/boot/compressed/ident_map_64.c-176- kernel_add_identity_map(sd_addr, sd_addr + sizeof(*sd) + sd->len);
arch/x86/boot/compressed/ident_map_64.c:177: sd = (struct setup_data *)sd->next;
arch/x86/boot/compressed/ident_map_64.c-178- }
--
arch/x86/boot/compressed/kaslr.c=354=static void mem_avoid_init(unsigned long input, unsigned long input_size,
--
arch/x86/boot/compressed/kaslr.c-389-
arch/x86/boot/compressed/kaslr.c:390: /* We don't need to set a mapping for setup_data. */
arch/x86/boot/compressed/kaslr.c-391-
--
arch/x86/boot/compressed/kaslr.c=403=static bool mem_avoid_overlap(struct mem_vector *img,
--
arch/x86/boot/compressed/kaslr.c-406- int i;
arch/x86/boot/compressed/kaslr.c:407: struct setup_data *ptr;
arch/x86/boot/compressed/kaslr.c-408- u64 earliest = img->start + img->size;
--
arch/x86/boot/compressed/kaslr.c-419-
arch/x86/boot/compressed/kaslr.c:420: /* Avoid all entries in the setup_data linked list. */
arch/x86/boot/compressed/kaslr.c:421: ptr = (struct setup_data *)(unsigned long)boot_params_ptr->hdr.setup_data;
arch/x86/boot/compressed/kaslr.c-422- while (ptr) {
--
arch/x86/boot/compressed/kaslr.c-445-
arch/x86/boot/compressed/kaslr.c:446: ptr = (struct setup_data *)(unsigned long)ptr->next;
arch/x86/boot/compressed/kaslr.c-447- }
--
arch/x86/boot/compressed/kaslr.c=767=static bool process_kho_entries(unsigned long minimum, unsigned long image_size)
--
arch/x86/boot/compressed/kaslr.c-769- struct kho_scratch *kho_scratch;
arch/x86/boot/compressed/kaslr.c:770: struct setup_data *ptr;
arch/x86/boot/compressed/kaslr.c-771- struct kho_data *kho;
--
arch/x86/boot/compressed/kaslr.c-776-
arch/x86/boot/compressed/kaslr.c:777: ptr = (struct setup_data *)(unsigned long)boot_params_ptr->hdr.setup_data;
arch/x86/boot/compressed/kaslr.c-778- while (ptr) {
--
arch/x86/boot/compressed/kaslr.c-785-
arch/x86/boot/compressed/kaslr.c:786: ptr = (struct setup_data *)(unsigned long)ptr->next;
arch/x86/boot/compressed/kaslr.c-787- }
--
arch/x86/boot/compressed/kernel_info.S=9=kernel_info:
--
arch/x86/boot/compressed/kernel_info.S-16-
arch/x86/boot/compressed/kernel_info.S:17: /* Maximal allowed type for setup_data and setup_indirect structs. */
arch/x86/boot/compressed/kernel_info.S-18- .long SETUP_TYPE_MAX
--
arch/x86/boot/compressed/sev.c=238=static struct cc_blob_sev_info *find_cc_blob_efi(struct boot_params *bp)
--
arch/x86/boot/compressed/sev.c-258- * - via an entry in the EFI config table
arch/x86/boot/compressed/sev.c:259: * - via a setup_data structure, as defined by the Linux Boot Protocol
arch/x86/boot/compressed/sev.c-260- *
--
arch/x86/boot/compressed/sev.c=263=static struct cc_blob_sev_info *find_cc_blob(struct boot_params *bp)
--
arch/x86/boot/compressed/sev.c-270-
arch/x86/boot/compressed/sev.c:271: cc_info = find_cc_blob_setup_data(bp);
arch/x86/boot/compressed/sev.c-272- if (!cc_info)
--
arch/x86/boot/header.S=394=payload_length: .long ZO_z_input_len
arch/x86/boot/header.S-395-
arch/x86/boot/header.S:396:setup_data: .quad 0 # 64-bit physical pointer to
arch/x86/boot/header.S-397- # single linked list of
arch/x86/boot/header.S:398: # struct setup_data
arch/x86/boot/header.S-399-
--
arch/x86/boot/startup/sev-shared.c-11-
arch/x86/boot/startup/sev-shared.c:12:#include <asm/setup_data.h>
arch/x86/boot/startup/sev-shared.c-13-
--
arch/x86/boot/startup/sev-shared.c=442=void do_vc_no_ghcb(struct pt_regs *regs, unsigned long exit_code)
--
arch/x86/boot/startup/sev-shared.c-519-
arch/x86/boot/startup/sev-shared.c:520:struct cc_setup_data {
arch/x86/boot/startup/sev-shared.c:521: struct setup_data header;
arch/x86/boot/startup/sev-shared.c-522- u32 cc_blob_address;
--
arch/x86/boot/startup/sev-shared.c-525-/*
arch/x86/boot/startup/sev-shared.c:526: * Search for a Confidential Computing blob passed in as a setup_data entry
arch/x86/boot/startup/sev-shared.c-527- * via the Linux Boot Protocol.
--
arch/x86/boot/startup/sev-shared.c=529=static __init
arch/x86/boot/startup/sev-shared.c:530:struct cc_blob_sev_info *find_cc_blob_setup_data(struct boot_params *bp)
arch/x86/boot/startup/sev-shared.c-531-{
arch/x86/boot/startup/sev-shared.c:532: struct cc_setup_data *sd = NULL;
arch/x86/boot/startup/sev-shared.c:533: struct setup_data *hdr;
arch/x86/boot/startup/sev-shared.c-534-
arch/x86/boot/startup/sev-shared.c:535: hdr = (struct setup_data *)bp->hdr.setup_data;
arch/x86/boot/startup/sev-shared.c-536-
--
arch/x86/boot/startup/sev-shared.c-538- if (hdr->type == SETUP_CC_BLOB) {
arch/x86/boot/startup/sev-shared.c:539: sd = (struct cc_setup_data *)hdr;
arch/x86/boot/startup/sev-shared.c-540- return (struct cc_blob_sev_info *)(unsigned long)sd->cc_blob_address;
arch/x86/boot/startup/sev-shared.c-541- }
arch/x86/boot/startup/sev-shared.c:542: hdr = (struct setup_data *)hdr->next;
arch/x86/boot/startup/sev-shared.c-543- }
--
arch/x86/boot/startup/sev-startup.c=92=void __init early_snp_set_memory_shared(unsigned long vaddr, unsigned long paddr,
--
arch/x86/boot/startup/sev-startup.c-122- * - when booted directly by firmware/bootloader (e.g. CONFIG_PVH):
arch/x86/boot/startup/sev-startup.c:123: * - via a setup_data entry, as defined by the Linux Boot Protocol
arch/x86/boot/startup/sev-startup.c-124- *
--
arch/x86/boot/startup/sev-startup.c=127=static struct cc_blob_sev_info *__init find_cc_blob(struct boot_params *bp)
--
arch/x86/boot/startup/sev-startup.c-139- * boot/decompression kernel, the CC blob may have been passed via
arch/x86/boot/startup/sev-startup.c:140: * setup_data instead.
arch/x86/boot/startup/sev-startup.c-141- */
arch/x86/boot/startup/sev-startup.c:142: cc_info = find_cc_blob_setup_data(bp);
arch/x86/boot/startup/sev-startup.c-143- if (!cc_info)
--
arch/x86/include/asm/setup_data.h-4-
arch/x86/include/asm/setup_data.h:5:#include <uapi/asm/setup_data.h>
arch/x86/include/asm/setup_data.h-6-
--
arch/x86/include/asm/setup_data.h=9=struct pci_setup_rom {
arch/x86/include/asm/setup_data.h:10: struct setup_data data;
arch/x86/include/asm/setup_data.h-11- uint16_t vendor;
--
arch/x86/include/asm/setup_data.h-21-/* kexec external ABI */
arch/x86/include/asm/setup_data.h:22:struct efi_setup_data {
arch/x86/include/asm/setup_data.h-23- u64 fw_vendor;
--
arch/x86/include/uapi/asm/bootparam.h-4-
arch/x86/include/uapi/asm/bootparam.h:5:#include <asm/setup_data.h>
arch/x86/include/uapi/asm/bootparam.h-6-
--
arch/x86/include/uapi/asm/bootparam.h=38=struct setup_header {
--
arch/x86/include/uapi/asm/bootparam.h-72- __u32 payload_length;
arch/x86/include/uapi/asm/bootparam.h:73: __u64 setup_data;
arch/x86/include/uapi/asm/bootparam.h-74- __u64 pref_address;
--
arch/x86/include/uapi/asm/bootparam.h=93=struct efi_info {
--
arch/x86/include/uapi/asm/bootparam.h-110-/*
arch/x86/include/uapi/asm/bootparam.h:111: * Smallest compatible version of jailhouse_setup_data required by this kernel.
arch/x86/include/uapi/asm/bootparam.h-112- */
--
arch/x86/include/uapi/asm/setup_data.h-4-
arch/x86/include/uapi/asm/setup_data.h:5:/* setup_data/setup_indirect types */
arch/x86/include/uapi/asm/setup_data.h-6-#define SETUP_NONE 0
--
arch/x86/include/uapi/asm/setup_data.h-26-/* extensible setup data list node */
arch/x86/include/uapi/asm/setup_data.h:27:struct setup_data {
arch/x86/include/uapi/asm/setup_data.h-28- __u64 next;
--
arch/x86/include/uapi/asm/setup_data.h=45=struct boot_e820_entry {
--
arch/x86/include/uapi/asm/setup_data.h-54- */
arch/x86/include/uapi/asm/setup_data.h:55:struct jailhouse_setup_data {
arch/x86/include/uapi/asm/setup_data.h-56- struct {
--
arch/x86/include/uapi/asm/setup_data.h-76- */
arch/x86/include/uapi/asm/setup_data.h:77:struct ima_setup_data {
arch/x86/include/uapi/asm/setup_data.h-78- __u64 addr;
--
arch/x86/kernel/devicetree.c=36=void __init add_dtb(u64 data)
arch/x86/kernel/devicetree.c-37-{
arch/x86/kernel/devicetree.c:38: initial_dtb = data + offsetof(struct setup_data, data);
arch/x86/kernel/devicetree.c-39-}
--
arch/x86/kernel/e820.c=724=__init void e820__reallocate_tables(void)
--
arch/x86/kernel/e820.c-748- * the remaining (if any) entries are passed via the SETUP_E820_EXT node of
arch/x86/kernel/e820.c:749: * struct setup_data, which is parsed here.
arch/x86/kernel/e820.c-750- */
arch/x86/kernel/e820.c=751=__init void e820__memory_setup_extended(u64 phys_addr, u32 data_len)
--
arch/x86/kernel/e820.c-754- struct boot_e820_entry *extmap;
arch/x86/kernel/e820.c:755: struct setup_data *sdata;
arch/x86/kernel/e820.c-756-
--
arch/x86/kernel/jailhouse.c-27-
arch/x86/kernel/jailhouse.c:28:static struct jailhouse_setup_data setup_data;
arch/x86/kernel/jailhouse.c:29:#define SETUP_DATA_V1_LEN (sizeof(setup_data.hdr) + sizeof(setup_data.v1))
arch/x86/kernel/jailhouse.c:30:#define SETUP_DATA_V2_LEN (SETUP_DATA_V1_LEN + sizeof(setup_data.v2))
arch/x86/kernel/jailhouse.c-31-
--
arch/x86/kernel/jailhouse.c=65=static void __init jailhouse_timer_init(void)
arch/x86/kernel/jailhouse.c-66-{
arch/x86/kernel/jailhouse.c:67: lapic_timer_period = setup_data.v1.apic_khz * (1000 / HZ);
arch/x86/kernel/jailhouse.c-68-}
--
arch/x86/kernel/jailhouse.c=93=static void __init jailhouse_parse_smp_config(void)
--
arch/x86/kernel/jailhouse.c-104-
arch/x86/kernel/jailhouse.c:105: for (cpu = 0; cpu < setup_data.v1.num_cpus; cpu++)
arch/x86/kernel/jailhouse.c:106: topology_register_apic(setup_data.v1.cpu_ids[cpu], CPU_ACPIID_INVALID, true);
arch/x86/kernel/jailhouse.c-107-
--
arch/x86/kernel/jailhouse.c-109-
arch/x86/kernel/jailhouse.c:110: if (setup_data.v1.standard_ioapic) {
arch/x86/kernel/jailhouse.c-111- mp_register_ioapic(0, 0xfec00000, gsi_top, &ioapic_cfg);
--
arch/x86/kernel/jailhouse.c-113- if (IS_ENABLED(CONFIG_SERIAL_8250) &&
arch/x86/kernel/jailhouse.c:114: setup_data.hdr.version < 2) {
arch/x86/kernel/jailhouse.c-115- /* Register 1:1 mapping for legacy UART IRQs 3 and 4 */
--
arch/x86/kernel/jailhouse.c=128=static int __init jailhouse_pci_arch_init(void)
--
arch/x86/kernel/jailhouse.c-140-#ifdef CONFIG_PCI_MMCONFIG
arch/x86/kernel/jailhouse.c:141: if (setup_data.v1.pci_mmconfig_base) {
arch/x86/kernel/jailhouse.c-142- pci_mmconfig_add(0, 0, pcibios_last_bus,
arch/x86/kernel/jailhouse.c:143: setup_data.v1.pci_mmconfig_base);
arch/x86/kernel/jailhouse.c-144- pci_mmcfg_arch_init();
--
arch/x86/kernel/jailhouse.c=152=static inline bool jailhouse_uart_enabled(unsigned int uart_nr)
arch/x86/kernel/jailhouse.c-153-{
arch/x86/kernel/jailhouse.c:154: return setup_data.v2.flags & BIT(uart_nr);
arch/x86/kernel/jailhouse.c-155-}
--
arch/x86/kernel/jailhouse.c=179=static void __init jailhouse_serial_workaround(void)
--
arch/x86/kernel/jailhouse.c-181- /*
arch/x86/kernel/jailhouse.c:182: * There are flags inside setup_data that indicate availability of
arch/x86/kernel/jailhouse.c-183- * platform UARTs since setup data version 2.
--
arch/x86/kernel/jailhouse.c-188- */
arch/x86/kernel/jailhouse.c:189: if (setup_data.hdr.version > 1)
arch/x86/kernel/jailhouse.c-190- serial8250_set_isa_configurator(jailhouse_serial_fixup);
--
arch/x86/kernel/jailhouse.c=198=static void __init jailhouse_init_platform(void)
arch/x86/kernel/jailhouse.c-199-{
arch/x86/kernel/jailhouse.c:200: u64 pa_data = boot_params.hdr.setup_data;
arch/x86/kernel/jailhouse.c:201: unsigned long setup_data_len;
arch/x86/kernel/jailhouse.c:202: struct setup_data header;
arch/x86/kernel/jailhouse.c-203- void *mapping;
--
arch/x86/kernel/jailhouse.c-237- /* setup data must at least contain the header */
arch/x86/kernel/jailhouse.c:238: if (header.len < sizeof(setup_data.hdr))
arch/x86/kernel/jailhouse.c-239- goto unsupported;
arch/x86/kernel/jailhouse.c-240-
arch/x86/kernel/jailhouse.c:241: pa_data += offsetof(struct setup_data, data);
arch/x86/kernel/jailhouse.c:242: setup_data_len = min_t(unsigned long, sizeof(setup_data),
arch/x86/kernel/jailhouse.c-243- (unsigned long)header.len);
arch/x86/kernel/jailhouse.c:244: mapping = early_memremap(pa_data, setup_data_len);
arch/x86/kernel/jailhouse.c:245: memcpy(&setup_data, mapping, setup_data_len);
arch/x86/kernel/jailhouse.c:246: early_memunmap(mapping, setup_data_len);
arch/x86/kernel/jailhouse.c-247-
arch/x86/kernel/jailhouse.c:248: if (setup_data.hdr.version == 0 ||
arch/x86/kernel/jailhouse.c:249: setup_data.hdr.compatible_version !=
arch/x86/kernel/jailhouse.c-250- JAILHOUSE_SETUP_REQUIRED_VERSION ||
arch/x86/kernel/jailhouse.c:251: (setup_data.hdr.version == 1 && header.len < SETUP_DATA_V1_LEN) ||
arch/x86/kernel/jailhouse.c:252: (setup_data.hdr.version >= 2 && header.len < SETUP_DATA_V2_LEN))
arch/x86/kernel/jailhouse.c-253- goto unsupported;
arch/x86/kernel/jailhouse.c-254-
arch/x86/kernel/jailhouse.c:255: pmtmr_ioport = setup_data.v1.pm_timer_address;
arch/x86/kernel/jailhouse.c-256- pr_debug("Jailhouse: PM-Timer IO Port: %#x\n", pmtmr_ioport);
arch/x86/kernel/jailhouse.c-257-
arch/x86/kernel/jailhouse.c:258: precalibrated_tsc_khz = setup_data.v1.tsc_khz;
arch/x86/kernel/jailhouse.c-259- setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ);
--
arch/x86/kernel/kdebugfs.c=20=EXPORT_SYMBOL(arch_debugfs_dir);
--
arch/x86/kernel/kdebugfs.c-22-#ifdef CONFIG_DEBUG_BOOT_PARAMS
arch/x86/kernel/kdebugfs.c:23:struct setup_data_node {
arch/x86/kernel/kdebugfs.c-24- u64 paddr;
--
arch/x86/kernel/kdebugfs.c-28-
arch/x86/kernel/kdebugfs.c:29:static ssize_t setup_data_read(struct file *file, char __user *user_buf,
arch/x86/kernel/kdebugfs.c-30- size_t count, loff_t *ppos)
arch/x86/kernel/kdebugfs.c-31-{
arch/x86/kernel/kdebugfs.c:32: struct setup_data_node *node = file->private_data;
arch/x86/kernel/kdebugfs.c-33- unsigned long remain;
--
arch/x86/kernel/kdebugfs.c-50- if (!(node->type & SETUP_INDIRECT) || node->type == SETUP_INDIRECT)
arch/x86/kernel/kdebugfs.c:51: pa += sizeof(struct setup_data);
arch/x86/kernel/kdebugfs.c-52-
--
arch/x86/kernel/kdebugfs.c-68-
arch/x86/kernel/kdebugfs.c:69:static const struct file_operations fops_setup_data = {
arch/x86/kernel/kdebugfs.c:70: .read = setup_data_read,
arch/x86/kernel/kdebugfs.c-71- .open = simple_open,
--
arch/x86/kernel/kdebugfs.c=75=static void __init
arch/x86/kernel/kdebugfs.c:76:create_setup_data_node(struct dentry *parent, int no,
arch/x86/kernel/kdebugfs.c:77: struct setup_data_node *node)
arch/x86/kernel/kdebugfs.c-78-{
--
arch/x86/kernel/kdebugfs.c-85- debugfs_create_x32("type", S_IRUGO, d, &node->type);
arch/x86/kernel/kdebugfs.c:86: debugfs_create_file("data", S_IRUGO, d, node, &fops_setup_data);
arch/x86/kernel/kdebugfs.c-87-}
arch/x86/kernel/kdebugfs.c-88-
arch/x86/kernel/kdebugfs.c:89:static int __init create_setup_data_nodes(struct dentry *parent)
arch/x86/kernel/kdebugfs.c-90-{
arch/x86/kernel/kdebugfs.c-91- struct setup_indirect *indirect;
arch/x86/kernel/kdebugfs.c:92: struct setup_data_node *node;
arch/x86/kernel/kdebugfs.c:93: struct setup_data *data;
arch/x86/kernel/kdebugfs.c-94- u64 pa_data, pa_next;
--
arch/x86/kernel/kdebugfs.c-99-
arch/x86/kernel/kdebugfs.c:100: d = debugfs_create_dir("setup_data", parent);
arch/x86/kernel/kdebugfs.c-101-
arch/x86/kernel/kdebugfs.c:102: pa_data = boot_params.hdr.setup_data;
arch/x86/kernel/kdebugfs.c-103-
--
arch/x86/kernel/kdebugfs.c-145-
arch/x86/kernel/kdebugfs.c:146: create_setup_data_node(d, no, node);
arch/x86/kernel/kdebugfs.c-147- pa_data = pa_next;
--
arch/x86/kernel/kdebugfs.c=165=static int __init boot_params_kdebugfs_init(void)
--
arch/x86/kernel/kdebugfs.c-174-
arch/x86/kernel/kdebugfs.c:175: error = create_setup_data_nodes(dbp);
arch/x86/kernel/kdebugfs.c-176- if (error)
--
arch/x86/kernel/kexec-bzimage64.c=125=setup_rng_seed(struct boot_params *params, unsigned long params_load_addr,
arch/x86/kernel/kexec-bzimage64.c:126: unsigned int rng_seed_setup_data_offset)
arch/x86/kernel/kexec-bzimage64.c-127-{
arch/x86/kernel/kexec-bzimage64.c:128: struct setup_data *sd = (void *)params + rng_seed_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:129: unsigned long setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-130-
--
arch/x86/kernel/kexec-bzimage64.c-136- get_random_bytes(sd->data, RNG_SEED_LENGTH);
arch/x86/kernel/kexec-bzimage64.c:137: setup_data_phys = params_load_addr + rng_seed_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:138: sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:139: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-140-}
--
arch/x86/kernel/kexec-bzimage64.c=164=static int
arch/x86/kernel/kexec-bzimage64.c:165:prepare_add_efi_setup_data(struct boot_params *params,
arch/x86/kernel/kexec-bzimage64.c-166- unsigned long params_load_addr,
arch/x86/kernel/kexec-bzimage64.c:167: unsigned int efi_setup_data_offset)
arch/x86/kernel/kexec-bzimage64.c-168-{
arch/x86/kernel/kexec-bzimage64.c:169: unsigned long setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c:170: struct setup_data *sd = (void *)params + efi_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:171: struct efi_setup_data *esd = (void *)sd + sizeof(struct setup_data);
arch/x86/kernel/kexec-bzimage64.c-172-
--
arch/x86/kernel/kexec-bzimage64.c-177- sd->type = SETUP_EFI;
arch/x86/kernel/kexec-bzimage64.c:178: sd->len = sizeof(struct efi_setup_data);
arch/x86/kernel/kexec-bzimage64.c-179-
arch/x86/kernel/kexec-bzimage64.c-180- /* Add setup data */
arch/x86/kernel/kexec-bzimage64.c:181: setup_data_phys = params_load_addr + efi_setup_data_offset;
arch/x86/kernel/kexec-bzimage64.c:182: sd->next = params->hdr.setup_data;
arch/x86/kernel/kexec-bzimage64.c:183: params->hdr.setup_data = setup_data_phys;
arch/x86/kernel/kexec-bzimage64.c-184-
--
arch/x86/kernel/kexec-bzimage64.c=189=setup_efi_state(struct boot_params *params, unsigned long params_load_addr,
arch/x86/kernel/kexec-bzimage64.c-190- unsigned int efi_map_offset, unsigned int efi_map_sz,
]
]
|
| 78/2 |
2026/05/26 05:49 |
llm |
expert |
0m
Model:
Tokens:
input: 118505
output: 53
thoughts: 69
Thoughts: **Investigating E820 Memory Reservation**
Okay, so I'm digging into how memory is handled during boot on x86, and I've got a specific question about the `setup_data` region. My initial thought is to check `arch/x86/kernel/e820.c`, and I'm particularly interested in `e820__memory_setup_extended`. I'm wondering if this function, within the context of the E820 map, accounts for reserving the `setup_data` memory region. I know this area holds critical early boot information, so its allocation is crucial for the process. To get to the bottom of this, I'll jump right into the code at around line 751. I'll need to meticulously examine the code flow there to see exactly how it handles that crucial memory range.
|
| 79/2 |
2026/05/26 05:50 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/e820.c IncludeLines:true Name:e820__memory_setup_extended]
Results: map[SourceCode: 745: /*
746: * Because of the small fixed size of struct boot_params, only the first
747: * 128 E820 memory entries are passed to the kernel via boot_params.e820_table,
748: * the remaining (if any) entries are passed via the SETUP_E820_EXT node of
749: * struct setup_data, which is parsed here.
750: */
751: __init void e820__memory_setup_extended(u64 phys_addr, u32 data_len)
752: {
753: int entries;
754: struct boot_e820_entry *extmap;
755: struct setup_data *sdata;
756:
757: sdata = early_memremap(phys_addr, data_len);
758: entries = sdata->len / sizeof(*extmap);
759: extmap = (struct boot_e820_entry *)(sdata->data);
760:
761: append_e820_table(extmap, entries);
762: e820__update_table(e820_table);
763:
764: memcpy(e820_table_kexec, e820_table, sizeof(*e820_table_kexec));
765: memcpy(e820_table_firmware, e820_table, sizeof(*e820_table_firmware));
766:
767: early_memunmap(sdata, data_len);
768: pr_info("extended physical RAM map:\n");
769: e820__print_table("extended");
770: }
SourceFile:arch/x86/kernel/e820.c]
|
| 80/2 |
2026/05/26 05:50 |
llm |
expert |
0m
Model:
Tokens:
input: 119339
output: 22
thoughts: 50
Thoughts: Okay, here's my take on those thoughts, framed as my own mental process:
**Diving into Memory Reservation**
Alright, so I'm thinking about memory reservation, specifically, the `setup_data`. It doesn't seem like the code *directly* reserves the `setup_data` memory area. That's a bit odd. I wonder where, and *how*, that memory gets blocked off? Time to dig deeper. I'll need to trace the memory allocation back to its source. Let me check `arch/x86/kernel/setup.c`. That's where I'd expect to find calls to something like `memblock_reserve` that would handle this. Let's see what clues that file holds!
|
| 81/2 |
2026/05/26 05:50 |
tool |
grepper |
0m
Error:
Args: map[Expression:memblock_reserve.*setup_data]
Results:
|
| 82/2 |
2026/05/26 05:50 |
llm |
expert |
0m
Model:
Tokens:
input: 119584
output: 22
thoughts: 23
Thoughts: Here's my thought process, summarized as you requested:
**Navigating the x86 Kernel Setup**
Okay, so I need to find where the `setup_data` structure is initialized, and my intuition points me towards the x86 architecture-specific kernel setup code. That would make sense. Let's delve into the `arch/x86/kernel/` directory. Within that, `setup.c` seems like the most likely candidate for handling early system initialization and configuration. Iβll open `arch/x86/kernel/setup.c` and start scanning for the definition or use of the `setup_data` variable. Hopefully, it's straightforward, and I can quickly pinpoint the crucial initialization points. I'm expecting to find a clear assignment or function call related to it within the early boot process. Let's get to work and see what that file reveals!
|
| 83/2 |
2026/05/26 05:50 |
tool |
grepper |
0m
Error:
Args: map[Expression:setup_data.*memblock_reserve]
Results:
|
| 84/2 |
2026/05/26 05:50 |
llm |
expert |
0m
Model:
Tokens:
input: 119833
output: 20
thoughts: 24
Thoughts: Here's my thought process, summarized as you requested:
**Investigating Memory Reservation in x86 Setup**
Okay, so I need to understand how the kernel reserves memory during the x86 boot process. My first instinct is to dig into the `arch/x86/kernel/setup.c` file. Specifically, I'm going to look for any functions that start with `reserve_`. That prefix is a pretty standard naming convention for functions related to memory reservation, so it's the most likely place to start. I'm assuming that this file will contain the core logic for setting up the memory map and claiming blocks of memory that the kernel needs early on. I'm expecting to find functions that handle things like reserving the kernel image itself, the initial RAM disk, any specific regions for hardware, and so forth. Let's see what we can find.
|
| 85/2 |
2026/05/26 05:50 |
tool |
grepper |
0m
Args: map[Expression:reserve_.*setup_data]
Results: map[Output:arch/x86/kernel/setup.c=530=static void __init parse_boot_params(void)
--
arch/x86/kernel/setup.c-567-
arch/x86/kernel/setup.c:568:static void __init memblock_x86_reserve_range_setup_data(void)
arch/x86/kernel/setup.c-569-{
--
arch/x86/kernel/setup.c=796=static void __init early_reserve_memory(void)
--
arch/x86/kernel/setup.c-821-
arch/x86/kernel/setup.c:822: memblock_x86_reserve_range_setup_data();
arch/x86/kernel/setup.c-823-
]
|
| 86/2 |
2026/05/26 05:50 |
llm |
expert |
0m
Model:
Tokens:
input: 120276
output: 54
thoughts: 25
Thoughts: Here's my take on those thoughts, tailored for an expert audience:
**Analyzing `memblock_x86_reserve_range_setup_data`**
Okay, `memblock_x86_reserve_range_setup_data`. Let's dive in. My initial thought is to quickly mentally parse the name β it's suggesting something to do with reserving memory ranges, x86-specific, and related to setup data. I'm immediately thinking about boot-time memory mapping, potential conflicts, and how the kernel handles early initialization.
My next step would be to consider its context. Where does this function fit within the overall boot process? Is it called before or after the initial page table setup? What other memory management structures is it interacting with? I'll probably be recalling any recent discussions on boot-time memory allocation or addressing limitations in this context.
I'm starting to anticipate questions about its implementation. Does it use the standard `memblock` API, or does it incorporate some low-level addressing hacks? What kind of data is being reserved? Is it kernel code, ACPI tables, firmware regions, or something else entirely? A quick glance at the code structure should reveal the answer.
I'd also consider any potential gotchas. Are there any known issues with this function? Are there any architectural specific dependencies, and if so, what are they? Is there any overlap with other memory reservations that I need to be aware of? I'm already anticipating the need to check for potential race conditions or conflicts with other initialization code.
Finally, I'll be thinking about the implications. What happens if this function fails? Does it cause a fatal error, or is there some fallback mechanism? How does it affect the overall memory map? Ultimately, I'm trying to get a clear picture of how this piece of code shapes the memory landscape during the early boot process, and any potential points of interest for debugging or optimization.
|
| 87/2 |
2026/05/26 05:50 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/kernel/setup.c IncludeLines:true Name:memblock_x86_reserve_range_setup_data]
Results: map[SourceCode: 568: static void __init memblock_x86_reserve_range_setup_data(void)
569: {
570: struct setup_indirect *indirect;
571: struct setup_data *data;
572: u64 pa_data, pa_next;
573: u32 len;
574:
575: pa_data = boot_params.hdr.setup_data;
576: while (pa_data) {
577: data = early_memremap(pa_data, sizeof(*data));
578: if (!data) {
579: pr_warn("setup: failed to memremap setup_data entry\n");
580: return;
581: }
582:
583: len = sizeof(*data);
584: pa_next = data->next;
585:
586: memblock_reserve_kern(pa_data, sizeof(*data) + data->len);
587:
588: if (data->type == SETUP_INDIRECT) {
589: len += data->len;
590: early_memunmap(data, sizeof(*data));
591: data = early_memremap(pa_data, len);
592: if (!data) {
593: pr_warn("setup: failed to memremap indirect setup_data\n");
594: return;
595: }
596:
597: indirect = (struct setup_indirect *)data->data;
598:
599: if (indirect->type != SETUP_INDIRECT)
600: memblock_reserve_kern(indirect->addr, indirect->len);
601: }
602:
603: pa_data = pa_next;
604: early_memunmap(data, len);
605: }
606: }
SourceFile:arch/x86/kernel/setup.c]
|
| 88/2 |
2026/05/26 05:50 |
llm |
expert |
1m
Model:
Tokens:
input: 121347
output: 56
thoughts: 564
Thoughts: **My Analysis of the `setup_data` Reservation Process**
Okay, so I'm digging into this `setup_data` reservation. I see it starts by reserving a range. My mind is immediately drawn to this `pa_data` value of `4ff4208dd89fe53e`. That looks... wrong. If `early_memremap` maps that, it's a huge potential issue. If the initial mapping fails, the function rightly bails out and stops the reservation process which is good. If it *succeeds*, it reads `data->len` and `data->next`. If `data->next` happens to be garbage, it'll attempt to reserve *that* address too and continue the process, but the chain itself continues being reserved. Wait, that's not right... if `early_memremap` fails, it halts the entire chain reservation!
The thing is, if it stops reserving *in the middle of a chain* it's bad news, because `boot_params.hdr.setup_data` will still point to the *incomplete* chain. Later on, `pcibios_device_add` will iterate through the chain, but if it encounters an invalid physical address, `memremap` calls `arch_memremap_wb` which calls `ioremap_cache`, which warns, and this seems like it is a way to catch the problem, but...
Why didn't `early_memremap` warn in the first place? And this is where it clicks: `early_memremap` *doesn't* check if the physical address is valid with `phys_addr_valid`! So, during the initial boot, `memblock_x86_reserve_range_setup_data` maps the invalid address, reads garbage from memory, and continues! But if it reads garbage, `data->len` could be massive, and `memblock_reserve_kern` will reserve a *huge* chunk of memory.
But let's look at that invalid `pa_data` of `4ff4208dd89fe53e` again. If `early_memremap` maps it, it creates a PTE! Then when `data->next` is read, it reads from that invalid address. Now the interesting part, on a VM it *might* return `0xFFFFFFFF`, but it also *might* cause a machine check exception or a KVM internal error. If we *do* get the `0xFFFFFFFF` result, then `data->next` becomes `0xFFFFFFFFFFFFFFFF`. Then `pa_data` becomes `0xFFFFFFFFFFFFFFFF`, and then `early_memremap` proceeds to map *that* as well.
This is a dangerous loop.
I was expecting `pcibios_device_add` to trigger the warning during boot, but if `early_memremap` maps it first, the warning is suppressed. We need to go back and double check how `pcibios_device_add` is behaving in all of this.
|
| 89/2 |
2026/05/26 05:51 |
tool |
codesearch-find-references |
0m
Args: map[ContextFile:arch/x86/pci/common.c IncludeSnippetLines:0 Name:pcibios_device_add SourceTreePrefix:]
Results: map[References:[map[ReferenceKind:calls ReferencingEntityKind:function ReferencingEntityName:pci_device_add SourceFile:drivers/pci/probe.c SourceLine:2760]] TruncatedOutput:false]
|
| 90/2 |
2026/05/26 05:51 |
llm |
expert |
0m
Model:
Tokens:
input: 122700
output: 47
thoughts: 1636
Thoughts: **Analyzing the PCI Device Warning**
Okay, so I'm digging into this PCI device issue, specifically the `ioremap: invalid physical address` warning that's popping up. `pcibios_device_add` is the culprit, and it looks like it's being called when syzkaller triggers it through `dev_rescan_store`. The kicker is, this warning *isn't* happening during boot, which is the really puzzling part. My initial thought process is leading me to the following train of thoughts and inquiries:
First, let me clarify: `pci_device_add` is called for *every* PCI device. During the boot process, these devices are scanned and added. Therefore, `pcibios_device_add` *should* be called during boot. If `boot_params.hdr.setup_data` contains an invalid physical address, `pcibios_device_add` calls `memremap`, then `ioremap_cache`, and that *should* trigger the warning. And if it triggered during boot, the `WARN_ON_ONCE` would prevent it from triggering again. The problem is, syzkaller is reporting this bug triggering via `dev_rescan_store` and it's *not* a boot-time issue. That's the core of the problem.
Why wouldn't it trigger during boot? Did `boot_params.hdr.setup_data` change? I ruled that out. We checked for modifications to `boot_params.hdr.setup_data` and except for kexec, there were none. Okay, what about `data->next`? Could that be changed? It's in physical memory. If that memory isn't reserved, it *could* be overwritten. `memblock_x86_reserve_range_setup_data` should reserve it. Specifically, `memblock_reserve_kern`. What if `data->len` is zero and only `sizeof(*data)` is reserved, and the rest is freed? Could `initrd` memory play a role? If `setup_data` is inside `initrd` and the `initrd` memory is freed, that's a possibility. But isn't `setup_data` provided by the bootloader and typically placed in normal RAM? What if syzkaller is corrupting something through a different bug like use-after-free or out-of-bounds writes? That's a possibility, but the bug report is separate.
Now, let's look at the warning itself: `ioremap: invalid physical address 4ff4208dd89fe53e`. That looks like a pointer. Based on the registers, specifically `R12: 4ff4208dd89fe57d` and `R13: 4ff4208dd89fe53e`, it's `R13 + 0x3F`. If `sizeof(struct pci_setup_rom)` is 24 bytes, then `4ff4208dd89fe53e` is where the address data is coming from. That value is `pa_data`. Where does `pa_data` come from? `pa_data = data->next`. So, `data->next` is `4ff4208dd89fe53e`. That means the previous `setup_data` had `next = 4ff4208dd89fe53e`. Could `setup_data` be a sysfs file that syzkaller is writing to? No. They're read-only. Okay, is syzkaller writing to a PCI device's ROM via sysfs? `pcibios_device_add` sets `dev->rom = pa_data + offsetof(struct pci_setup_rom, romdata);`. It's just setting the ROM pointer. What about `kexec_load`? Could that be modifying the current kernel's `boot_params`? No, it loads a new kernel.
Let's re-think: why didn't it happen during boot? Maybe there were *no* PCI devices during boot? Is it even possible to boot a kernel without any PCI devices? Yes, if there are none in the VM. But this is Google Compute Engine, it has virtio devices. If `pci_device_add` is called during boot, it *will* trigger the `WARN_ON_ONCE`. Syzkaller parses the kernel log continuously. If the warning happened during boot, it would be reported and attributed to the boot process or some random program, but not to the syzkaller test case. But it's attributed to `syz.5.5717` and the
|
| 91/2 |
2026/05/26 05:51 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:drivers/pci/pci-sysfs.c IncludeLines:true Name:bus_rescan_store]
Results: map[SourceCode: 528: static ssize_t bus_rescan_store(struct device *dev,
529: struct device_attribute *attr,
530: const char *buf, size_t count)
531: {
532: unsigned long val;
533: struct pci_bus *bus = to_pci_bus(dev);
534:
535: if (kstrtoul(buf, 0, &val) < 0)
536: return -EINVAL;
537:
538: if (val) {
539: pci_lock_rescan_remove();
540: if (!pci_is_root_bus(bus) && list_empty(&bus->devices))
541: pci_rescan_bus_bridge_resize(bus->self);
542: else
543: pci_rescan_bus(bus);
544: pci_unlock_rescan_remove();
545: }
546: return count;
547: }
SourceFile:drivers/pci/pci-sysfs.c]
|
| 92/2 |
2026/05/26 05:51 |
llm |
expert |
0m
Model:
Tokens:
input: 125741
output: 17
thoughts: 275
Thoughts: **Analyzing the Device Rescan Issue**
Okay, so the stack trace points to `dev_rescan_store`, not the broader `bus_rescan_store`. That's a key clue. `dev_rescan_store` means we're dealing with a specific PCI device, not the whole bus. Right, a specific PCI device⦠therefore, a PCI device *must* exist for this function to even be called. It has to have been added at some point.
If it exists, it was either added during boot or hotplugged. Letβs assume boot for now, as hotplug seems less likely given the context. If it was during boot, that means `pcibios_device_add` was invoked at some point in the boot process. And if *that* was called, then it must have been iterating over the `boot_params.hdr.setup_data` structure.
Now, here's the kicker. If there were a problem with that data structure, we should have seen a warning during boot, right? We're not seeing that. So, `boot_params.hdr.setup_data` *must* have been valid during boot β or, perhaps, NULL. Okay, so if it was NULL during boot, then `pa_data` in the loop would be zero and the loop would never execute.
Wait a second. If it *was* NULL initially, how could it possibly become non-NULL later? Is there any code that actually modifies `boot_params.hdr.setup_data` *after* boot? We should have checked this earlier, but better safe than sorry. I seem to recall that kexec modifies a *new* copy of `boot_params`. That's not the problem.
Hang on⦠what about `pci_setup_rom`? Could that be relevant? Is there any code that adds an entry of `SETUP_PCI` to `setup_data`? That's the key question. We need to find out. Let's start by searching for `SETUP_PCI`.
|
| 93/2 |
2026/05/26 05:52 |
tool |
grepper |
0m
Args: map[Expression:SETUP_PCI]
Results: map[Output:arch/x86/include/uapi/asm/setup_data.h-8-#define SETUP_DTB 2
arch/x86/include/uapi/asm/setup_data.h:9:#define SETUP_PCI 3
arch/x86/include/uapi/asm/setup_data.h-10-#define SETUP_EFI 4
--
arch/x86/pci/common.c=643=int pcibios_device_add(struct pci_dev *dev)
--
arch/x86/pci/common.c-655-
arch/x86/pci/common.c:656: if (data->type == SETUP_PCI) {
arch/x86/pci/common.c-657- rom = (struct pci_setup_rom *)data;
--
drivers/firmware/efi/libstub/x86-stub.c=43=preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)
--
drivers/firmware/efi/libstub/x86-stub.c-73-
drivers/firmware/efi/libstub/x86-stub.c:74: rom->data.type = SETUP_PCI;
drivers/firmware/efi/libstub/x86-stub.c-75- rom->data.len = size - sizeof(struct setup_data);
]
|
| 94/2 |
2026/05/26 05:52 |
llm |
expert |
0m
Model:
Tokens:
input: 126842
output: 52
thoughts: 68
Thoughts: Okay, here's my interpretation of that thought process, tailored for an expert audience:
**EFI Stub PCI Initialization Deep Dive**
Right, so I see that `drivers/firmware/efi/libstub/x86-stub.c` is where things are getting interesting. Specifically, it looks like the `SETUP_PCI` flag is being incorporated into the `setup_data` structure within that file. This immediately piques my interest; the inclusion of PCI setup within the EFI stub is a key integration point. I need to understand *how* it's being handled. My focus now shifts to the `setup_efi_pci` function, also found in `drivers/firmware/efi/libstub/x86-stub.c`. Time to dig in and see precisely how they are managing PCI configuration and enumeration within the EFI environment, and how this relates to the overall handover process to the kernel. I expect this function to shed light on how they're handling resource allocation, potentially remapping, and the overall device initialization sequence from the EFI runtime perspective.
|
| 95/2 |
2026/05/26 05:52 |
tool |
codesearch-definition-source |
0m
Error:
Args: map[ContextFile:drivers/firmware/efi/libstub/x86-stub.c IncludeLines:true Name:setup_efi_pci]
Results: map[SourceCode: SourceFile:]
|
| 96/2 |
2026/05/26 05:52 |
llm |
expert |
0m
Model:
Tokens:
input: 127209
output: 20
thoughts: 18
Thoughts: Here's my thought process, as if I were thinking it:
**Using Grepper for Efficient Code Navigation**
Okay, time to get to work. I need to find the definition of `setup_efi_pci`. My go-to approach is to reach for `grepper`. It's incredibly efficient for this type of code search, much faster than a standard `grep` or relying solely on my IDE's indexing. I'm going to leverage `grepper`'s ability to quickly traverse repositories and identify the exact file and line where that function is defined. This will provide the precise context I need to understand how the function is used and how it fits into the larger system. No need to waste time guessing file names or getting tripped up by ambiguous search results when `grepper` can handle it in a matter of seconds. Let's see what it turns up.
|
| 97/2 |
2026/05/26 05:52 |
tool |
grepper |
0m
Args: map[Expression:setup_efi_pci]
Results: map[Output:drivers/firmware/efi/libstub/x86-stub.c=43=preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)
--
drivers/firmware/efi/libstub/x86-stub.c-114- */
drivers/firmware/efi/libstub/x86-stub.c:115:static void setup_efi_pci(struct boot_params *params)
drivers/firmware/efi/libstub/x86-stub.c-116-{
--
drivers/firmware/efi/libstub/x86-stub.c=912=void __noreturn efi_stub_entry(efi_handle_t handle,
--
drivers/firmware/efi/libstub/x86-stub.c-1019-
drivers/firmware/efi/libstub/x86-stub.c:1020: setup_efi_pci(boot_params);
drivers/firmware/efi/libstub/x86-stub.c-1021-
]
|
| 98/2 |
2026/05/26 05:52 |
llm |
expert |
0m
Model:
Tokens:
input: 127717
output: 32
thoughts: 12
Thoughts: Okay, let's dive into this. Here's my take on understanding this `setup_efi_pci` function:
**Analyzing the `setup_efi_pci` Function**
Alright, so the first thing I'm doing is reading the code for `setup_efi_pci`. I'm going to assume it's dealing with configuring the PCI bus within an EFI environment. Given the name, that's the obvious starting point. I need to understand how it's interfacing with the EFI system, which APIs it's utilizing for discovering and configuring PCI devices. I'll be looking for the critical steps: device enumeration, resource allocation (memory regions, interrupt lines, etc.), and actually programming the PCI configuration space. Is this using the EFI PCI I/O protocol? The PCI root bridge I/O protocol? Or something else entirely?
I'm particularly interested in how it handles potential conflicts. Does it check for resource overlaps? Does it have any kind of fallback mechanism if certain PCI devices or their resources cannot be initialized as requested? I'll also be watching for any optimizations β are they doing things in parallel where possible, or batching operations to reduce overhead?
I'm going to carefully note the error handling. I'd expect comprehensive checks for things like device not being present, resource allocation failures, and programming failures. How gracefully does it handle these scenarios? Does it log errors, return specific error codes, or attempt any kind of recovery? I'm hoping to see well-defined error handling and reporting.
Finally, I'll be looking for any signs of platform-specific code. EFI implementations can vary, so I'm wondering if there are any conditional compilation directives or specific platform checks in place. Understanding any platform dependencies is crucial. I'm hoping to understand what assumptions are made about the underlying hardware and the EFI firmware it's running on.
|
| 99/2 |
2026/05/26 05:52 |
tool |
read-file |
0m
Args: map[File:drivers/firmware/efi/libstub/x86-stub.c]
Results: map[Contents:// SPDX-License-Identifier: GPL-2.0-only
/* -----------------------------------------------------------------------
*
* Copyright 2011 Intel Corporation; author Matt Fleming
*
* ----------------------------------------------------------------------- */
#include <linux/efi.h>
#include <linux/pci.h>
#include <linux/stddef.h>
#include <asm/efi.h>
#include <asm/e820/types.h>
#include <asm/setup.h>
#include <asm/desc.h>
#include <asm/boot.h>
#include <asm/kaslr.h>
#include <asm/sev.h>
#include "efistub.h"
#include "x86-stub.h"
extern char _bss[], _ebss[];
const efi_system_table_t *efi_system_table;
const efi_dxe_services_table_t *efi_dxe_table;
static efi_loaded_image_t *image = NULL;
static efi_memory_attribute_protocol_t *memattr;
typedef union sev_memory_acceptance_protocol sev_memory_acceptance_protocol_t;
union sev_memory_acceptance_protocol {
struct {
efi_status_t (__efiapi * allow_unaccepted_memory)(
sev_memory_acceptance_protocol_t *);
};
struct {
u32 allow_unaccepted_memory;
} mixed_mode;
};
static efi_status_t
preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)
{
struct pci_setup_rom *rom __free(efi_pool) = NULL;
efi_status_t status;
unsigned long size;
uint64_t romsize;
void *romimage;
/*
* Some firmware images contain EFI function pointers at the place where
* the romimage and romsize fields are supposed to be. Typically the EFI
* code is mapped at high addresses, translating to an unrealistically
* large romsize. The UEFI spec limits the size of option ROMs to 16
* MiB so we reject any ROMs over 16 MiB in size to catch this.
*/
romimage = efi_table_attr(pci, romimage);
romsize = efi_table_attr(pci, romsize);
if (!romimage || !romsize || romsize > SZ_16M)
return EFI_INVALID_PARAMETER;
size = romsize + sizeof(*rom);
status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,
(void **)&rom);
if (status != EFI_SUCCESS) {
efi_err("Failed to allocate memory for 'rom'\n");
return status;
}
memset(rom, 0, sizeof(*rom));
rom->data.type = SETUP_PCI;
rom->data.len = size - sizeof(struct setup_data);
rom->data.next = 0;
rom->pcilen = romsize;
status = efi_call_proto(pci, pci.read, EfiPciIoWidthUint16,
PCI_VENDOR_ID, 1, &rom->vendor);
if (status != EFI_SUCCESS) {
efi_err("Failed to read rom->vendor\n");
return status;
}
status = efi_call_proto(pci, pci.read, EfiPciIoWidthUint16,
PCI_DEVICE_ID, 1, &rom->devid);
if (status != EFI_SUCCESS) {
efi_err("Failed to read rom->devid\n");
return status;
}
status = efi_call_proto(pci, get_location, &rom->segment, &rom->bus,
&rom->device, &rom->function);
if (status != EFI_SUCCESS)
return status;
memcpy(rom->romdata, romimage, romsize);
*__rom = no_free_ptr(rom);
return EFI_SUCCESS;
}
/*
* There's no way to return an informative status from this function,
* because any analysis (and printing of error messages) needs to be
* done directly at the EFI function call-site.
*
* For example, EFI_INVALID_PARAMETER could indicate a bug or maybe we
* just didn't find any PCI devices, but there's no way to tell outside
* the context of the call.
*/
static void setup_efi_pci(struct boot_params *params)
{
efi_status_t status;
efi_handle_t *pci_handle __free(efi_pool) = NULL;
efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
struct setup_data *data;
unsigned long num;
efi_handle_t h;
status = efi_bs_call(locate_handle_buffer, EFI_LOCATE_BY_PROTOCOL,
&pci_proto, NULL, &num, &pci_handle);
if (status != EFI_SUCCESS)
return;
data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
while (data && data->next)
data = (struct setup_data *)(unsigned long)data->next;
for_each_efi_handle(h, pci_handle, num) {
efi_pci_io_protocol_t *pci = NULL;
struct pci_setup_rom *rom;
status = efi_bs_call(handle_protocol, h, &pci_proto,
(void **)&pci);
if (status != EFI_SUCCESS || !pci)
continue;
status = preserve_pci_rom_image(pci, &rom);
if (status != EFI_SUCCESS)
continue;
if (data)
data->next = (unsigned long)rom;
else
params->hdr.setup_data = (unsigned long)rom;
data = (struct setup_data *)rom;
}
}
static void retrieve_apple_device_properties(struct boot_params *boot_params)
{
efi_guid_t guid = APPLE_PROPERTIES_PROTOCOL_GUID;
struct setup_data *data, *new;
efi_status_t status;
u32 size = 0;
apple_properties_protocol_t *p;
status = efi_bs_call(locate_protocol, &guid, NULL, (void **)&p);
if (status != EFI_SUCCESS)
return;
if (efi_table_attr(p, version) != 0x10000) {
efi_err("Unsupported properties proto version\n");
return;
}
efi_call_proto(p, get_all, NULL, &size);
if (!size)
return;
do {
status = efi_bs_call(allocate_pool, EFI_LOADER_DATA,
size + sizeof(struct setup_data),
(void **)&new);
if (status != EFI_SUCCESS) {
efi_err("Failed to allocate memory for 'properties'\n");
return;
}
status = efi_call_proto(p, get_all, new->data, &size);
if (status == EFI_BUFFER_TOO_SMALL)
efi_bs_call(free_pool, new);
} while (status == EFI_BUFFER_TOO_SMALL);
new->type = SETUP_APPLE_PROPERTIES;
new->len = size;
new->next = 0;
data = (struct setup_data *)(unsigned long)boot_params->hdr.setup_data;
if (!data) {
boot_params->hdr.setup_data = (unsigned long)new;
} else {
while (data->next)
data = (struct setup_data *)(unsigned long)data->next;
data->next = (unsigned long)new;
}
}
struct smbios_entry_point {
u8 anchor[4];
u8 ep_checksum;
u8 ep_length;
u8 major_version;
u8 minor_version;
u16 max_size_entry;
u8 ep_rev;
u8 reserved[5];
struct __packed {
u8 anchor[5];
u8 checksum;
u16 st_length;
u32 st_address;
u16 number_of_entries;
u8 bcd_rev;
} intm;
};
static bool verify_ep_checksum(const void *ptr, int length)
{
u8 sum = 0;
for (int i = 0; i < length; i++)
sum += ((u8 *)ptr)[i];
return sum == 0;
}
static bool verify_ep_integrity(const struct smbios_entry_point *ep)
{
if (memcmp(ep->anchor, "_SM_", sizeof(ep->anchor)) != 0)
return false;
if (memcmp(ep->intm.anchor, "_DMI_", sizeof(ep->intm.anchor)) != 0)
return false;
if (!verify_ep_checksum(ep, ep->ep_length) ||
!verify_ep_checksum(&ep->intm, sizeof(ep->intm)))
return false;
return true;
}
static const struct efi_smbios_record *search_record(void *table, u32 length,
u8 type)
{
const u8 *p, *end;
p = (u8 *)table;
end = p + length;
while (p + sizeof(struct efi_smbios_record) < end) {
const struct efi_smbios_record *hdr =
(struct efi_smbios_record *)p;
const u8 *next;
if (hdr->type == type)
return hdr;
/* Type 127 = End-of-Table */
if (hdr->type == 0x7F)
return NULL;
/* Jumping to the unformed section */
next = p + hdr->length;
/* Unformed section ends with 0000h */
while ((next[0] != 0 || next[1] != 0) && next + 1 < end)
next++;
next += 2;
p = next;
}
return NULL;
}
static const struct efi_smbios_record *get_table_record(u8 type)
{
const struct smbios_entry_point *ep;
/*
* Locate the legacy 32-bit SMBIOS entrypoint in memory, and parse it
* directly. Needed by some Macs that do not implement the EFI protocol.
*/
ep = get_efi_config_table(SMBIOS_TABLE_GUID);
if (!ep)
return NULL;
if (!verify_ep_integrity(ep))
return NULL;
return search_record((void *)(unsigned long)ep->intm.st_address,
ep->intm.st_length, type);
}
static bool apple_match_product_name(void)
{
static const char type1_product_matches[][15] = {
"MacBookPro11,3",
"MacBookPro11,5",
"MacBookPro13,3",
"MacBookPro14,3",
"MacBookPro15,1",
"MacBookPro15,3",
"MacBookPro16,1",
"MacBookPro16,4",
};
const struct efi_smbios_type1_record *record;
const u8 *product;
record = (struct efi_smbios_type1_record *)
(efi_get_smbios_record(1) ?: get_table_record(1));
if (!record)
return false;
product = efi_get_smbios_string(record, product_name);
if (!product)
return false;
for (int i = 0; i < ARRAY_SIZE(type1_product_matches); i++) {
if (!strcmp(product, type1_product_matches[i]))
return true;
}
return false;
}
static void apple_set_os(void)
{
struct {
unsigned long version;
efi_status_t (__efiapi *set_os_version)(const char *);
efi_status_t (__efiapi *set_os_vendor)(const char *);
} *set_os;
efi_status_t status;
if (!efi_is_64bit() || !apple_match_product_name())
return;
status = efi_bs_call(locate_protocol, &APPLE_SET_OS_PROTOCOL_GUID, NULL,
(void **)&set_os);
if (status != EFI_SUCCESS)
return;
if (set_os->version >= 2) {
status = set_os->set_os_vendor("Apple Inc.");
if (status != EFI_SUCCESS)
efi_err("Failed to set OS vendor via apple_set_os\n");
}
if (set_os->version > 0) {
/* The version being set doesn't seem to matter */
status = set_os->set_os_version("Mac OS X 10.9");
if (status != EFI_SUCCESS)
efi_err("Failed to set OS version via apple_set_os\n");
}
}
efi_status_t efi_adjust_memory_range_protection(unsigned long start,
unsigned long size)
{
efi_status_t status;
efi_gcd_memory_space_desc_t desc;
unsigned long end, next;
unsigned long rounded_start, rounded_end;
unsigned long unprotect_start, unprotect_size;
rounded_start = rounddown(start, EFI_PAGE_SIZE);
rounded_end = roundup(start + size, EFI_PAGE_SIZE);
if (memattr != NULL) {
status = efi_call_proto(memattr, set_memory_attributes,
rounded_start,
rounded_end - rounded_start,
EFI_MEMORY_RO);
if (status != EFI_SUCCESS) {
efi_warn("Failed to set EFI_MEMORY_RO attribute\n");
return status;
}
status = efi_call_proto(memattr, clear_memory_attributes,
rounded_start,
rounded_end - rounded_start,
EFI_MEMORY_XP);
if (status != EFI_SUCCESS)
efi_warn("Failed to clear EFI_MEMORY_XP attribute\n");
return status;
}
if (efi_dxe_table == NULL)
return EFI_SUCCESS;
/*
* Don't modify memory region attributes, if they are
* already suitable, to lower the possibility to
* encounter firmware bugs.
*/
for (end = start + size; start < end; start = next) {
status = efi_dxe_call(get_memory_space_descriptor, start, &desc);
if (status != EFI_SUCCESS)
break;
next = desc.base_address + desc.length;
/*
* Only system memory and more reliable memory are suitable for
* trampoline/kernel image placement. So only those memory types
* may need to have attributes modified.
*/
if ((desc.gcd_memory_type != EfiGcdMemoryTypeSystemMemory &&
desc.gcd_memory_type != EfiGcdMemoryTypeMoreReliable) ||
(desc.attributes & (EFI_MEMORY_RO | EFI_MEMORY_XP)) == 0)
continue;
unprotect_start = max(rounded_start, (unsigned long)desc.base_address);
unprotect_size = min(rounded_end, next) - unprotect_start;
status = efi_dxe_call(set_memory_space_attributes,
unprotect_start, unprotect_size,
EFI_MEMORY_WB);
if (status != EFI_SUCCESS) {
efi_warn("Unable to unprotect memory range [%08lx,%08lx]: %lx\n",
unprotect_start,
unprotect_start + unprotect_size,
status);
break;
}
}
return EFI_SUCCESS;
}
static void setup_unaccepted_memory(void)
{
efi_guid_t mem_acceptance_proto = OVMF_SEV_MEMORY_ACCEPTANCE_PROTOCOL_GUID;
sev_memory_acceptance_protocol_t *proto;
efi_status_t status;
if (!IS_ENABLED(CONFIG_UNACCEPTED_MEMORY))
return;
/*
* Enable unaccepted memory before calling exit boot services in order
* for the UEFI to not accept all memory on EBS.
*/
status = efi_bs_call(locate_protocol, &mem_acceptance_proto, NULL,
(void **)&proto);
if (status != EFI_SUCCESS)
return;
status = efi_call_proto(proto, allow_unaccepted_memory);
if (status != EFI_SUCCESS)
efi_err("Memory acceptance protocol failed\n");
}
static efi_char16_t *efistub_fw_vendor(void)
{
unsigned long vendor = efi_table_attr(efi_system_table, fw_vendor);
return (efi_char16_t *)vendor;
}
static const efi_char16_t apple[] = L"Apple";
static void setup_quirks(struct boot_params *boot_params)
{
if (!memcmp(efistub_fw_vendor(), apple, sizeof(apple))) {
if (IS_ENABLED(CONFIG_APPLE_PROPERTIES))
retrieve_apple_device_properties(boot_params);
apple_set_os();
}
}
static void setup_graphics(struct boot_params *boot_params)
{
struct screen_info *si = memset(&boot_params->screen_info, 0, sizeof(*si));
struct edid_info *edid = memset(&boot_params->edid_info, 0, sizeof(*edid));
efi_setup_graphics(si, edid);
}
static void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)
{
efi_bs_call(exit, handle, status, 0, NULL);
for(;;)
asm("hlt");
}
/*
* Because the x86 boot code expects to be passed a boot_params we
* need to create one ourselves (usually the bootloader would create
* one for us).
*/
static efi_status_t efi_allocate_bootparams(efi_handle_t handle,
struct boot_params **bp)
{
efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID;
struct boot_params *boot_params;
struct setup_header *hdr;
efi_status_t status;
unsigned long alloc;
char *cmdline_ptr;
status = efi_bs_call(handle_protocol, handle, &proto, (void **)&image);
if (status != EFI_SUCCESS) {
efi_err("Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
return status;
}
status = efi_allocate_pages(PARAM_SIZE, &alloc, ULONG_MAX);
if (status != EFI_SUCCESS)
return status;
boot_params = memset((void *)alloc, 0x0, PARAM_SIZE);
hdr = &boot_params->hdr;
/* Assign the setup_header fields that the kernel actually cares about */
hdr->root_flags = 1;
hdr->vid_mode = 0xffff;
hdr->type_of_loader = 0x21;
hdr->initrd_addr_max = INT_MAX;
/* Convert unicode cmdline to ascii */
cmdline_ptr = efi_convert_cmdline(image);
if (!cmdline_ptr) {
efi_free(PARAM_SIZE, alloc);
return EFI_OUT_OF_RESOURCES;
}
efi_set_u64_split((unsigned long)cmdline_ptr, &hdr->cmd_line_ptr,
&boot_params->ext_cmd_line_ptr);
*bp = boot_params;
return EFI_SUCCESS;
}
static void add_e820ext(struct boot_params *params,
struct setup_data *e820ext, u32 nr_entries)
{
struct setup_data *data;
e820ext->type = SETUP_E820_EXT;
e820ext->len = nr_entries * sizeof(struct boot_e820_entry);
e820ext->next = 0;
data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
while (data && data->next)
data = (struct setup_data *)(unsigned long)data->next;
if (data)
data->next = (unsigned long)e820ext;
else
params->hdr.setup_data = (unsigned long)e820ext;
}
static efi_status_t
setup_e820(struct boot_params *params, struct setup_data *e820ext, u32 e820ext_size)
{
struct boot_e820_entry *entry = params->e820_table;
struct efi_info *efi = ¶ms->efi_info;
struct boot_e820_entry *prev = NULL;
u32 nr_entries;
u32 nr_desc;
int i;
nr_entries = 0;
nr_desc = efi->efi_memmap_size / efi->efi_memdesc_size;
for (i = 0; i < nr_desc; i++) {
efi_memory_desc_t *d;
unsigned int e820_type = 0;
unsigned long m = efi->efi_memmap;
#ifdef CONFIG_X86_64
m |= (u64)efi->efi_memmap_hi << 32;
#endif
d = efi_memdesc_ptr(m, efi->efi_memdesc_size, i);
switch (d->type) {
case EFI_RESERVED_TYPE:
case EFI_RUNTIME_SERVICES_CODE:
case EFI_RUNTIME_SERVICES_DATA:
case EFI_MEMORY_MAPPED_IO:
case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
case EFI_PAL_CODE:
e820_type = E820_TYPE_RESERVED;
break;
case EFI_UNUSABLE_MEMORY:
e820_type = E820_TYPE_UNUSABLE;
break;
case EFI_ACPI_RECLAIM_MEMORY:
e820_type = E820_TYPE_ACPI;
break;
case EFI_LOADER_CODE:
case EFI_LOADER_DATA:
case EFI_BOOT_SERVICES_CODE:
case EFI_BOOT_SERVICES_DATA:
case EFI_CONVENTIONAL_MEMORY:
if (efi_soft_reserve_enabled() &&
(d->attribute & EFI_MEMORY_SP))
e820_type = E820_TYPE_SOFT_RESERVED;
else
e820_type = E820_TYPE_RAM;
break;
case EFI_ACPI_MEMORY_NVS:
e820_type = E820_TYPE_NVS;
break;
case EFI_PERSISTENT_MEMORY:
e820_type = E820_TYPE_PMEM;
break;
case EFI_UNACCEPTED_MEMORY:
if (!IS_ENABLED(CONFIG_UNACCEPTED_MEMORY))
continue;
e820_type = E820_TYPE_RAM;
process_unaccepted_memory(d->phys_addr,
d->phys_addr + PAGE_SIZE * d->num_pages);
break;
default:
continue;
}
/* Merge adjacent mappings */
if (prev && prev->type == e820_type &&
(prev->addr + prev->size) == d->phys_addr) {
prev->size += d->num_pages << 12;
continue;
}
if (nr_entries == ARRAY_SIZE(params->e820_table)) {
u32 need = (nr_desc - i) * sizeof(struct e820_entry) +
sizeof(struct setup_data);
if (!e820ext || e820ext_size < need)
return EFI_BUFFER_TOO_SMALL;
/* boot_params map full, switch to e820 extended */
entry = (struct boot_e820_entry *)e820ext->data;
}
entry->addr = d->phys_addr;
entry->size = d->num_pages << PAGE_SHIFT;
entry->type = e820_type;
prev = entry++;
nr_entries++;
}
if (nr_entries > ARRAY_SIZE(params->e820_table)) {
u32 nr_e820ext = nr_entries - ARRAY_SIZE(params->e820_table);
add_e820ext(params, e820ext, nr_e820ext);
nr_entries -= nr_e820ext;
}
params->e820_entries = (u8)nr_entries;
return EFI_SUCCESS;
}
static efi_status_t alloc_e820ext(u32 nr_desc, struct setup_data **e820ext,
u32 *e820ext_size)
{
efi_status_t status;
unsigned long size;
size = sizeof(struct setup_data) +
sizeof(struct e820_entry) * nr_desc;
if (*e820ext) {
efi_bs_call(free_pool, *e820ext);
*e820ext = NULL;
*e820ext_size = 0;
}
status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,
(void **)e820ext);
if (status == EFI_SUCCESS)
*e820ext_size = size;
return status;
}
static efi_status_t allocate_e820(struct boot_params *params,
struct setup_data **e820ext,
u32 *e820ext_size)
{
struct efi_boot_memmap *map __free(efi_pool) = NULL;
efi_status_t status;
__u32 nr_desc;
status = efi_get_memory_map(&map, false);
if (status != EFI_SUCCESS)
return status;
nr_desc = map->map_size / map->desc_size;
if (nr_desc > ARRAY_SIZE(params->e820_table) - EFI_MMAP_NR_SLACK_SLOTS) {
u32 nr_e820ext = nr_desc - ARRAY_SIZE(params->e820_table) +
EFI_MMAP_NR_SLACK_SLOTS;
status = alloc_e820ext(nr_e820ext, e820ext, e820ext_size);
if (status != EFI_SUCCESS)
return status;
}
if (IS_ENABLED(CONFIG_UNACCEPTED_MEMORY))
return allocate_unaccepted_bitmap(nr_desc, map);
return EFI_SUCCESS;
}
struct exit_boot_struct {
struct boot_params *boot_params;
struct efi_info *efi;
};
static efi_status_t exit_boot_func(struct efi_boot_memmap *map,
void *priv)
{
const char *signature;
struct exit_boot_struct *p = priv;
signature = efi_is_64bit() ? EFI64_LOADER_SIGNATURE
: EFI32_LOADER_SIGNATURE;
memcpy(&p->efi->efi_loader_signature, signature, sizeof(__u32));
efi_set_u64_split((unsigned long)efi_system_table,
&p->efi->efi_systab, &p->efi->efi_systab_hi);
p->efi->efi_memdesc_size = map->desc_size;
p->efi->efi_memdesc_version = map->desc_ver;
efi_set_u64_split((unsigned long)map->map,
&p->efi->efi_memmap, &p->efi->efi_memmap_hi);
p->efi->efi_memmap_size = map->map_size;
return EFI_SUCCESS;
}
static efi_status_t exit_boot(struct boot_params *boot_params, void *handle)
{
struct setup_data *e820ext = NULL;
__u32 e820ext_size = 0;
efi_status_t status;
struct exit_boot_struct priv;
priv.boot_params = boot_params;
priv.efi = &boot_params->efi_info;
status = allocate_e820(boot_params, &e820ext, &e820ext_size);
if (status != EFI_SUCCESS)
return status;
/* Might as well exit boot services now */
status = efi_exit_boot_services(handle, &priv, exit_boot_func);
if (status != EFI_SUCCESS)
return status;
/* Historic? */
boot_params->alt_mem_k = 32 * 1024;
status = setup_e820(boot_params, e820ext, e820ext_size);
if (status != EFI_SUCCESS)
return status;
return EFI_SUCCESS;
}
static bool have_unsupported_snp_features(void)
{
u64 unsupported;
unsupported = snp_get_unsupported_features(sev_get_status());
if (unsupported) {
efi_err("Unsupported SEV-SNP features detected: 0x%llx\n",
unsupported);
return true;
}
return false;
}
static void efi_get_seed(void *seed, int size)
{
efi_get_random_bytes(size, seed);
/*
* This only updates seed[0] when running on 32-bit, but in that case,
* seed[1] is not used anyway, as there is no virtual KASLR on 32-bit.
*/
*(unsigned long *)seed ^= kaslr_get_random_long("EFI");
}
static void error(char *str)
{
efi_warn("Decompression failed: %s\n", str);
}
static const char *cmdline_memmap_override;
static efi_status_t parse_options(const char *cmdline)
{
static const char opts[][14] = {
"mem=", "memmap=", "hugepages="
};
for (int i = 0; i < ARRAY_SIZE(opts); i++) {
const char *p = strstr(cmdline, opts[i]);
if (p == cmdline || (p > cmdline && isspace(p[-1]))) {
cmdline_memmap_override = opts[i];
break;
}
}
return efi_parse_options(cmdline);
}
static efi_status_t efi_decompress_kernel(unsigned long *kernel_entry,
struct boot_params *boot_params)
{
unsigned long virt_addr = LOAD_PHYSICAL_ADDR;
unsigned long addr, alloc_size, entry;
efi_status_t status;
u32 seed[2] = {};
boot_params_ptr = boot_params;
/* determine the required size of the allocation */
alloc_size = ALIGN(max_t(unsigned long, output_len, kernel_total_size),
MIN_KERNEL_ALIGN);
if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && !efi_nokaslr) {
u64 range = KERNEL_IMAGE_SIZE - LOAD_PHYSICAL_ADDR - kernel_total_size;
static const efi_char16_t ami[] = L"American Megatrends";
efi_get_seed(seed, sizeof(seed));
virt_addr += (range * seed[1]) >> 32;
virt_addr &= ~(CONFIG_PHYSICAL_ALIGN - 1);
/*
* Older Dell systems with AMI UEFI firmware v2.0 may hang
* while decompressing the kernel if physical address
* randomization is enabled.
*
* https://bugzilla.kernel.org/show_bug.cgi?id=218173
*/
if (efi_system_table->hdr.revision <= EFI_2_00_SYSTEM_TABLE_REVISION &&
!memcmp(efistub_fw_vendor(), ami, sizeof(ami))) {
efi_debug("AMI firmware v2.0 or older detected - disabling physical KASLR\n");
seed[0] = 0;
} else if (cmdline_memmap_override) {
efi_info("%s detected on the kernel command line - disabling physical KASLR\n",
cmdline_memmap_override);
seed[0] = 0;
}
boot_params->hdr.loadflags |= KASLR_FLAG;
}
status = efi_random_alloc(alloc_size, CONFIG_PHYSICAL_ALIGN, &addr,
seed[0], EFI_LOADER_CODE,
LOAD_PHYSICAL_ADDR,
EFI_X86_KERNEL_ALLOC_LIMIT);
if (status != EFI_SUCCESS)
return status;
entry = decompress_kernel((void *)addr, virt_addr, error);
if (entry == ULONG_MAX) {
efi_free(alloc_size, addr);
return EFI_LOAD_ERROR;
}
*kernel_entry = addr + entry;
return efi_adjust_memory_range_protection(addr, kernel_text_size) ?:
efi_adjust_memory_range_protection(addr + kernel_inittext_offset,
kernel_inittext_size);
}
static void __noreturn enter_kernel(unsigned long kernel_addr,
struct boot_params *boot_params)
{
/* enter decompressed kernel with boot_params pointer in RSI/ESI */
asm("jmp *%0"::"r"(kernel_addr), "S"(boot_params));
unreachable();
}
/*
* On success, this routine will jump to the relocated image directly and never
* return. On failure, it will exit to the firmware via efi_exit() instead of
* returning.
*/
void __noreturn efi_stub_entry(efi_handle_t handle,
efi_system_table_t *sys_table_arg,
struct boot_params *boot_params)
{
efi_guid_t guid = EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID;
const struct linux_efi_initrd *initrd = NULL;
unsigned long kernel_entry;
struct setup_header *hdr;
efi_status_t status;
efi_system_table = sys_table_arg;
/* Check if we were booted by the EFI firmware */
if (efi_system_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
efi_exit(handle, EFI_INVALID_PARAMETER);
if (!IS_ENABLED(CONFIG_EFI_HANDOVER_PROTOCOL) || !boot_params) {
status = efi_allocate_bootparams(handle, &boot_params);
if (status != EFI_SUCCESS)
efi_exit(handle, status);
}
hdr = &boot_params->hdr;
if (have_unsupported_snp_features())
efi_exit(handle, EFI_UNSUPPORTED);
if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
efi_dxe_table = get_efi_config_table(EFI_DXE_SERVICES_TABLE_GUID);
if (efi_dxe_table &&
efi_dxe_table->hdr.signature != EFI_DXE_SERVICES_TABLE_SIGNATURE) {
efi_warn("Ignoring DXE services table: invalid signature\n");
efi_dxe_table = NULL;
}
}
/* grab the memory attributes protocol if it exists */
efi_bs_call(locate_protocol, &guid, NULL, (void **)&memattr);
status = efi_setup_5level_paging();
if (status != EFI_SUCCESS) {
efi_err("efi_setup_5level_paging() failed!\n");
goto fail;
}
#ifdef CONFIG_CMDLINE_BOOL
status = parse_options(CONFIG_CMDLINE);
if (status != EFI_SUCCESS) {
efi_err("Failed to parse options\n");
goto fail;
}
#endif
if (!IS_ENABLED(CONFIG_CMDLINE_OVERRIDE)) {
unsigned long cmdline_paddr = ((u64)hdr->cmd_line_ptr |
((u64)boot_params->ext_cmd_line_ptr << 32));
status = parse_options((char *)cmdline_paddr);
if (status != EFI_SUCCESS) {
efi_err("Failed to parse options\n");
goto fail;
}
}
if (efi_mem_encrypt > 0)
hdr->xloadflags |= XLF_MEM_ENCRYPTION;
status = efi_decompress_kernel(&kernel_entry, boot_params);
if (status != EFI_SUCCESS) {
efi_err("Failed to decompress kernel\n");
goto fail;
}
/*
* At this point, an initrd may already have been loaded by the
* bootloader and passed via bootparams. We permit an initrd loaded
* from the LINUX_EFI_INITRD_MEDIA_GUID device path to supersede it.
*
* If the device path is not present, any command-line initrd=
* arguments will be processed only if image is not NULL, which will be
* the case only if we were loaded via the PE entry point.
*/
status = efi_load_initrd(image, hdr->initrd_addr_max, ULONG_MAX,
&initrd);
if (status != EFI_SUCCESS)
goto fail;
if (initrd && initrd->size > 0) {
efi_set_u64_split(initrd->base, &hdr->ramdisk_image,
&boot_params->ext_ramdisk_image);
efi_set_u64_split(initrd->size, &hdr->ramdisk_size,
&boot_params->ext_ramdisk_size);
}
/*
* If the boot loader gave us a value for secure_boot then we use that,
* otherwise we ask the BIOS.
*/
if (boot_params->secure_boot == efi_secureboot_mode_unset)
boot_params->secure_boot = efi_get_secureboot();
/* Ask the firmware to clear memory on unclean shutdown */
efi_enable_reset_attack_mitigation();
efi_random_get_seed();
efi_retrieve_eventlog();
setup_graphics(boot_params);
setup_efi_pci(boot_params);
setup_quirks(boot_params);
setup_unaccepted_memory();
status = exit_boot(boot_params, handle);
if (status != EFI_SUCCESS) {
efi_err("exit_boot() failed!\n");
goto fail;
}
/*
* Call the SEV init code while still running with the firmware's
* GDT/IDT, so #VC exceptions will be handled by EFI.
*/
sev_enable(boot_params);
efi_5level_switch();
enter_kernel(kernel_entry, boot_params);
fail:
efi_err("efi_stub_entry() failed!\n");
efi_exit(handle, status);
}
efi_status_t __efiapi efi_pe_entry(efi_handle_t handle,
efi_system_table_t *sys_table_arg)
{
efi_stub_entry(handle, sys_table_arg, NULL);
}
#ifdef CONFIG_EFI_HANDOVER_PROTOCOL
void efi_handover_entry(efi_handle_t handle, efi_system_table_t *sys_table_arg,
struct boot_params *boot_params)
{
memset(_bss, 0, _ebss - _bss);
efi_stub_entry(handle, sys_table_arg, boot_params);
}
#ifndef CONFIG_EFI_MIXED
extern __alias(efi_handover_entry)
void efi32_stub_entry(efi_handle_t handle, efi_system_table_t *sys_table_arg,
struct boot_params *boot_params);
extern __alias(efi_handover_entry)
void efi64_stub_entry(efi_handle_t handle, efi_system_table_t *sys_table_arg,
struct boot_params *boot_params);
#endif
#endif
]
|
| 100/2 |
2026/05/26 05:52 |
llm |
expert |
0m
Model:
Tokens:
input: 138507
output: 19
thoughts: 882
Thoughts: **Analyzing the EFI PCI ROM Image Preservation in Early Boot**
Okay, let's break this down. I'm looking at the `setup_efi_pci` function. It's calling `preserve_pci_rom_image` to grab a ROM image and place it in memory for later use. This memory, allocated with `efi_bs_call(allocate_pool, EFI_LOADER_DATA, ...)` using the EFI boot services, immediately triggers some concerns. `EFI_LOADER_DATA` is, by default, *not* reserved in the Linux kernel! That means it's treated as RAM.
I need to confirm this. Ah, yes, looking at `setup_e820`, `EFI_LOADER_DATA` is indeed mapped as `E820_TYPE_RAM` unless `efi_soft_reserve_enabled()` and `(d->attribute & EFI_MEMORY_SP)` are both true. Good. This confirms that the memory allocated for the ROM image β which includes this `setup_data` β *isn't* inherently reserved by the kernel's memory map. That's a potential problem!
But wait, I recall `memblock_x86_reserve_range_setup_data` *should* be taking care of this:
```c
memblock_reserve_kern(pa_data, sizeof(*data) + data->len);
```
This *should* reserve the right amount of memory, specifically `size`, but it is called during early boot! Am I missing something?
Okay, let me trace back how data is constructed. `data->len` is calculated as `size - sizeof(struct setup_data)`, so `memblock_reserve_kern` reserves `size`, which sounds correct... Wait. Is `memblock_reserve_kern` failing?
Ah, looking further, `early_memremap` is used to get a direct mapping to the setup data. And it seems that if `early_memremap` *fails*, the function returns, leaving the rest of the chain unreserved.
```c
data = early_memremap(pa_data, sizeof(*data));
if (!data) {
pr_warn("setup: failed to memremap setup_data entry\n");
return;
}
```
When does `early_memremap` fail? Invalid `pa_data` or no available fixmap slots. `pa_data` is valid as it comes from EFI. What about `data->next`? In the code, `next` is set to 0.
```c
memset(rom, 0, sizeof(*rom));
rom->data.type = SETUP_PCI;
rom->data.len = size - sizeof(struct setup_data);
rom->data.next = 0;
```
So what if `data->len` is huge and `memblock_reserve_kern` fails? But, `memblock_reserve_kern` doesn't fail, it only adds to the `memblock` array.
Wait, are these `setup_data` entries *ever* freed? I need to check for any deallocation calls. Let me check `arch/x86/kernel/setup.c`. That's where I need to look for a deallocation path.
|
| 101/2 |
2026/05/26 05:52 |
tool |
grepper |
0m
Args: map[Expression:free.*setup_data]
Results: map[Output:drivers/firmware/efi/apple-properties.c=175=static int __init map_properties(void)
--
drivers/firmware/efi/apple-properties.c-223- /*
drivers/firmware/efi/apple-properties.c:224: * Can only free the setup_data payload but not its header
drivers/firmware/efi/apple-properties.c-225- * to avoid breaking the chain of ->next pointers.
]
|
| 102/2 |
2026/05/26 05:52 |
llm |
expert |
1m
Model:
Tokens:
input: 140265
output: 44
thoughts: 49
Thoughts: Okay, here's my take on those thoughts, tailored for an expert audience:
**Analyzing Apple Property Handling in EFI Firmware**
Right, so `drivers/firmware/efi/apple-properties.c`... ah, that's where the `setup_data` payload is *freed*. Important. That suggests a potentially critical point for vulnerabilities related to memory management or, perhaps, data corruption if there's any mishandling before that point. I need to keep that in mind.
Let's drill down. The next logical step is to verify the `map_properties` function itself. I need to understand how it interacts with `setup_data`. Is there a use-after-free scenario waiting to happen? Are the properties properly validated before mapping? What's the allocation strategy within `map_properties`? Are there any obvious integer overflows or buffer overflows lurking in this critical code path? This whole section warrants close scrutiny to ensure data integrity and system security. I'll need to look at how these properties are created, validated, mapped, and, finally, freed in relation to this section of code.
|
| 103/2 |
2026/05/26 05:53 |
tool |
codesearch-definition-source |
0m
Error:
Args: map[ContextFile:drivers/firmware/efi/apple-properties.c IncludeLines:true Name:map_properties]
Results: map[SourceCode: SourceFile:]
|
| 104/2 |
2026/05/26 05:53 |
llm |
expert |
0m
Model:
Tokens:
input: 140616
output: 17
thoughts: 15
Thoughts: Here's my thought process, as if I were thinking it:
**Using Grepper for Efficient Code Exploration**
Okay, so I need to find where this `map_properties` function is used within this codebase. I could manually grep the entire directory, but that feels clunky and inefficient, especially with a project of this size. I'd rather refine my search quickly and get a precise result. Grepping is great, but let's be more surgical about it. Let's fire up `grepper`. That should allow me to pinpoint the exact locations I'm looking for and quickly navigate through the results. I expect it'll give me a much cleaner and more manageable view than a standard grep search, allowing me to focus directly on the relevant context. Efficiency is key here, I don't want to waste time sifting through irrelevant files.
|
| 105/2 |
2026/05/26 05:53 |
tool |
grepper |
0m
Args: map[Expression:map_properties]
Results: map[Output:drivers/firmware/efi/apple-properties.c=118=static int __init unmarshal_devices(struct properties_header *properties)
--
drivers/firmware/efi/apple-properties.c-174-
drivers/firmware/efi/apple-properties.c:175:static int __init map_properties(void)
drivers/firmware/efi/apple-properties.c-176-{
--
drivers/firmware/efi/apple-properties.c-235-
drivers/firmware/efi/apple-properties.c:236:fs_initcall(map_properties);
]
|
| 106/2 |
2026/05/26 05:53 |
llm |
expert |
0m
Model:
Tokens:
input: 140986
output: 27
thoughts: 18
Thoughts: Okay, let's dive in.
**Initial Examination of apple-properties.c**
Alright, time to get into the nitty-gritty. I see we're looking at `drivers/firmware/efi/apple-properties.c`. I expect this is where the core logic for handling Apple-specific firmware properties within the EFI environment resides. Given the file name, itβs highly likely we'll find code for reading, writing, and potentially interpreting NVRAM variables related to Apple hardware. I'm anticipating the use of EFI runtime services calls for accessing these properties, likely dealing with GUIDs and specific variable names that Apple uses. I'm curious to see how they handle potential quirks or inconsistencies across different Apple hardware generations and firmware revisions. I'm also interested in how error handling is implemented β robustness is key in firmware, especially when dealing with hardware-specific configuration. Let's see how well it's written and if there are any interesting optimizations or design choices to consider for our own projects.
|
| 107/2 |
2026/05/26 05:53 |
tool |
read-file |
0m
Args: map[File:drivers/firmware/efi/apple-properties.c]
Results: map[Contents:// SPDX-License-Identifier: GPL-2.0
/*
* apple-properties.c - EFI device properties on Macs
* Copyright (C) 2016 Lukas Wunner <lukas@wunner.de>
*
* Properties are stored either as:
* u8 arrays which can be retrieved with device_property_read_u8_array() or
* booleans which can be queried with device_property_present().
*/
#define pr_fmt(fmt) "apple-properties: " fmt
#include <linux/memblock.h>
#include <linux/efi.h>
#include <linux/io.h>
#include <linux/platform_data/x86/apple.h>
#include <linux/property.h>
#include <linux/slab.h>
#include <linux/ucs2_string.h>
#include <asm/setup.h>
static bool dump_properties __initdata;
static int __init dump_properties_enable(char *arg)
{
dump_properties = true;
return 1;
}
__setup("dump_apple_properties", dump_properties_enable);
struct dev_header {
u32 len;
u32 prop_count;
struct efi_dev_path path[];
/*
* followed by key/value pairs, each key and value preceded by u32 len,
* len includes itself, value may be empty (in which case its len is 4)
*/
};
struct properties_header {
u32 len;
u32 version;
u32 dev_count;
struct dev_header dev_header[];
};
static void __init unmarshal_key_value_pairs(struct dev_header *dev_header,
struct device *dev, const void *ptr,
struct property_entry entry[])
{
int i;
for (i = 0; i < dev_header->prop_count; i++) {
int remaining = dev_header->len - (ptr - (void *)dev_header);
u32 key_len, val_len, entry_len;
const u8 *entry_data;
char *key;
if (sizeof(key_len) > remaining)
break;
key_len = *(typeof(key_len) *)ptr;
if (key_len + sizeof(val_len) > remaining ||
key_len < sizeof(key_len) + sizeof(efi_char16_t) ||
*(efi_char16_t *)(ptr + sizeof(key_len)) == 0) {
dev_err(dev, "invalid property name len at %#zx\n",
ptr - (void *)dev_header);
break;
}
val_len = *(typeof(val_len) *)(ptr + key_len);
if (key_len + val_len > remaining ||
val_len < sizeof(val_len)) {
dev_err(dev, "invalid property val len at %#zx\n",
ptr - (void *)dev_header + key_len);
break;
}
/* 4 bytes to accommodate UTF-8 code points + null byte */
key = kzalloc((key_len - sizeof(key_len)) * 4 + 1, GFP_KERNEL);
if (!key) {
dev_err(dev, "cannot allocate property name\n");
break;
}
ucs2_as_utf8(key, ptr + sizeof(key_len),
key_len - sizeof(key_len));
entry_data = ptr + key_len + sizeof(val_len);
entry_len = val_len - sizeof(val_len);
if (entry_len)
entry[i] = PROPERTY_ENTRY_U8_ARRAY_LEN(key, entry_data,
entry_len);
else
entry[i] = PROPERTY_ENTRY_BOOL(key);
if (dump_properties) {
dev_info(dev, "property: %s\n", key);
print_hex_dump(KERN_INFO, pr_fmt(), DUMP_PREFIX_OFFSET,
16, 1, entry_data, entry_len, true);
}
ptr += key_len + val_len;
}
if (i != dev_header->prop_count) {
dev_err(dev, "got %d device properties, expected %u\n", i,
dev_header->prop_count);
print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
16, 1, dev_header, dev_header->len, true);
return;
}
dev_info(dev, "assigning %d device properties\n", i);
}
static int __init unmarshal_devices(struct properties_header *properties)
{
size_t offset = offsetof(struct properties_header, dev_header[0]);
while (offset + sizeof(struct dev_header) < properties->len) {
struct dev_header *dev_header = (void *)properties + offset;
struct property_entry *entry = NULL;
const struct efi_dev_path *ptr;
struct device *dev;
size_t len;
int ret, i;
if (offset + dev_header->len > properties->len ||
dev_header->len <= sizeof(*dev_header)) {
pr_err("invalid len in dev_header at %#zx\n", offset);
return -EINVAL;
}
ptr = dev_header->path;
len = dev_header->len - sizeof(*dev_header);
dev = efi_get_device_by_path(&ptr, &len);
if (IS_ERR(dev)) {
pr_err("device path parse error %ld at %#zx:\n",
PTR_ERR(dev), (void *)ptr - (void *)dev_header);
print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
16, 1, dev_header, dev_header->len, true);
dev = NULL;
goto skip_device;
}
entry = kzalloc_objs(*entry, dev_header->prop_count + 1);
if (!entry) {
dev_err(dev, "cannot allocate properties\n");
goto skip_device;
}
unmarshal_key_value_pairs(dev_header, dev, ptr, entry);
if (!entry[0].name)
goto skip_device;
ret = device_create_managed_software_node(dev, entry, NULL);
if (ret)
dev_err(dev, "error %d assigning properties\n", ret);
for (i = 0; entry[i].name; i++)
kfree(entry[i].name);
skip_device:
kfree(entry);
put_device(dev);
offset += dev_header->len;
}
return 0;
}
static int __init map_properties(void)
{
struct properties_header *properties;
struct setup_data *data;
u32 data_len;
u64 pa_data;
int ret;
if (!x86_apple_machine)
return 0;
pa_data = boot_params.hdr.setup_data;
while (pa_data) {
data = memremap(pa_data, sizeof(*data), MEMREMAP_WB);
if (!data) {
pr_err("cannot map setup_data header\n");
return -ENOMEM;
}
if (data->type != SETUP_APPLE_PROPERTIES) {
pa_data = data->next;
memunmap(data);
continue;
}
data_len = data->len;
memunmap(data);
data = memremap(pa_data, sizeof(*data) + data_len, MEMREMAP_WB);
if (!data) {
pr_err("cannot map setup_data payload\n");
return -ENOMEM;
}
properties = (struct properties_header *)data->data;
if (properties->version != 1) {
pr_err("unsupported version:\n");
print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
16, 1, properties, data_len, true);
ret = -ENOTSUPP;
} else if (properties->len != data_len) {
pr_err("length mismatch, expected %u\n", data_len);
print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
16, 1, properties, data_len, true);
ret = -EINVAL;
} else
ret = unmarshal_devices(properties);
/*
* Can only free the setup_data payload but not its header
* to avoid breaking the chain of ->next pointers.
*/
data->len = 0;
memunmap(data);
memblock_free_late(pa_data + sizeof(*data), data_len);
return ret;
}
return 0;
}
fs_initcall(map_properties);
]
|
| 108/2 |
2026/05/26 05:53 |
llm |
expert |
0m
Model:
Tokens:
input: 143508
output: 22
thoughts: 117
Thoughts: **Analyzing the SETUP_APPLE_PROPERTIES Memory Management**
Okay, here's what's running through my head. I'm looking at this `map_properties` function, and it's calling `memblock_free_late(pa_data + sizeof(*data), data_len)`. Right, that's freeing the actual payload associated with `SETUP_APPLE_PROPERTIES`. But hold on... it's *not* freeing the header itself. And what's worse, it's setting `data->len` to zero. So the `next` pointer within that header should still be valid, at least as far as the memory goes.
That seems like a potential problem. If the header isn't freed and the `next` pointer is still somehow used, we could have a memory leak or even a use-after-free situation. I need to be sure that the header is taken care of! I need to know if something else is responsible for handling it, but the `next` pointer gives me pause. Is there any other code path that will free `setup_data`?
I need to quickly scan the code for any other `memblock_free_late` or `memblock_free` calls related to `setup_data` to ensure a consistent memory management strategy for this structure. I need to be sure the header is accounted for, and that there aren't conflicting attempts to free the same memory block.
|
| 109/2 |
2026/05/26 05:53 |
tool |
grepper |
0m
Error:
Args: map[Expression:memblock_free.*setup_data]
Results:
|
| 110/2 |
2026/05/26 05:53 |
llm |
expert |
0m
Model:
Tokens:
input: 143966
output: 48
thoughts: 968
Thoughts: **Debugging a Bootloader-Induced Kernel Panic**
Okay, so I'm looking at this crash in `ioremap` and the invalid physical address is screaming "bootloader issue" to me. I'm thinking, this `setup_data` field within `boot_params` seems like the likely culprit, especially considering `memblock_x86_reserve_range_setup_data` *should* be called, and it *is* called from `early_reserve_memory`. My first thought was maybe syzkaller was messing with `setup_data`. But the `boot_params` sysfs entry is read-only, so that's a dead end. Okay, could `/dev/mem` be the issue? Syzkaller *could* write to that, if it has root, but that's not its typical behavior unless it's intentionally fuzzing it, and it's not a kernel bug if that's the case.
But then I see it: the `ioremap` crash, and that *awful* address, `4ff4208dd89fe53e`. That's pointing directly at `boot_params.hdr.setup_data` being garbage. Going back to the `pcibios_device_add` function, and seeing the `memremap` call with that bad address just confirms it. If `setup_data` *is* this value, it means the bootloader gave us garbage, I'm now thinking, "VM Guest Trigger." Syzkaller can, and often *does*, act as a VMM, using `/dev/kvm`, and that's it!
So syzkaller boots a guest kernel with a corrupted `boot_params`, and that's what's triggering the crash. Wait, though, why didn't the kernel warn about it during boot? If it were garbage, it should have.
Hold on, I see something else. The crash happens during `dev_rescan_store`, meaning this isn't just a generic boot issue. It has to be related to a *specific* device rescan! If a device rescan is happening, a PCI device *must* exist. The stack trace shows `dev_rescan_store`, which means we aren't just rescanning the whole PCI bus (which would trigger the usual warning), but specifically a device. So, the kernel must have added a device.
If it was added during boot, `pcibios_device_add` would have been called then, and, again, it *should* have warned during boot. I need to re-examine that function...
|
| 111/2 |
2026/05/26 05:54 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/pci/common.c IncludeLines:true Name:pcibios_device_add]
Results: map[SourceCode: 643: int pcibios_device_add(struct pci_dev *dev)
644: {
645: struct pci_setup_rom *rom;
646: struct irq_domain *msidom;
647: struct setup_data *data;
648: u64 pa_data;
649:
650: pa_data = boot_params.hdr.setup_data;
651: while (pa_data) {
652: data = memremap(pa_data, sizeof(*rom), MEMREMAP_WB);
653: if (!data)
654: return -ENOMEM;
655:
656: if (data->type == SETUP_PCI) {
657: rom = (struct pci_setup_rom *)data;
658:
659: if ((pci_domain_nr(dev->bus) == rom->segment) &&
660: (dev->bus->number == rom->bus) &&
661: (PCI_SLOT(dev->devfn) == rom->device) &&
662: (PCI_FUNC(dev->devfn) == rom->function) &&
663: (dev->vendor == rom->vendor) &&
664: (dev->device == rom->devid)) {
665: dev->rom = pa_data +
666: offsetof(struct pci_setup_rom, romdata);
667: dev->romlen = rom->pcilen;
668: }
669: }
670: pa_data = data->next;
671: memunmap(data);
672: }
673: set_dev_domain_options(dev);
674:
675: /*
676: * Setup the initial MSI domain of the device. If the underlying
677: * bus has a PCI/MSI irqdomain associated use the bus domain,
678: * otherwise set the default domain. This ensures that special irq
679: * domains e.g. VMD are preserved. The default ensures initial
680: * operation if irq remapping is not active. If irq remapping is
681: * active it will overwrite the domain pointer when the device is
682: * associated to a remapping domain.
683: */
684: msidom = dev_get_msi_domain(&dev->bus->dev);
685: if (!msidom)
686: msidom = x86_pci_msi_default_domain;
687: dev_set_msi_domain(&dev->dev, msidom);
688: return 0;
689: }
SourceFile:arch/x86/pci/common.c]
|
| 112/2 |
2026/05/26 05:54 |
llm |
expert |
0m
Model:
Tokens:
input: 146344
output: 39
thoughts: 106
Thoughts: **Investigating `pcibios_device_add` and Memory Remapping**
Okay, so `pcibios_device_add` calls `memremap(pa_data, sizeof(*rom), MEMREMAP_WB)`. My immediate concern is the potential for an invalid physical address (`pa_data`). If that happens, `memremap` is supposed to fall back to `arch_memremap_wb`, which in turn calls `ioremap_cache` and triggers a warning. But... is it *guaranteed* that `memremap` *always* goes through `arch_memremap_wb` in this scenario, especially during the boot process? I need to clarify that. I'm going to re-examine the `memremap` function itself to be absolutely sure about the execution path. Let's dig back into the code.
|
| 113/2 |
2026/05/26 05:54 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:kernel/iomem.c IncludeLines:true Name:memremap]
Results: map[SourceCode: 41: /**
42: * memremap() - remap an iomem_resource as cacheable memory
43: * @offset: iomem resource start address
44: * @size: size of remap
45: * @flags: any of MEMREMAP_WB, MEMREMAP_WT, MEMREMAP_WC,
46: * MEMREMAP_ENC, MEMREMAP_DEC
47: *
48: * memremap() is "ioremap" for cases where it is known that the resource
49: * being mapped does not have i/o side effects and the __iomem
50: * annotation is not applicable. In the case of multiple flags, the different
51: * mapping types will be attempted in the order listed below until one of
52: * them succeeds.
53: *
54: * MEMREMAP_WB - matches the default mapping for System RAM on
55: * the architecture. This is usually a read-allocate write-back cache.
56: * Moreover, if MEMREMAP_WB is specified and the requested remap region is RAM
57: * memremap() will bypass establishing a new mapping and instead return
58: * a pointer into the direct map.
59: *
60: * MEMREMAP_WT - establish a mapping whereby writes either bypass the
61: * cache or are written through to memory and never exist in a
62: * cache-dirty state with respect to program visibility. Attempts to
63: * map System RAM with this mapping type will fail.
64: *
65: * MEMREMAP_WC - establish a writecombine mapping, whereby writes may
66: * be coalesced together (e.g. in the CPU's write buffers), but is otherwise
67: * uncached. Attempts to map System RAM with this mapping type will fail.
68: */
69: void *memremap(resource_size_t offset, size_t size, unsigned long flags)
70: {
71: int is_ram = region_intersects(offset, size,
72: IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE);
73: void *addr = NULL;
74:
75: if (!flags)
76: return NULL;
77:
78: if (is_ram == REGION_MIXED) {
79: WARN_ONCE(1, "memremap attempted on mixed range %pa size: %#lx\n",
80: &offset, (unsigned long) size);
81: return NULL;
82: }
83:
84: /* Try all mapping types requested until one returns non-NULL */
85: if (flags & MEMREMAP_WB) {
86: /*
87: * MEMREMAP_WB is special in that it can be satisfied
88: * from the direct map. Some archs depend on the
89: * capability of memremap() to autodetect cases where
90: * the requested range is potentially in System RAM.
91: */
92: if (is_ram == REGION_INTERSECTS)
93: addr = try_ram_remap(offset, size, flags);
94: if (!addr)
95: addr = arch_memremap_wb(offset, size, flags);
96: }
97:
98: /*
99: * If we don't have a mapping yet and other request flags are
100: * present then we will be attempting to establish a new virtual
101: * address mapping. Enforce that this mapping is not aliasing
102: * System RAM.
103: */
104: if (!addr && is_ram == REGION_INTERSECTS && flags != MEMREMAP_WB) {
105: WARN_ONCE(1, "memremap attempted on ram %pa size: %#lx\n",
106: &offset, (unsigned long) size);
107: return NULL;
108: }
109:
110: if (!addr && (flags & MEMREMAP_WT))
111: addr = ioremap_wt(offset, size);
112:
113: if (!addr && (flags & MEMREMAP_WC))
114: addr = ioremap_wc(offset, size);
115:
116: return addr;
117: }
SourceFile:kernel/iomem.c]
|
| 114/2 |
2026/05/26 05:54 |
llm |
expert |
0m
Model:
Tokens:
input: 147912
output: 45
thoughts: 3425
Thoughts: **Analyzing a PCI Device Rescan Warning**
Okay, here's the breakdown of my thinking. The code checks for RAM intersections, remaps memory, and eventually hits a `WARN_ON_ONCE` because an invalid physical address is encountered. This address, `4ff4208dd89fe53e`, is clearly out of bounds for standard x86 systems. If this happens, it means we have to dive into what's being mapped and *why*. I initially ruled out simple memory corruption during the boot process because that address shouldn't have been valid in the first place, or the warning would've triggered then.
The `setup_data` from `boot_params` becomes a key area for analysis, and a pointer for the memory that is to be mapped. The core logic of the problem revolves around the fact that if a PCI device has its rescan command called, it attempts to access setup data in `pcibios_device_add`. The crucial point is that `boot_params` is available via `/sys/kernel/boot_params/data` in read-only mode and not easily modifiable.
The suspicion shifts towards post-boot modification. I ruled out direct modification by looking at kexec, which would trigger separate conditions. I then went down the rabbit hole, and the fact that `data->next` can be overwritten in the scenario where the PCI bus is rescanned with a pre-existing device. The fact the bootloader can place `setup_data` inside the initrd, which is later freed via `free_initrd_mem`, is the key. The function call `free_reserved_area` is able to free the memory regardless of its other reservations. The warning is triggered when the system is rescanned, because the memory pointed to by `boot_params` is now garbage.
My analysis went from this to the idea that a VM Guest Trigger bug is possible where the bootloader provided a malformed memory layout, putting `setup_data` inside `initrd`. This memory is later freed, and when the PCI bus is rescanned, an invalid physical address is encountered. This is strengthened by the fact that the warning is NOT triggered during boot.
I then went through several scenarios to make sure that another explanation was impossible. I checked to make sure that the system was not always invalid, because the warning would have been triggered during boot. I considered ways `data->next` could have been corrupted, by checking if the PCI device exists or not. The final conclusion is that the freed memory hypothesis best explains this bug. It appears that the VMM in this scenario, placed the setup data inside the initrd, which means there is a systematic bug. The error is then triggered when the PCI device is rescanned, pointing to the garbage value in the freed memory.
One last possibility is considered, is the warning actually triggered during boot. In reality, `boot_cpu_data.x86_phys_bits` is always false, and if `pcibios_device_add` does not occur during boot, the only likely scenario is the VMM hotplugging a device. The final conclusion, is that this is a VM guest trigger, where the VMM provided an invalid memory layout.
|
| 115/2 |
2026/05/26 05:54 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:drivers/pci/probe.c IncludeLines:true Name:pci_scan_single_device]
Results: map[SourceCode:2778: struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn)
2779: {
2780: struct pci_dev *dev;
2781:
2782: dev = pci_get_slot(bus, devfn);
2783: if (dev) {
2784: pci_dev_put(dev);
2785: return dev;
2786: }
2787:
2788: dev = pci_scan_device(bus, devfn);
2789: if (!dev)
2790: return NULL;
2791:
2792: pci_device_add(dev, bus);
2793:
2794: return dev;
2795: }
SourceFile:drivers/pci/probe.c]
|
| 116/2 |
2026/05/26 05:54 |
llm |
expert |
1m
Model:
Tokens:
input: 152324
output: 46
thoughts: 7180
Thoughts: **Analysis of `ioremap: invalid physical address` Warning During PCI Rescan**
Okay, so here's the thought process: I'm looking at this kernel warning, triggered during a PCI rescan after boot, and it points to a problem with `boot_params.hdr.setup_data`. If the device already exists, we get the device structure from `pci_get_slot` without needing to add it. If we need to add a *new* device, then `pci_device_add` is called. So, the fact `pci_device_add` gets called during a rescan (`dev_rescan_store`) is key β it means a new device was *found* after the initial boot. That's either because the VMM hotplugged something, or, more interestingly, because syzkaller removed and then re-detected the device through a rescan. And, yes, syzkaller *can* remove PCI devices via `/sys/bus/pci/devices/.../remove`, and then trigger a rescan.
The sequence: boot, PCI device added, some memory freed (like initrd), syzkaller removes the device, syzkaller rescans, the device is found again, `pci_device_add` gets called, and then `pcibios_device_add` gets called. `pcibios_device_add` reads from `boot_params.hdr.setup_data`, but now the memory has been clobbered!
This means the warning is due to invalid `data->next` pointer because of corrupted memory. It reads `data->next`, which points to a garbage address, and then tries to map it, which fails. This happens only after boot because that's when the memory has been freed and overwritten.
So, the critical piece here is that `setup_data` *has* to be in memory that is freed after boot (like `initrd`).
Now, who controls this memory layout? The bootloader/VMM. If it places `setup_data` inside `initrd`, it's bad. But `memblock_x86_reserve_range_setup_data` *should* reserve `setup_data` memory, but `free_initrd_mem` doesn't care about the memblock reservation and just frees the pages, causing this to happen. The boot protocol says `setup_data` can be anywhere, but it shouldn't overlap with stuff like `initrd`. So, if they *do* overlap, it's a bootloader bug. Syzkaller's guest fuzzing doesn't control the bootloader. It's the infrastructure (QEMU/crosvm). If QEMU puts things in initrd in a wrong way, then it's a QEMU/Crosvm bug.
What about `setup_data` *not* in `initrd`? Is there some other memory that's freed after boot? `free_initmem()` frees the `.init` section - but that's unlikely to have `setup_data`. Also `setup_efi_pci` calls `efi_bs_call(allocate_pool`, which allocates memory from the kernel buddy allocator, which is protected. However, if this region is not reserved by `memblock`, and the kernel allocates the same memory region for something else, then the kernel will overwrite this memory as well. However, this is not the case since `memblock_reserve` *does* protect it!
But what if the `memblock_x86_reserve_range_setup_data` fails to reserve it? That would be very weird, as it is called very early in the boot.
The problem is that `setup_data` is modified.
Is there any other place to look for that might be freeing the memory? `kexec` doesn't free the memory, just reads it.
Okay, let's think about the boot sequence. It looks like the warning *should* be there, but why don't we see it? If the stack trace during boot is different from `dev_rescan_store`, then the `WARN_ON_ONCE` will suppress the boot-time warning, and the rescan warning will be printed. It seems that `phys_addr_valid` *should* fail at boot too. Unless, during boot, `try_ram_remap` succeeds which is unlikely in this case, but let's check.
During boot, the kernel considers the garbage address as valid RAM and maps it during boot, and *then* after boot when this memory is overwritten, `dev_rescan_store` fails.
So, during boot, `data->next` was a valid address. The initial memory was not corrupted. After boot, that memory
|
| 117/2 |
2026/05/26 05:55 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:arch/x86/mm/init.c IncludeLines:true Name:free_initrd_mem]
Results: map[SourceCode: 984: void __init free_initrd_mem(unsigned long start, unsigned long end)
985: {
986: /*
987: * end could be not aligned, and We can not align that,
988: * decompressor could be confused by aligned initrd_end
989: * We already reserve the end partial page before in
990: * - i386_start_kernel()
991: * - x86_64_start_kernel()
992: * - relocate_initrd()
993: * So here We can do PAGE_ALIGN() safely to get partial page to be freed
994: */
995: free_init_pages("initrd", start, PAGE_ALIGN(end));
996: }
SourceFile:arch/x86/mm/init.c]
|
| 118/2 |
2026/05/26 05:55 |
llm |
expert |
0m
Model:
Tokens:
input: 160828
output: 43
thoughts: 1112
Thoughts: **Analyzing a Kernel Bug: A Deep Dive**
Okay, let's break this down. It looks like we've got a potential memory corruption issue triggered during a PCI rescan, and the warning message is the clue. The core concern here is the `free_initrd_mem` function, specifically how it interacts with the placement of `setup_data`.
My initial thought is that if the bootloader places `setup_data` immediately after the `initrd`, and `free_initrd_mem` frees up to `PAGE_ALIGN(end)`, then the page containing `setup_data` could get inadvertently freed and put back into the buddy allocator. If that memory is subsequently reallocated and overwritten, then the garbage data could trigger the problem. When a PCI rescan happens, specifically during `pcibios_device_add`, the corrupted `setup_data` gets read, yielding a bogus `next` pointer and the warning. This screams "classic memory corruption" to me, a textbook scenario.
So, the likely trigger is: a bootloader (like QEMU) placing `setup_data` close to `initrd`, followed by the kernel freeing the `initrd` and accidentally freeing `setup_data` too. Because the PCI rescan is the ultimate trigger, it needs root privileges. It's certainly a VM Guest Trigger, because QEMU is a VMM in this situation.
It's not a denial-of-service in the traditional sense, as it doesn't crash the system. It's more of a localized issue β corruption of `setup_data` potentially causing issues for later code that expects valid data. I would classify it as non-exploitable as it just generates a warning.
Now, let's explore other ways this might be happening. Can any unprivileged user initiate a PCI rescan? No, and definitely not from within a user namespace. The sysfs PCI files are owned by root, ruling out unprivileged user attacks.
What if Syzkaller, instead of a bootloader issue, is using something like `kexec` to load a kernel? If it placed `setup_data` right next to the `initrd` in that scenario... yes, it could. And if syzkaller uses `kexec_load`, it runs as root anyway. This bears further investigation.
Let's look closely at that error message again: `ioremap: invalid physical address 4ff4208dd89fe53e`. That garbage address is the smoking gun! Since the rescan requires root, we can consider this either a VM Guest trigger (if QEMU is doing this) or a root-only bug. It's still not exploitable and not a DOS; just a warning.
Wait, is there a Malicious Filesystem trigger? No, because it's a PCI rescan. The clue to the solution is found in the peripheral triggers.
Could this be a Peripheral Trigger? Specifically, does plugging in a USB device trigger a PCI rescan? No. USB devices trigger USB enumeration. But wait... what about Thunderbolt or USB4 devices? They *do* appear as PCI devices. When you plug one in, the Thunderbolt controller triggers a PCI hotplug event, and a PCI bus rescan is then performed by calling `pci_device_add`. If `setup_data` *is* corrupted by the `initrd` issue, then a Thunderbolt device hotplug event could expose the bug, triggering `pcibios_device_add` and the warning! This is promising. Peripheral Trigger: TRUE.
Now, is this a Denial of Service? If `pcibios_device_add` fails (returns `-ENOMEM` or crashes), the new PCI device isn't added. Does this represent a DoS? It *prevents* the Thunderbolt device from working, but the system itself doesn't crash. It's a localized failure. I'm going to lean towards FALSE for DoS.
Let's confirm how `pcibios_device_add` fails:
```c
pa_data = boot_params.hdr.setup_data;
while (pa_data) {
data = memremap(pa_data, sizeof(*rom), MEMREMAP_WB);
if (!data)
return -ENOMEM;
```
If `memremap` returns `NULL` (due to the corrupted address), then `pcibios_device_add` *will* return `-ENOMEM`. Therefore `pci_device_add` will see the error. And we've got our confirmed trigger: a Peripheral Trigger that fails the device's addition.
|
| 119/2 |
2026/05/26 05:56 |
tool |
codesearch-definition-source |
0m
Args: map[ContextFile:drivers/pci/probe.c IncludeLines:true Name:pci_device_add]
Results: map[SourceCode:2726: void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
2727: {
2728: int ret;
2729:
2730: pci_configure_device(dev);
2731:
2732: device_initialize(&dev->dev);
2733: dev->dev.release = pci_release_dev;
2734:
2735: set_dev_node(&dev->dev, pcibus_to_node(bus));
2736: dev->dev.dma_mask = &dev->dma_mask;
2737: dev->dev.dma_parms = &dev->dma_parms;
2738: dev->dev.coherent_dma_mask = 0xffffffffull;
2739:
2740: dma_set_max_seg_size(&dev->dev, 65536);
2741: dma_set_seg_boundary(&dev->dev, 0xffffffff);
2742:
2743: pcie_failed_link_retrain(dev);
2744:
2745: /* Fix up broken headers */
2746: pci_fixup_device(pci_fixup_header, dev);
2747:
2748: pci_reassigndev_resource_alignment(dev);
2749:
2750: pci_init_capabilities(dev);
2751:
2752: /*
2753: * Add the device to our list of discovered devices
2754: * and the bus list for fixup functions, etc.
2755: */
2756: down_write(&pci_bus_sem);
2757: list_add_tail(&dev->bus_list, &bus->devices);
2758: up_write(&pci_bus_sem);
2759:
2760: ret = pcibios_device_add(dev);
2761: WARN_ON(ret < 0);
2762:
2763: /* Set up MSI IRQ domain */
2764: pci_set_msi_domain(dev);
2765:
2766: /* Notifier could use PCI capabilities */
2767: ret = device_add(&dev->dev);
2768: WARN_ON(ret < 0);
2769:
2770: /* Establish pdev->tsm for newly added (e.g. new SR-IOV VFs) */
2771: pci_tsm_init(dev);
2772:
2773: pci_npem_create(dev);
2774:
2775: pci_doe_sysfs_init(dev);
2776: }
SourceFile:drivers/pci/probe.c]
|
| 120/2 |
2026/05/26 05:56 |
llm |
expert |
0m
Model:
Tokens:
input: 163796
output: 25
thoughts: 1260
Thoughts: **My Analysis of the PCI Device Warning**
Okay, let's break this down. First, `pci_device_add` has a `WARN_ON(ret < 0)`. That's an interesting starting point. It means the code is *designed* to warn if something goes wrong, but it doesn't halt. It continues with `device_add`, so the device *is* added, even if the ROM isn't properly initialized through `setup_data`, and potentially the MSI domain isn't set up correctly. If the MSI domain isn't right, the device *might* malfunction, but it won't crash the system immediately.
The core question is, can this be a VM Host Trigger? It hinges on `setup_data`. If a host provides a malformed `setup_data` to a guest, especially in a confidential computing scenario, could this warning be triggered? The answer seems to be yes, *because* the host controls `setup_data` in a confidential computing environment. A maliciously crafted `setup_data`, with an invalid physical address in it, can absolutely trigger this warning *during boot* when `pcibios_device_add` is called. That's a definite VM Host Trigger: TRUE. This is also confirmed by a `syzkaller` bug report, triggered by writing to sysfs. It can also be triggered if the `setup_data` overlaps with `initrd`, and during a PCI rescan. The host can provide an invalid physical address in `setup_data->next`, and the warning will be triggered. So, host can definitely trigger this warning in the guest. This is a potential bug because host-triggerable warnings are considered bugs in CC guests. So, VM Host Trigger = TRUE.
Now, what about VM Guest Trigger? Can a guest somehow manipulate the host? No. `setup_data` is, in essence, either guest-internal or host-internal. The guest cannot modify the host's setup data. That makes VM Guest Trigger: FALSE. Specifically, the definition of VM Guest Trigger is a bug in the HOST, but the bug in question is in the GUEST.
Is it exploitable? It is just a `WARN_ON_ONCE` on an invalid physical address. `memremap` returns `NULL`, and the code handles this by returning `-ENOMEM`, so there's no memory corruption, no use-after-free, no out-of-bounds access. It's just a warning. This makes Exploitable: FALSE.
Is it a Denial of Service? A warning isn't a DoS unless `panic_on_warn` is set, and in production, it usually isn't. The device might not initialize properly, but the system remains running. So, Denial of Service: FALSE.
Is it accessible from unprivileged processes? Triggering the bug via sysfs requires root or `CAP_SYS_ADMIN`. So, Unprivileged: FALSE.
Is it accessible from user namespaces? Sysfs PCI files are owned by global root; a user namespace root can't touch them. This makes UserNamespace: FALSE.
It's not an Ethernet Network Trigger or any Other Remote Trigger, so those are both FALSE.
What about a Peripheral Trigger? Ah, here's where it gets interesting. Plugging in a Thunderbolt device, for example, triggers PCI hotplug, which calls `pci_device_add`, which then calls `pcibios_device_add`. If the `setup_data` is corrupted (think that `initrd` overlap bug), *that* would trigger the warning. That makes Peripheral Trigger: TRUE.
Finally, it's not a Malicious Filesystem Trigger, so FALSE. Now, to make sure, let's verify if `initrd` overlap is a known bug. There was a known issue, which confirms this trigger.
|
| 121/2 |
2026/05/26 05:56 |
tool |
git-log |
0m
Args: map[MessageRegexps:[setup_data initrd]]
Results:
|
| 122/2 |
2026/05/26 05:57 |
llm |
expert |
0m
Model:
Tokens:
input: 165915
output: 25
thoughts: 14
Thoughts: Okay, here's my summarized thought process, presented as if I'm thinking it:
**Digging into the Data Setup**
Alright, I need to understand how this data is being prepared or configured. Given my experience, the term "setup_data" feels like a likely key function or script name related to this. So, my immediate thought is to delve into the project's Git history. The quickest way to get a handle on this is to use `git log` and see if I can pinpoint any commits where "setup_data" is mentioned. This should give me a chronological view of how the functionality evolved, who worked on it, and possibly link me to related files or documentation. Let's see what that search turns up. This log search is a good starting point to quickly understand the context around this potentially critical piece of the workflow.
|
| 123/2 |
2026/05/26 05:57 |
tool |
git-log |
0m
Args: map[Count:10 MessageRegexps:[setup_data]]
Results: map[Output:b9e2f58ffb84 alloc_tag: mark inaccurate allocation counters in /proc/allocinfo output
f367474b5884 x86/kexec: carry forward the boot DTB on kexec
fd779eac2d65 mtd: nand: raw: atmel: Respect tAR, tCLR in read setup timing
1f69220b0998 mmc: mmc_spi: remove unnecessary check in mmc_spi_setup_data_message()
a8ebb70447f8 x86/boot: make sure KASLR does not step over KHO preserved memory
a2498e5c453b x86/kexec: Export e820_table_kexec[] to sysfs
efe659ac0146 x86/e820: Drop obsolete E820_TYPE_RESERVED_KERN and related code
525077ae7145 x86/ioremap: Remove unused size parameter in remapping functions
095ac6fa1950 x86/ioremap: Simplify setup_data mapping variants
8d9ffb2fe65a x86/mm: Fix a kdump kernel failure on SME system when CONFIG_IMA_KEXEC=y
]
|
| 124/2 |
2026/05/26 05:57 |
llm |
expert |
0m
Model:
Tokens:
input: 166454
output: 25
thoughts: 29
Thoughts: Here's my take on those thoughts, tailored for an expert audience:
**Analyzing the ioremap Simplification**
Alright, let's dive into that `095ac6fa1950` commit regarding `x86/ioremap: Simplify setup_data mapping variants`. I'm curious to see how they've streamlined the setup of these data mappings. Knowing the potential for subtle bugs in memory management, especially within the context of `ioremap`, I'm keen to understand the specific simplification techniques. I hope it's not a performance regression. My initial hunch is that they've found a way to collapse some conditional logic or perhaps reduced the number of distinct code paths for the various ioremap variants β could be a good thing if done properly. Wonder if they've leveraged some new hardware capabilities in the process, or if this is simply a code refactoring exercise. I'm also interested in whether they've addressed any specific corner cases or potential race conditions that might have been present in the previous implementation. My experience tells me these kinds of memory mapping changes are tricky, so I'll be meticulously reviewing the diffs to ensure no side effects are introduced. I hope to see fewer lines of code, improved readability, and, most importantly, no compromise in robustness.
|
| 125/2 |
2026/05/26 05:57 |
tool |
git-show |
0m
Args:
Results: map[Output:commit 095ac6fa19500fecd7c62e755dee45bb303d4d43
Author: Baoquan He <bhe@redhat.com>
Date: Sat Nov 23 19:42:19 2024 +0800
x86/ioremap: Simplify setup_data mapping variants
memremap_is_setup_data() and early_memremap_is_setup_data() share
completely the same process and handling, except for the differing
memremap/unmap invocations.
Add a helper __memremap_is_setup_data() extracting the common part and
simplify a lot of code while at it.
Mark __memremap_is_setup_data() as __ref to suppress this section
mismatch warning:
WARNING: modpost: vmlinux: section mismatch in reference: __memremap_is_setup_data+0x5f (section: .text) ->
early_memunmap (section: .init.text)
[ bp: Massage a bit. ]
Signed-off-by: Baoquan He <bhe@redhat.com>
Signed-off-by: Borislav Petkov (AMD) <bp@alien8.de>
Link: https://lore.kernel.org/r/20241123114221.149383-2-bhe@redhat.com
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index 8d29163568a7..fe44e8180bdd 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -632,42 +632,54 @@ static bool memremap_is_efi_data(resource_size_t phys_addr,
* Examine the physical address to determine if it is boot data by checking
* it against the boot params setup_data chain.
*/
-static bool memremap_is_setup_data(resource_size_t phys_addr,
- unsigned long size)
+static bool __ref __memremap_is_setup_data(resource_size_t phys_addr, bool early)
{
+ unsigned int setup_data_sz = sizeof(struct setup_data);
struct setup_indirect *indirect;
struct setup_data *data;
u64 paddr, paddr_next;
paddr = boot_params.hdr.setup_data;
while (paddr) {
- unsigned int len;
+ unsigned int len, size;
if (phys_addr == paddr)
return true;
- data = memremap(paddr, sizeof(*data),
- MEMREMAP_WB | MEMREMAP_DEC);
+ if (early)
+ data = early_memremap_decrypted(paddr, setup_data_sz);
+ else
+ data = memremap(paddr, setup_data_sz, MEMREMAP_WB | MEMREMAP_DEC);
if (!data) {
- pr_warn("failed to memremap setup_data entry\n");
+ pr_warn("failed to remap setup_data entry\n");
return false;
}
+ size = setup_data_sz;
+
paddr_next = data->next;
len = data->len;
if ((phys_addr > paddr) &&
- (phys_addr < (paddr + sizeof(struct setup_data) + len))) {
- memunmap(data);
+ (phys_addr < (paddr + setup_data_sz + len))) {
+ if (early)
+ early_memunmap(data, setup_data_sz);
+ else
+ memunmap(data);
return true;
}
if (data->type == SETUP_INDIRECT) {
- memunmap(data);
- data = memremap(paddr, sizeof(*data) + len,
- MEMREMAP_WB | MEMREMAP_DEC);
+ size += len;
+ if (early) {
+ early_memunmap(data, setup_data_sz);
+ data = early_memremap_decrypted(paddr, size);
+ } else {
+ memunmap(data);
+ data = memremap(paddr, size, MEMREMAP_WB | MEMREMAP_DEC);
+ }
if (!data) {
- pr_warn("failed to memremap indirect setup_data\n");
+ pr_warn("failed to remap indirect setup_data\n");
return false;
}
@@ -679,7 +691,10 @@ static bool memremap_is_setup_data(resource_size_t phys_addr,
}
}
- memunmap(data);
+ if (early)
+ early_memunmap(data, size);
+ else
+ memunmap(data);
if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
return true;
@@ -690,67 +705,16 @@ static bool memremap_is_setup_data(resource_size_t phys_addr,
return false;
}
-/*
- * Examine the physical address to determine if it is boot data by checking
- * it against the boot params setup_data chain (early boot version).
- */
+static bool memremap_is_setup_data(resource_size_t phys_addr,
+ unsigned long size)
+{
+ return __memremap_is_setup_data(phys_addr, false);
+}
+
static bool __init early_memremap_is_setup_data(resource_size_t phys_addr,
unsigned long size)
{
- struct setup_indirect *indirect;
- struct setup_data *data;
- u64 paddr, paddr_next;
-
- paddr = boot_params.hdr.setup_data;
- while (paddr) {
- unsigned int len, size;
-
- if (phys_addr == paddr)
- return true;
-
- data = early_memremap_decrypted(paddr, sizeof(*data));
- if (!data) {
- pr_warn("failed to early memremap setup_data entry\n");
- return false;
- }
-
- size = sizeof(*data);
-
- paddr_next = data->next;
- len = data->len;
-
- if ((phys_addr > paddr) &&
- (phys_addr < (paddr + sizeof(struct setup_data) + len))) {
- early_memunmap(data, sizeof(*data));
- return true;
- }
-
- if (data->type == SETUP_INDIRECT) {
- size += len;
- early_memunmap(data, sizeof(*data));
- data = early_memremap_decrypted(paddr, size);
- if (!data) {
- pr_warn("failed to early memremap indirect setup_data\n");
- return false;
- }
-
- indirect = (struct setup_indirect *)data->data;
-
- if (indirect->type != SETUP_INDIRECT) {
- paddr = indirect->addr;
- len = indirect->len;
- }
- }
-
- early_memunmap(data, size);
-
- if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
- return true;
-
- paddr = paddr_next;
- }
-
- return false;
+ return __memremap_is_setup_data(phys_addr, true);
}
/*
]
|
| 126/2 |
2026/05/26 05:57 |
llm |
expert |
0m
Model:
Tokens:
input: 168825
output: 66
thoughts: 2778
Thoughts: **Analysis of the Invalid Physical Address Warning in `pcibios_device_add`**
Alright, let's break this down. First, this commit, `095ac6fa1950`, introduced `__memremap_is_setup_data`, which seems relevant. That `setup_data_sz` and the diff certainly caught my eye. The call stack, specifically `memremap` calling `arch_memremap_can_ram_remap`, and the potential for recursion, immediately grabbed my attention. However, a quick check of `arch_memremap_can_ram_remap` with that `MEMREMAP_DEC` flag clearly stops the recursion. It immediately returns `false` if `MEMREMAP_DEC` is true.
So, if `MEMREMAP_DEC` is set, `memremap` doesn't go down the rabbit hole and instead calls `arch_memremap_wb`. That function uses `ioremap_cache`, which then calls `__ioremap_caller`, and the crucial part: it checks `phys_addr_valid`. Aha! This is where the warning likely originates: `phys_addr` is invalid.
I initially thought it was the first `memremap` call which was causing the issue, but if that were the case, the stack trace would be different. Looking at the bug report stack trace, it's `__ioremap_caller` <- `ioremap_cache` <- `arch_memremap_wb` <- `memremap` <- `pcibios_device_add` β `__memremap_is_setup_data` isn't there! This means the issue isn't coming from the initial check, but from a call that goes directly from `pcibios_device_add`.
This means `pcibios_device_add` is calling `memremap` with an invalid `paddr`. This is happening because of this part of the code:
```c
pa_data = boot_params.hdr.setup_data;
while (pa_data) {
data = memremap(pa_data, sizeof(*rom), MEMREMAP_WB);
```
The key is `boot_params.hdr.setup_data` β it's an invalid physical address. Now, if this were invalid during boot, it would've warned then, but it didn't, which is critical. Therefore, this data becomes invalid *after* the boot process. This means `boot_params.hdr.setup_data` (or the `data->next` pointer it references) must be getting overwritten. So the memory holding this setup data is being freed and reused or corrupted later on.
The `initrd` overlap issue is a known cause for these kinds of problems, and perfectly explains it. Essentially, it appears the memory allocated for `setup_data` is being freed, then overwritten with garbage. When a PCI rescan happens (triggered by root), `pcibios_device_add` reads this garbage and calls `memremap`, leading to the warning.
So, the assessment: this isn't exploitable for code execution. It's just a warning, and a PCI device add failure at most. This does NOT represent a denial-of-service, nor can it be triggered without root access, nor does it require a namespaced environment. The host can provide the faulty data, so the host is able to trigger this from a guest. Plugging in peripherals, like a Thunderbolt device, which triggers a PCI hotplug, is another possible trigger, but it's not a remote or file system trigger.
It's unlikely syzkaller can directly modify the `setup_data` through `/sys/kernel/debug/boot_params/data` because that's read-only. However, `kexec_load` is a possibility β if syzkaller can use `kexec_load` (requiring `CAP_SYS_BOOT`, hence root) to overwrite the memory, that's another trigger. However, it's still rooted in an incorrect `boot_params.hdr.setup_data`, so the initial hypothesis regarding memory corruption from the boot environment holds.
|
| 127/2 |
2026/05/26 05:57 |
tool |
set-results |
0m
Args: map[DenialOfService:false Exploitable:false FilesystemTrigger:false NetworkTrigger:false PeripheralTrigger:true RemoteTrigger:false Unprivileged:false UserNamespace:false VMGuestTrigger:false VMHostTrigger:true]
Results: map[DenialOfService:false Exploitable:false FilesystemTrigger:false NetworkTrigger:false PeripheralTrigger:true RemoteTrigger:false Unprivileged:false UserNamespace:false VMGuestTrigger:false VMHostTrigger:true]
|
| 128/2 |
2026/05/26 05:57 |
llm |
expert |
0m
Model:
Tokens:
input: 172638
output: 818
thoughts: 13
Thoughts: Okay, here's my attempt at summarizing the thought process, as requested, aimed at an expert user:
**Finalizing the Response**
Alright, the data's locked in, the analysis is complete. Now it's time to craft the final response. I've considered all the angles, weighed the implications, and I'm ready to translate this complex information into a clear and compelling narrative. It's about distilling the essence, communicating the nuance, and making sure the conclusion is both sound and readily accessible. Time to synthesize. I'll make sure to cover all the key findings, address the relevant caveats and ensure it adds value to the conversation.
|
| 129/1 |
2026/05/26 05:58 |
action |
format-explanation |
0m
Results: map[Explanation:Based on the analysis of the bug report and the kernel source code, here is the
assessment of the security impact:
**Bug Mechanism:**
The warning `ioremap: invalid physical address 4ff4208dd89fe53e` is triggered in
`__ioremap_caller` when the kernel attempts to map an invalid physical address.
The stack trace shows this occurs during a PCI bus rescan (`dev_rescan_store` ->
`pci_rescan_bus` -> ... -> `pcibios_device_add`).
In `pcibios_device_add`, the kernel iterates over the
`boot_params.hdr.setup_data` linked list to find `SETUP_PCI` ROMs. It maps each
entry using `memremap`. If the `next` pointer of a `setup_data` entry contains a
garbage value (like `4ff4208dd89fe53e`), `memremap` will attempt to map it.
Since this garbage address is not valid RAM, it falls back to `ioremap_cache`,
which checks `phys_addr_valid()` and triggers the `WARN_ON_ONCE`.
Since this warning occurs during a runtime sysfs write (`syz.5.5717`) and not
during the initial boot PCI enumeration, the `setup_data` chain must have been
valid during boot but became corrupted later. This typically happens when the
bootloader (e.g., QEMU) places the `setup_data` chain in memory that the kernel
later frees (such as overlapping with or immediately following the `initrd`
which gets freed by `free_initrd_mem`). Once freed, the memory is reallocated
and overwritten with arbitrary data. When a PCI rescan is later triggered, the
kernel reads the overwritten memory, encounters the garbage `next` pointer, and
triggers the warning.
**Security Impact:**
* **Exploitable:** No. The bug results in a `WARN_ON_ONCE` and `memremap` safely
returning `NULL`. The calling function (`pcibios_device_add`) handles the `NULL`
return by returning `-ENOMEM`. There is no memory corruption, out-of-bounds
access, or use-after-free caused by this bug itself (the kernel is just reading
its own reused memory).
* **Denial Of Service:** No. It is a non-fatal warning. The specific PCI device
being added might fail to initialize its ROM or MSI domain properly, but the
system continues to operate.
* **Accessible From Unprivileged Processes / User Namespaces:** No. Triggering a
PCI rescan via `/sys/bus/pci/devices/.../rescan` requires global root privileges
(`0200` permissions, owned by global root). It cannot be triggered by
unprivileged users or from within a user namespace.
* **VM Guest Trigger:** No. The bug is internal to the guest kernel and does not
affect the host.
* **VM Host Trigger in The Confidential Computing Context:** Yes. In a
confidential computing environment (like AMD SEV or Intel TDX), the host VMM
provides the `boot_params` and `setup_data` to the guest. A malicious host can
intentionally provide a malformed `setup_data` chain with an invalid physical
address to trigger this warning in the guest during boot.
* **Peripheral Trigger:** Yes. Physically plugging in a Thunderbolt/USB4 device
triggers a PCI hotplug event. This scans the new PCI bus and calls
`pci_device_add` -> `pcibios_device_add`. If the `setup_data` was previously
corrupted (e.g., by the initrd freeing issue), plugging in the peripheral will
trigger the warning.
* **Network / Remote / Filesystem Trigger:** No. The bug is strictly related to
PCI device enumeration and boot parameters.]
|