x86: Clean up and reorganize the E820 table handling code
Subsystems (15)
cover x86: Clean up and reorganize the E820 table handling code
When reviewing an E820 patch two days ago I noticed that our E820 code in arch/x86/kernel/e820.c has bitrotten quite a bit, and started cleaning it up a bit.
Didn't suspect that I'd end up with 50 patches, but oh well ...
The code got the usual treatments to turn it into a modern, cleanly structured kernel facility:
- split the e820.h header split into asm/e820/types.h and asm/e820/api.h and moved most of it out of the UAPI export,
- eliminated a number of header dependency hell related to the E820 code,
- clarified and standardized the API names, the variable names, the overall code style and the comments,
- cleaned up and modernized the various basic types used,
- fixed a ton of comments and weird constructs and added comments where they were missing.
There's a lot more: see the individual patches for details. There's no big functional changes, but the overall diffstat is pretty significant, due to cleaning out of 10+ years of gradually accumulated cruft.
It should now be possible for someone to understand the code from first principles, without too much hassle.
The patches can also be accessed in the following Git tree:
git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git WIP.x86/boot
The code has been through a fair amount of testing, but only on a limited number of test systems.
Ingo Molnar (50):
x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
x86/boot/e820: Clean up and improve comments in asm/e820/types.h
x86/boot/e820: Move asm/e820.h to asm/e820/api.h
x86/boot/e820: Split minimal UAPI types out into uapi/asm/e820/types.h
x86/boot/e820: Clean up the E820_X_MAX definition
x86/boot/e820: Remove spurious asm/e820/api.h inclusions
x86/boot/e820: Remove assembly guard from asm/e820/types.h
x86/boot/e820: Clean up asm/e820/api.h
x86/boot/e820: Remove unnecessary __ASSEMBLY__ guard
x86/boot/e820: Move HIGH_MEMORY define to asm/e820/types.h
x86/boot/e820: Rename the basic e820 data types to 'struct e820_entry' and 'struct e820_array' x86/boot/e820: Remove unnecessary #include <linux/ioport.h> from asm/e820/api.h x86/boot/e820: Remove e820_mark_nosave_regions() definition uglies
x86/boot/e820: Rename 'e820_map' variables to 'e820_array'
x86/boot/e820: Rename everything to e820_table
x86/boot/e820: Harmonize the 'struct e820_table' fields
x86/boot/e820: Rename default_machine_specific_memory_setup() to e820__memory_setup_default() x86/boot/e820: Rename e820_table_saved to e820_table_firmware and improve the description x86/boot/e820: Basic cleanup of e820.c
x86/boot/e820: Rename memblock_x86_fill() to e820__memblock_setup() and improve the explanations x86/boot/e820: Consolidate 'struct e820_entry *entry' local variable names x86/boot/e820: Convert printk(KERN_* ...) to pr_*()
x86/boot/e820: Move the memblock_find_dma_reserve() function and rename it to memblock_set_dma_reserve() x86/boot/e820: Rename parse_e820_ext() to e820__memory_setup_extended()
x86/boot/e820: Move e820_reserve_setup_data() to e820.c
x86/boot/e820: Clarify the role of finish_e820_parsing() and rename it to e820__finish_early_params() x86/boot/e820: Rename early_reserve_e820() to e820__memblock_alloc() and document it x86/boot/e820: Rename update_e820() to e820__update_table()
x86/boot/e820: Rename sanitize_e820_table() to e820__update_table()
x86/boot/e820: Rename e820_any_mapped()/e820_all_mapped() to e820__mapped_any()/e820__mapped_all() x86/boot/e820: Rename e820_setup_gap() to e820__setup_pci_gap()
x86/boot/e820: Create coherent API function names for E820 range operations x86/boot/e820: Rename e820_print_map() to e820__print_table()
x86/boot/e820: Reorder the function prototypes in api.h
x86/boot/e820: Simplify e820_reserve_resources()
x86/boot/e820: Introduce 'enum e820_type'
x86/boot/e820: Use 'enum e820_type' in 'struct e820_entry'
x86/boot/e820: Use 'enum e820_type' when handling the e820 region type
x86/boot/e820: Prefix the E820_* type names with "E820_TYPE_"
x86/boot/e820: Clean up the E820 table size define names
x86/boot/e820: Clean up and standardize sizeof() uses
xen, x86/boot/e820: Simplify Xen's xen_e820_table construct
x86/boot/e820: Simplify the e820__update_table() interface
x86/boot/e820: Clean up __e820__update_table() et al
x86/boot/e820: Document e820__reserve_setup_data()
x86/boot/e820: Use bool in query APIs
x86/boot/e820: Rename e820_reserve_resources*() to e820__reserve_resources*() x86/boot/e820: Rename e820_mark_nosave_regions() to e820__register_nosave_regions() x86/boot/e820: Remove unnecessary #include's
x86/boot/e820: Rename the remaining E820 APIs to the e820__*() prefix
Documentation/x86/zero-page.txt | 6 +- arch/x86/boot/compressed/eboot.c | 44 +-- arch/x86/boot/compressed/kaslr.c | 6 +- arch/x86/boot/header.S | 1 - arch/x86/boot/memory.c | 6 +- arch/x86/include/asm/acpi.h | 2 + arch/x86/include/asm/e820.h | 73 ---- arch/x86/include/asm/e820/api.h | 50 +++ arch/x86/include/asm/e820/types.h | 58 +++ arch/x86/include/asm/gart.h | 4 +- arch/x86/include/asm/mpspec.h | 4 +- arch/x86/include/asm/pci_x86.h | 2 + arch/x86/include/asm/pgtable.h | 3 +- arch/x86/include/uapi/asm/bootparam.h | 4 +- arch/x86/include/uapi/asm/e820/types.h | 55 +++ arch/x86/kernel/acpi/boot.c | 5 +- arch/x86/kernel/aperture_64.c | 10 +- arch/x86/kernel/apic/apic.c | 2 +- arch/x86/kernel/apic/apic_noop.c | 2 +- arch/x86/kernel/apic/probe_32.c | 2 +- arch/x86/kernel/apic/x2apic_uv_x.c | 1 + arch/x86/kernel/cpu/centaur.c | 2 +- arch/x86/kernel/cpu/mtrr/cleanup.c | 6 +- arch/x86/kernel/cpu/mtrr/main.c | 2 +- arch/x86/kernel/crash.c | 23 +- arch/x86/kernel/e820.c | 1032 ++++++++++++++++++++++++++-------------------------- arch/x86/kernel/early-quirks.c | 4 +- arch/x86/kernel/head32.c | 2 +- arch/x86/kernel/head64.c | 2 +- arch/x86/kernel/kexec-bzimage64.c | 18 +- arch/x86/kernel/mpparse.c | 6 +- arch/x86/kernel/probe_roms.c | 2 +- arch/x86/kernel/resource.c | 8 +- arch/x86/kernel/setup.c | 78 ++-- arch/x86/kernel/tboot.c | 16 +- arch/x86/kernel/x86_init.c | 4 +- arch/x86/lguest/boot.c | 8 +- arch/x86/lib/kaslr.c | 2 +- arch/x86/mm/amdtopology.c | 2 +- arch/x86/mm/init.c | 59 ++- arch/x86/mm/init_32.c | 2 +- arch/x86/mm/init_64.c | 26 +- arch/x86/mm/ioremap.c | 3 +- arch/x86/mm/kasan_init_64.c | 5 +- arch/x86/mm/mmio-mod.c | 2 +- arch/x86/mm/numa.c | 2 +- arch/x86/mm/pageattr.c | 2 +- arch/x86/mm/pat.c | 3 +- arch/x86/mm/pgtable_32.c | 2 +- arch/x86/mm/srat.c | 2 +- arch/x86/pci/i386.c | 4 +- arch/x86/pci/mmconfig-shared.c | 22 +- arch/x86/pci/mmconfig_32.c | 2 +- arch/x86/pci/mmconfig_64.c | 2 +- arch/x86/pci/pcbios.c | 2 + arch/x86/platform/efi/efi.c | 19 +- arch/x86/platform/efi/efi_64.c | 2 +- arch/x86/platform/efi/quirks.c | 8 +- arch/x86/power/hibernate_64.c | 16 +- arch/x86/xen/mmu.c | 2 +- arch/x86/xen/setup.c | 97 +++-- drivers/acpi/tables.c | 2 +- drivers/char/agp/amd64-agp.c | 2 +- include/xen/page.h | 2 +- tools/lguest/lguest.c | 2 +- 65 files changed, 989 insertions(+), 860 deletions(-) delete mode 100644 arch/x86/include/asm/e820.h create mode 100644 arch/x86/include/asm/e820/api.h create mode 100644 arch/x86/include/asm/e820/types.h create mode 100644 arch/x86/include/uapi/asm/e820/types.h
Signature · 1 line
2.7.4
PATCH 1/50 x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
First baby steps towards saner e820 headers: create an exact copy of arch/x86/include/uapi/asm/e820.h and use it from the asm/e820.h file.
No other changes - this is done to decouple the code from UAPI headers, plus to make sure that subsequent modifications to the file can be more clearly seen.
The plan is to keep the old UAPI header in place but the kernel won't use it anymore - and after some time we'll try to remove it. (User-space tools better have local copies of headers anyway, instead of relying on kernel headers.)
This gives the kernel the freedom to reorganize the e820 code.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820.h | 4 +-- arch/x86/include/asm/e820/types.h | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+), 2 deletions(-)
arch/x86/include/asm/e820.h +2 -2
@@ -5,12 +5,12 @@* E820_X_MAX is the maximum size of the extended E820 table. The extended * table may contain up to 3 extra E820 entries per possible NUMA node, so we * make room for 3 * MAX_NUMNODES possible entries, beyond the standard 128. -* Also note that E820_X_MAX *must* be defined before we include uapi/asm/e820.h. +* Also note that E820_X_MAX *must* be defined before we include asm/e820/types.h. */ #include <linux/numa.h> #define E820_X_MAX (E820MAX + 3 * MAX_NUMNODES) -#include <uapi/asm/e820.h> +#include <asm/e820/types.h> #ifndef __ASSEMBLY__/* see comment in arch/x86/kernel/e820.c */
arch/x86/include/asm/e820/types.h new file +81 -0
81 lines not on this page · raw message
Signature · 1 line
2.7.4
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 5 lines · Ingo Molnar
The plan is to keep the old UAPI header in place but the kernel won't use it anymore - and after some time we'll try to remove it. (User-space tools better have local copies of headers anyway, instead of relying on kernel headers.)
The idea with uapi is the the kernel provides a sane set of headers to be used by user space.
So we avoid random copies that is maintained by random people in random ways resulting in random bugs.
The step(s) outlined here can only result in inconsistency and cannot benefit neither user space nor the kernel in the long run.
The uapi shall be lean and clean headers, and shall include no info whatsoever that is not relevant for user space.
But requiring all user space programs (diverse libc variants, other programs) to maintain their own copy can only result in inconsistencies that is the benefit for no one.
Sam
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 11 lines · Sam Ravnborg
Quoted 5 lines · Ingo Molnar
The plan is to keep the old UAPI header in place but the kernel won't use it anymore - and after some time we'll try to remove it. (User-space tools better have local copies of headers anyway, instead of relying on kernel headers.)
The idea with uapi is the the kernel provides a sane set of headers to be used by user space.
So we avoid random copies that is maintained by random people in random ways resulting in random bugs.
Your argument is simplistic which presents a false dichotomy: maintaining a copy or fully sharing the header are not the only two options available to share the information in the headers between the kernel and tooling: for example perf uses a half-automated method where headers are copied from the kernel, but also checked automatically against the upstream kernel, and a (non-fatal) warning is emitted during the build if the upstream header has changed.
For example today the perf build shows these UAPI header warnings:
Warning: arch/powerpc/include/uapi/asm/kvm.h differs from kernel
Warning: arch/arm/include/uapi/asm/kvm.h differs from kernel
... because new bits were added to those two UAPI headers. For example the new ARM bits were:
triton:~/tip/tools/perf> diff -up ../arch/arm/include/uapi/asm/kvm.h ../../arch/arm/include/uapi/asm/kvm.h
../arch/arm/include/uapi/asm/kvm.h 2017-01-28 09:35:12.383587930 +0100 renamed from arch/arm/include/uapi/asm/kvm.h 2017-01-23 10:10:18.846003002 +0100 +9 -0
@@ -84,6 +84,15 @@ struct kvm_regs { #define KVM_VGIC_V2_DIST_SIZE 0x1000 #define KVM_VGIC_V2_CPU_SIZE 0x2000 +/* Supported VGICv3 address types */ +#define KVM_VGIC_V3_ADDR_TYPE_DIST 2 +#define KVM_VGIC_V3_ADDR_TYPE_REDIST 3 +#define KVM_VGIC_ITS_ADDR_TYPE 4 + +#define KVM_VGIC_V3_DIST_SIZE SZ_64K +#define KVM_VGIC_V3_REDIST_SIZE (2 * SZ_64K) +#define KVM_VGIC_V3_ITS_SIZE (2 * SZ_64K) + #define KVM_ARM_VCPU_POWER_OFF 0 /* CPU is started in OFF state */ #define KVM_ARM_VCPU_PSCI_0_2 1 /* CPU uses PSCI v0.2 */
... so for these changes the perf side copy can be updated safely. Had the changes been more intricate, the changes can be copied too - while adopting the tooling source code as well.
See the tools/perf/check-headers.sh script.
This IMHO is a far more intelligent and far more robust approach than blind sharing or detached copies, because it:
- forces new changes from upstream to be considered and adapted by tooling
- header (and thus ABI) synchronization is guaranteed (eventually)
- it does not actually couple the two source code bases in a rigid fashion:
- the upstream kernel is free to change those headers (at least from perf's POV) in any sane way, those changes can be adapted.
- every step is conscious and there's no way to accidentally break tooling via header changes - nor does tooling hinder the kernel from progressing its source code base.
It's basically a script based COW filesystem with guaranteed propagation and guaranteed synchronization.
Quoted 2 lines
The step(s) outlined here can only result in inconsistency and cannot benefit neither user space nor the kernel in the long run.
That's simply not true, see above.
Quoted 2 lines
The uapi shall be lean and clean headers, and shall include no info whatsoever that is not relevant for user space.
I agree with that characterization, and that will be even more so with my changes:
my series makes uapi/asm/bootparam.h more self-contained, more lean - while still defining the full ABI.
Quoted 3 lines
But requiring all user space programs (diverse libc variants, other programs) to maintain their own copy can only result in inconsistencies that is the benefit for no one.
That's simply not true, see above.
Note that my changes try to keep the 'UAPI promise' (in that the old e820.h header is still around), while still modifying the kernel side.
What _IS_ insane is to somehow construe the UAPI headers as a rigid construct that forces the kernel source to keep using poorly chosen names like 'struct e820entry' forever...
Thanks,
Ingo
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 15 lines · Ingo Molnar
Quoted 11 lines · Sam Ravnborg
Quoted 5 lines · Ingo Molnar
The plan is to keep the old UAPI header in place but the kernel won't use it anymore - and after some time we'll try to remove it. (User-space tools better have local copies of headers anyway, instead of relying on kernel headers.)
The idea with uapi is the the kernel provides a sane set of headers to be used by user space.
So we avoid random copies that is maintained by random people in random ways resulting in random bugs.
Quoted 6 lines
Your argument is simplistic which presents a false dichotomy: maintaining a copy or fully sharing the header are not the only two options available to share the information in the headers between the kernel and tooling: for example perf uses a half-automated method where headers are copied from the kernel, but also checked automatically against the upstream kernel, and a (non-fatal) warning is emitted during the build if the upstream header has changed.
Obvious when there are two vastly different solutions there are some middle ground solutions too.
And perf implements a tool based method to check that the manually copied/created/maintained headers are in sync with the kernel. which is just another way to maintain a set of copied headers.
But this does not at all address the point which is that it is an unessesary burden to put on all the _users_ of the kernel uapi headers to amintain their own copy of the kernel headers (tool assisted or not).
The rationale behind requesting the users of the kernel uapi headers seems to be that the kernel people would like to have the freedom to fix wrong doings in the past without violatign the uapi. So the benefit here is simpler headers on the kernel side compared to all users of kernel uapi heders to manually (tool assisted or not) maintaining their own copies of the uapi kernel headers.
Heck - if this is how it should be done then the the kernel should provide the copy of the headers that describe the uapi and the kernel should have the tool infrastructure to check that the headers are OK.
Not all the users outside the kernelspace.
So just to repeat - it is an error prone design to let users of the kernel uapi maintain their own copies of the kernel uapi header. It is the job of the kernel.
Sam
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 10 lines · Sam Ravnborg
Obvious when there are two vastly different solutions there are some middle ground solutions too.
And perf implements a tool based method to check that the manually copied/created/maintained headers are in sync with the kernel. which is just another way to maintain a set of copied headers.
But this does not at all address the point which is that it is an unessesary burden to put on all the _users_ of the kernel uapi headers to amintain their own copy of the kernel headers (tool assisted or not).
In 99% of the cases it's trivial to keep them updated on the tooling side. Basically a copy only has to be made if a change is done - and changes are not that common in the ABI space.
Quoted 7 lines
The rationale behind requesting the users of the kernel uapi headers seems to be that the kernel people would like to have the freedom to fix wrong doings in the past without violatign the uapi.
So the benefit here is simpler headers on the kernel side compared to all users of kernel uapi heders to manually (tool assisted or not) maintaining their own copies of the uapi kernel headers.
I was reacting to this original claim of yours:
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
The idea with uapi is the the kernel provides a sane set of headers to be used by user space.
So we avoid random copies that is maintained by random people in random ways resulting in random bugs.
There's no 'random copies' - they are copies of past, valid versions of the kernel headers, and there's a mechanism to update them to the latest.
Quoted 9 lines
Heck - if this is how it should be done then the the kernel should provide the copy of the headers that describe the uapi and the kernel should have the tool infrastructure to check that the headers are OK.
Not all the users outside the kernelspace.So just to repeat - it is an error prone design to let users of the kernel uapi maintain their own copies of the kernel uapi header. It is the job of the kernel.
But "random copies" is not what perf does. Tell me, how is the perf mechanism of using the headers "error-prone"? It's a delayed COW mechanism - COW is not an error-prone concept in any way ...
Thanks,
Ingo
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 8 lines
Quoted 4 lines
So just to repeat - it is an error prone design to let users of the kernel uapi maintain their own copies of the kernel uapi header. It is the job of the kernel.
But "random copies" is not what perf does. Tell me, how is the perf mechanism of using the headers "error-prone"? It's a delayed COW mechanism - COW is not an error-prone concept in any way ...
The whole concept that user space have the burden to maintain a set of headers describing the uapi provided by the kernel is the point of discussion.
The randomness come into play when a user space developer are faced with the challenge that the programm require access to something described by the kernel uapi and then have to hunt for a header that describes said uapi.
In this thread we have covered one rational reason to push thus burden to user space - to give the kernel the freedom to repair past stupidity (being that in naming or some other sort).
So lets turn around the arguments - and from a user space perspective what is the benefit of maintaining a set of headers describing the kernel uapi?
Obviously this allows user space to name thing exactly the way they like, and allows user space to put all sorts of strange things in the header files describing the kernel uapi.
This is just not enough good reasons why the user space developer shall create headers files describing the kerneluapi and maintain tooling to maintain the header files describing the kernel uapi.
Are there other benefits that is missed which makes the concept of letting user space maintain header files describing the kernel uapi a good idea that is missed?
Sam
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 11 lines · Sam Ravnborg
Quoted 8 lines
Quoted 4 lines
So just to repeat - it is an error prone design to let users of the kernel uapi maintain their own copies of the kernel uapi header. It is the job of the kernel.
But "random copies" is not what perf does. Tell me, how is the perf mechanism of using the headers "error-prone"? It's a delayed COW mechanism - COW is not an error-prone concept in any way ...
The whole concept that user space have the burden to maintain a set of headers describing the uapi provided by the kernel is the point of discussion.
That's your characterisation and I think it's misleading: they don't have to "maintain a set of headers", they can, if they'd like to:
"maintain a _copy_ of a small number of headers that the typical user-space
tooling project is interested in"
which is different from how you framed it.
Quoted 7 lines
The randomness come into play when a user space developer are faced with the challenge that the programm require access to something described by the kernel uapi and then have to hunt for a header that describes said uapi.
In this thread we have covered one rational reason to push thus burden to user space - to give the kernel the freedom to repair past stupidity (being that in naming or some other sort).
There's no real "burden" for heaven's sake: it's having to execute a 'cp' every now and then and check whether the result still builds (it will build just fine in the overwhelming majority of cases).
Quoted 3 lines
So lets turn around the arguments - and from a user space perspective what is the benefit of maintaining a set of headers describing the kernel uapi?
Firsty, the headers are not maintained by the user-space project, 99.999% of the maintenance is done by the kernel developers.
Quoted 3 lines
Obviously this allows user space to name thing exactly the way they like, and allows user space to put all sorts of strange things in the header files describing the kernel uapi.
Huh? Again, my suggestion is to to _copy_ the kernel header the tooling project is interested in as-is, and this is exactly what perf does. We don't change the UAPI headers, we copy them verbatim and check during the build that the copy is exact.
Quoted 3 lines
Are there other benefits that is missed which makes the concept of letting user space maintain header files describing the kernel uapi a good idea that is missed?
Yes, you missed a lot of the benefits.
Firstly, the user-space tooling project that relies on some UAPI header with Linux kernel ABI details in it, if it so wishes, maintains a _copy_ of the affected headers, which is vastly less work and 'burden' than 'maintaining headers'.
Secondly, doing this copy has numerous advantages over using the UAPI headers from the distro installation:
- Additions to the ABI are monitored by the tooling project. Say there's external tooling that relies on the perf system call, and uses a copy of perf_events.h. It can see new ABI additions in new versions of the file, and can add support for them. If on the other hand the file is just shared with whatever distro kernel headers there are on the system, there's no information about ABI progress.
Advantage: changes to the ABI can be seen in the tool's Git repository,
the "git log" of the header shows how the versions got updated and how the tool adopted to new ABI additions.
- The tooling project is more self-contained: it can build just fine in more limited environments that don't have the kernel headers installed.
Advantage: more robust tool build process, fewer dependencies.
- So the tooling project can copy the kernel header _before_ the updated kernel header trickles through to distros. This has the advantage of being able to add tooling support for new ABI additions before it all goes into the 'official' UAPI headers a distro includes, and speeds up ABI propagation.
Advantage: faster ABI propagation to tooling.
- In fact this model allows the tooling project to host new kernel ABI additions in its development process, so sometimes it has the new UAPI header _before_ the upstream kernel has it. (Obviously the upstream kernel has to pull it for it to become the official UAPI header, so this only works for subsystems where there's good communication between the tooling developers and the kernel developers.)
This is what tools/perf does quite often.
Advantage: better development model where tooling can develop new kernel
features hand in hand with kernel developers.
I.e. most of the advantages of the copied headers are for the _tooling project_, not for the kernel.
Your one sided characterization of the copying method as a 'burden' ignores all that.
Thanks,
Ingo
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 8 lines · Ingo Molnar
Quoted 3 lines · Sam Ravnborg
In this thread we have covered one rational reason to push thus burden to user space - to give the kernel the freedom to repair past stupidity (being that in naming or some other sort).
There's no real "burden" for heaven's sake: it's having to execute a 'cp' every now and then and check whether the result still builds (it will build just fine in the overwhelming majority of cases).
Defining what is it that encompasses "userspace", the thing that's nominally guaranteed to "not be broken", here is the real question.
Is it just the ABI or is it more than that?
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
In reply to Ingo MolnarHi Ingo.
Quoted 8 lines
Quoted 4 lines
In this thread we have covered one rational reason to push thus burden to user space - to give the kernel the freedom to repair past stupidity (being that in naming or some other sort).
There's no real "burden" for heaven's sake: it's having to execute a 'cp' every now and then and check whether the result still builds (it will build just fine in the overwhelming majority of cases).
We are obvious so far away in our perception of what is easy for a user-space developers that is is not even funny.
Quoted 6 lines
Quoted 3 lines
So lets turn around the arguments - and from a user space perspective what is the benefit of maintaining a set of headers describing the kernel uapi?
Firsty, the headers are not maintained by the user-space project, 99.999% of the maintenance is done by the kernel developers.
In the inital mail triggering this plan was that the kernel is moving away from having uapi headers what-so-ever.
Quoting the original mail:
"
The plan is to keep the old UAPI header in place but the kernel won't use it anymore - and after some time we'll try to remove it. "
Translated:
The plan is that the kernel will stop using headers from uapi/* The headers will be left for a while and then they will be deleted.
The mail was centered about e820 - so maybe the outlined plan was only for e820.
But I read it as a general pan - hence this mail thread.
So this is the plan that this argument is about.
No tooling will magically make files appear again.
And there is no benefit from user space that the kernel remove the files.
And the removing of files from uapi/ makes is hard for user space. Because then a user-space developers have to find a definition of the uapi somewhere else.
Quoted 2 lines
Huh? Again, my suggestion is to to _copy_ the kernel header the tooling project is interested in as-is, and this is exactly what perf does.
Here the proposal was stop using the header in uapi/ and then later delete it. So there i no file to copy - making the copying and tooling part irrelevant.
Quoted 5 lines
Yes, you missed a lot of the benefits.
Firstly, the user-space tooling project that relies on some UAPI header with Linux kernel ABI details in it, if it so wishes, maintains a _copy_ of the affected headers, which is vastly less work and 'burden' than 'maintaining headers'.
It is by no means a benefit to have a copy, rather than using the source. There is a reason why we do not have multiple copies of the headers in the kernel when we can avoid it. asm-generic is one way the kernel avoid the burden of maintaining copies of headers.
All your remaining argumens zapped - I see the point of view. But there are many other solutions for the same set of problems.
Perf being intimidate with the kernel is not the best example to come up with. Think about to 100's of program that uses a few ioclt to talk with drivers etc.
Sam
Re: [PATCH 01/50] x86/boot/e820: Introduce arch/x86/include/asm/e820/types.h
Quoted 5 lines · Sam Ravnborg
Quoted 2 lines
Firsty, the headers are not maintained by the user-space project, 99.999% of the maintenance is done by the kernel developers.
In the inital mail triggering this plan was that the kernel is moving away from having uapi headers what-so-ever.
No, that is a misunderstanding:
Quoted 5 lines
Quoting the original mail:
"
The plan is to keep the old UAPI header in place but the kernel won't use it anymore - and after some time we'll try to remove it. "
You misunderstood my mail and you misunderstood the patch: we transition from the old UAPI header to a new one, but the exported data structures are still kept!
If you check the patches you'll see that bootparam.h still exports the e820_entry data structure. The 'old' header is simply one that is being phased out (if we can) - but the information is still exported.
Quoted 3 lines
Translated:
The plan is that the kernel will stop using headers from uapi/* The headers will be left for a while and then they will be deleted.
No, not at all.
Quoted 1 line
Perf being intimidate with the kernel is not the best example to come up with.
No, that's wrong too, most larger tooling projects that care about feature propagation latency in fact already do something quite similar to what perf does.
For example the tooling side of GPU drivers (libdrm) has a copy of all the relevant UAPI headers:
triton:~/libdrm/include/drm> ls -l
total 316
-rw-rw-r-- 1 mingo mingo 19119 Feb 1 09:47 amdgpu_drm.h -rw-rw-r-- 1 mingo mingo 11850 Feb 1 09:47 drm_fourcc.h -rw-rw-r-- 1 mingo mingo 27613 Feb 1 09:47 drm.h -rw-rw-r-- 1 mingo mingo 18313 Feb 1 09:47 drm_mode.h -rw-rw-r-- 1 mingo mingo 2701 Feb 1 09:47 drm_sarea.h -rw-rw-r-- 1 mingo mingo 46684 Feb 1 09:47 i915_drm.h -rw-rw-r-- 1 mingo mingo 7895 Feb 1 09:47 mach64_drm.h -rw-rw-r-- 1 mingo mingo 12923 Feb 1 09:47 mga_drm.h -rw-rw-r-- 1 mingo mingo 5662 Feb 1 09:47 nouveau_drm.h -rw-rw-r-- 1 mingo mingo 4217 Feb 1 09:47 qxl_drm.h -rw-rw-r-- 1 mingo mingo 9901 Feb 1 09:47 r128_drm.h -rw-rw-r-- 1 mingo mingo 38509 Feb 1 09:47 radeon_drm.h -rw-rw-r-- 1 mingo mingo 5201 Feb 1 09:47 README -rw-rw-r-- 1 mingo mingo 7054 Feb 1 09:47 savage_drm.h -rw-rw-r-- 1 mingo mingo 2534 Feb 1 09:47 sis_drm.h -rw-rw-r-- 1 mingo mingo 5526 Feb 1 09:47 tegra_drm.h -rw-rw-r-- 1 mingo mingo 9534 Feb 1 09:47 vc4_drm.h -rw-rw-r-- 1 mingo mingo 8291 Feb 1 09:47 via_drm.h -rw-rw-r-- 1 mingo mingo 4704 Feb 1 09:47 virtgpu_drm.h -rw-rw-r-- 1 mingo mingo 31225 Feb 1 09:47 vmwgfx_drm.h
For example i915_drm.h is a copy of include/uapi/drm/i915_drm.h, which is being synched between the two projects regularly.
Quoted 1 line
Think about to 100's of program that uses a few ioclt to talk with drivers etc.
Those can use distro UAPI headers just fine, if they don't care about the 6-12 months delay it takes to get updated kernel headers. I.e. what you propose works for well-established ABIs that have been around for years.
To actually _progress_ with a tooling project, in close cooperation with the kernel side, the UAPI method of sharing via distro headers as-is hinders development agility big time...
Distro UAPI headers work fine in a world where the kernel is a static entity and does not update its ABIs. I.e. it only works if there's no actual kernel side extensions to the ABI. The whole UAPI distro headers approach is designed for the case where the style of sharing the headers matters the least: for a stagnant kernel or a stagnant tooling project ...
Btw., his kind of rigid, suboptimal, latency laden method of sharing information between the kernel and tooling might be one of the reasons why in general the Linux tooling landscape sucks, compared to other OSs...
Thanks,
Ingo
PATCH 2/50 x86/boot/e820: Clean up and improve comments in asm/e820/types.h
In reply to Ingo MolnarDo some common-sense cleanups:
- standardize on the kernel coding style consistently
- tabulate definitions consistently
- extend and clarify various descriptions
- fix speling
- update the header guard name according to the new position
- etc.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/types.h | 84 +++++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 53 insertions(+), 31 deletions(-)
arch/x86/include/asm/e820/types.h +53 -31
@@ -1,18 +1,30 @@ -#ifndef _UAPI_ASM_X86_E820_H -#define _UAPI_ASM_X86_E820_H -#define E820MAP 0x2d0/* our map */ -#define E820MAX 128/* number of entries in E820MAP */ +#ifndef _ASM_E820_TYPES_H +#define _ASM_E820_TYPES_H + +/* Our map: */ +#define E820MAP 0x2d0 + +/* The maximum number of entries in E820MAP: */ +#define E820MAX 128/* -* Legacy E820 BIOS limits us to 128 (E820MAX) nodes due to the -* constrained space in the zeropage. If we have more nodes than -* that, and if we've booted off EFI firmware, then the EFI tables -* passed us from the EFI firmware can list more nodes. Size our -* internal memory map tables to have room for these additional -* nodes, based on up to three entries per node for which the -* kernel was built: MAX_NUMNODES == (1 << CONFIG_NODES_SHIFT), -* plus E820MAX, allowing space for the possible duplicate E820 -* entries that might need room in the same arrays, prior to the +* The legacy E820 BIOS limits us to 128 (E820MAX) nodes due to the +* constrained space in the zeropage. +* +* On large systems we can easily have thousands of nodes with RAM, +* which cannot be fit into so few entries - so we have a mechanism +* to extend the e820 table size at build-time, via the E820_X_MAX +* define below. +* +* ( Those extra entries are enumerated via the EFI memory map, not +* via the legacy zeropage mechanism. ) +* +* Size our internal memory map tables to have room for these additional +* entries, based on a heuristic calculation: up to three entries per +* NUMA node, plus E820MAX for some extra space. +* +* This allows for bootstrap/firmware quirks such as possible duplicate +* E820 entries that might need room in the same arrays, prior to the * call to sanitize_e820_map() to remove duplicates. The allowance * of three memory map entries per node is "enough" entries for * the initial hardware platform motivating this mechanism to make
@@ -20,19 +32,19 @@* to allow more than three entries per node or otherwise refine * this size. */ -#ifndef __KERNEL__ -#define E820_X_MAX E820MAX +# define E820_X_MAX E820MAX#endif -#define E820NR 0x1e8/* # entries in E820MAP */ +/* Number of entries in E820MAP: */ +#define E820NR 0x1e8 -#define E820_RAM 1 -#define E820_RESERVED 2 -#define E820_ACPI 3 -#define E820_NVS 4 -#define E820_UNUSABLE 5 -#define E820_PMEM 7 +#define E820_RAM 1 +#define E820_RESERVED 2 +#define E820_ACPI 3 +#define E820_NVS 4 +#define E820_UNUSABLE 5 +#define E820_PMEM 7/* * This is a non-standardized way to represent ADR or NVDIMM regions that
@@ -43,7 +55,7 @@* but newer versions switched to 12 as 6 was assigned differently. Some * time they will learn... ) */ -#define E820_PRAM 12 +#define E820_PRAM 12/* * reserved RAM used by kernel itself
@@ -51,23 +63,34 @@* included in the S3 integrity calculation and so should not include * any memory that BIOS might alter over the S3 transition */ -#define E820_RESERVED_KERN 128 +#define E820_RESERVED_KERN 128#ifndef __ASSEMBLY__#include <linux/types.h> + +/* +* A single E820 map entry, describing a memory range of [addr...addr+size-1], +* of 'type' memory type: +*/ struct e820entry { -__u64 addr;/* start of memory segment */ -__u64 size;/* size of memory segment */ -__u32 type;/* type of memory segment */ +__u64 addr; +__u64 size; +__u32 type; } __attribute__((packed)); +/* +* The whole array of E820 entries: +*/ struct e820map {__u32 nr_map;struct e820entry map[E820_X_MAX ]; }; -#define ISA_START_ADDRESS 0xa0000 -#define ISA_END_ADDRESS 0x100000 +/* +* Various legacy ranges in physical memory: +*/ +#define ISA_START_ADDRESS 0x000a0000 +#define ISA_END_ADDRESS 0x00100000#define BIOS_BEGIN 0x000a0000#define BIOS_END 0x00100000
@@ -77,5 +100,4 @@ struct e820map {#endif /* __ASSEMBLY__ */ - -#endif /* _UAPI_ASM_X86_E820_H */ +#endif /* _ASM_E820_TYPES_H */
Signature · 1 line
2.7.4
PATCH 3/50 x86/boot/e820: Move asm/e820.h to asm/e820/api.h
In reply to Ingo MolnarIn line with asm/e820/types.h, move the e820 API declarations to asm/e820/api.h and update all usage sites.
This is just a mechanical, obviously correct move & replace patch, there will be subsequent changes to clean up the code and to make better use of the new header organization.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
---
arch/x86/boot/header.S | 2 +-
arch/x86/include/asm/{e820.h => e820/api.h} | 6 +++---
arch/x86/include/asm/gart.h | 2 +-
arch/x86/include/asm/pgtable.h | 2 +-
arch/x86/include/uapi/asm/bootparam.h | 2 +-
arch/x86/kernel/aperture_64.c | 2 +-
arch/x86/kernel/apic/apic_noop.c | 2 +-
arch/x86/kernel/apic/probe_32.c | 2 +-
arch/x86/kernel/cpu/centaur.c | 2 +-
arch/x86/kernel/cpu/mtrr/cleanup.c | 2 +-
arch/x86/kernel/cpu/mtrr/main.c | 2 +-
arch/x86/kernel/e820.c | 2 +-
arch/x86/kernel/head32.c | 2 +-
arch/x86/kernel/head64.c | 2 +-
arch/x86/kernel/mpparse.c | 2 +-
arch/x86/kernel/probe_roms.c | 2 +-
arch/x86/kernel/resource.c | 2 +-
arch/x86/kernel/setup.c | 2 +-
arch/x86/kernel/tboot.c | 2 +-
arch/x86/kernel/x86_init.c | 2 +-
arch/x86/lguest/boot.c | 2 +-
arch/x86/lib/kaslr.c | 2 +-
arch/x86/mm/amdtopology.c | 2 +-
arch/x86/mm/init.c | 2 +-
arch/x86/mm/init_32.c | 2 +-
arch/x86/mm/init_64.c | 2 +-
arch/x86/mm/ioremap.c | 2 +-
arch/x86/mm/mmio-mod.c | 2 +-
arch/x86/mm/numa.c | 2 +-
arch/x86/mm/pageattr.c | 2 +-
arch/x86/mm/pat.c | 2 +-
arch/x86/mm/pgtable_32.c | 2 +-
arch/x86/mm/srat.c | 2 +-
arch/x86/pci/i386.c | 2 +-
arch/x86/pci/mmconfig-shared.c | 2 +-
arch/x86/pci/mmconfig_32.c | 2 +-
arch/x86/pci/mmconfig_64.c | 2 +-
arch/x86/platform/efi/efi_64.c | 2 +-
arch/x86/xen/mmu.c | 2 +-
arch/x86/xen/setup.c | 2 +-
drivers/char/agp/amd64-agp.c | 2 +-
41 files changed, 43 insertions(+), 43 deletions(-)arch/x86/boot/header.S +1 -1
@@ -18,7 +18,7 @@ #include <asm/segment.h> #include <generated/utsrelease.h> #include <asm/boot.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/page_types.h> #include <asm/setup.h> #include <asm/bootparam.h>
arch/x86/include/asm/e820/api.h renamed from arch/x86/include/asm/e820.h +3 -3
@@ -1,5 +1,5 @@ -#ifndef _ASM_X86_E820_H -#define _ASM_X86_E820_H +#ifndef _ASM_E820_API_H +#define _ASM_E820_API_H/* * E820_X_MAX is the maximum size of the extended E820 table. The extended
@@ -70,4 +70,4 @@ static inline bool is_ISA_range(u64 s, u64 e)#include <linux/ioport.h> #define HIGH_MEMORY (1024*1024) -#endif /* _ASM_X86_E820_H */ +#endif /* _ASM_E820_API_H */
arch/x86/include/asm/gart.h +1 -1
@@ -1,7 +1,7 @@#ifndef _ASM_X86_GART_H#define _ASM_X86_GART_H -#include <asm/e820.h> +#include <asm/e820/api.h> extern void set_up_gart_resume (u32 ,u32 );
arch/x86/include/asm/pgtable.h +1 -1
@@ -2,7 +2,7 @@#define _ASM_X86_PGTABLE_H#include <asm/page.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/pgtable_types.h>
arch/x86/include/uapi/asm/bootparam.h +1 -1
@@ -34,7 +34,7 @@#include <linux/screen_info.h> #include <linux/apm_bios.h> #include <linux/edd.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/ist.h> #include <video/edid.h>
arch/x86/kernel/aperture_64.c +1 -1
@@ -21,7 +21,7 @@#include <linux/pci.h> #include <linux/bitops.h> #include <linux/suspend.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/io.h> #include <asm/iommu.h> #include <asm/gart.h>
arch/x86/kernel/apic/apic_noop.c +1 -1
@@ -26,7 +26,7 @@#include <linux/interrupt.h> #include <asm/acpi.h> -#include <asm/e820.h> +#include <asm/e820/api.h> static void noop_init_apic_ldr (void ) { }static void noop_send_IPI (int cpu,int vector) { }
arch/x86/kernel/apic/probe_32.c +1 -1
@@ -25,7 +25,7 @@#include <linux/interrupt.h> #include <asm/acpi.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #ifdef CONFIG_HOTPLUG_CPU #define DEFAULT_SEND_IPI (1)
arch/x86/kernel/cpu/centaur.c +1 -1
@@ -2,7 +2,7 @@#include <linux/kernel.h> #include <asm/cpufeature.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/mtrr.h> #include <asm/msr.h>
arch/x86/kernel/cpu/mtrr/cleanup.c +1 -1
@@ -27,7 +27,7 @@#include <linux/range.h> #include <asm/processor.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/mtrr.h> #include <asm/msr.h>
arch/x86/kernel/cpu/mtrr/main.c +1 -1
@@ -48,7 +48,7 @@#include <linux/syscore_ops.h> #include <asm/cpufeature.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/mtrr.h> #include <asm/msr.h> #include <asm/pat.h>
arch/x86/kernel/e820.c +1 -1
@@ -21,7 +21,7 @@#include <linux/memblock.h> #include <linux/sort.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/proto.h> #include <asm/setup.h> #include <asm/cpufeature.h>
arch/x86/kernel/head32.c +1 -1
@@ -12,7 +12,7 @@#include <asm/setup.h> #include <asm/sections.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/page.h> #include <asm/apic.h> #include <asm/io_apic.h>
arch/x86/kernel/head64.c +1 -1
@@ -23,7 +23,7 @@#include <asm/tlbflush.h> #include <asm/sections.h> #include <asm/kdebug.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/bios_ebda.h> #include <asm/bootparam_utils.h> #include <asm/microcode.h>
arch/x86/kernel/mpparse.c +1 -1
@@ -26,7 +26,7 @@#include <asm/io_apic.h> #include <asm/proto.h> #include <asm/bios_ebda.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/setup.h> #include <asm/smp.h>
arch/x86/kernel/probe_roms.c +1 -1
@@ -14,7 +14,7 @@#include <asm/probe_roms.h> #include <asm/pci-direct.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/mmzone.h> #include <asm/setup.h> #include <asm/sections.h>
arch/x86/kernel/resource.c +1 -1
@@ -1,5 +1,5 @@#include <linux/ioport.h> -#include <asm/e820.h> +#include <asm/e820/api.h> static void resource_clip (struct resource *res,resource_size_t start,resource_size_t end)
arch/x86/kernel/setup.c +1 -1
@@ -75,7 +75,7 @@#include <asm/mtrr.h> #include <asm/apic.h> #include <asm/realmode.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/mpspec.h> #include <asm/setup.h> #include <asm/efi.h>
arch/x86/kernel/tboot.c +1 -1
@@ -42,7 +42,7 @@#include <asm/fixmap.h> #include <asm/proto.h> #include <asm/setup.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/io.h> #include "../realmode/rm/wakeup.h"
arch/x86/kernel/x86_init.c +1 -1
@@ -14,7 +14,7 @@#include <asm/mpspec.h> #include <asm/setup.h> #include <asm/apic.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/time.h> #include <asm/irq.h> #include <asm/io_apic.h>
arch/x86/lguest/boot.c +1 -1
@@ -67,7 +67,7 @@#include <asm/pgtable.h> #include <asm/desc.h> #include <asm/setup.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/mce.h> #include <asm/io.h> #include <asm/fpu/api.h>
arch/x86/lib/kaslr.c +1 -1
@@ -8,7 +8,7 @@#include <asm/kaslr.h> #include <asm/msr.h> #include <asm/archrandom.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/io.h> /*
arch/x86/mm/amdtopology.c +1 -1
@@ -19,7 +19,7 @@#include <asm/types.h> #include <asm/mmzone.h> #include <asm/proto.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/pci-direct.h> #include <asm/numa.h> #include <asm/mpspec.h>
arch/x86/mm/init.c +1 -1
@@ -6,7 +6,7 @@#include <linux/bootmem.h> /* for max_low_pfn */ #include <asm/cacheflush.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/init.h> #include <asm/page.h> #include <asm/page_types.h>
arch/x86/mm/init_32.c +1 -1
@@ -38,7 +38,7 @@#include <asm/pgtable.h> #include <asm/dma.h> #include <asm/fixmap.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/apic.h> #include <asm/bugs.h> #include <asm/tlb.h>
arch/x86/mm/init_64.c +1 -1
@@ -41,7 +41,7 @@#include <asm/pgalloc.h> #include <asm/dma.h> #include <asm/fixmap.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/apic.h> #include <asm/tlb.h> #include <asm/mmu_context.h>
arch/x86/mm/ioremap.c +1 -1
@@ -14,7 +14,7 @@#include <linux/mmiotrace.h> #include <asm/cacheflush.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/fixmap.h> #include <asm/pgtable.h> #include <asm/tlbflush.h>
arch/x86/mm/mmio-mod.c +1 -1
@@ -32,7 +32,7 @@#include <linux/kallsyms.h> #include <asm/pgtable.h> #include <linux/mmiotrace.h> -#include <asm/e820.h> /* for ISA_START_ADDRESS */ +#include <asm/e820/api.h> /* for ISA_START_ADDRESS */ #include <linux/atomic.h> #include <linux/percpu.h> #include <linux/cpu.h>
arch/x86/mm/numa.c +1 -1
@@ -12,7 +12,7 @@#include <linux/sched.h> #include <linux/topology.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/proto.h> #include <asm/dma.h> #include <asm/amd_nb.h>
arch/x86/mm/pageattr.c +1 -1
@@ -15,7 +15,7 @@#include <linux/pci.h> #include <linux/vmalloc.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/processor.h> #include <asm/tlbflush.h> #include <asm/sections.h>
arch/x86/mm/pat.c +1 -1
@@ -23,7 +23,7 @@#include <asm/x86_init.h> #include <asm/pgtable.h> #include <asm/fcntl.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/mtrr.h> #include <asm/page.h> #include <asm/msr.h>
arch/x86/mm/pgtable_32.c +1 -1
@@ -12,7 +12,7 @@#include <asm/pgtable.h> #include <asm/pgalloc.h> #include <asm/fixmap.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/tlb.h> #include <asm/tlbflush.h> #include <asm/io.h>
arch/x86/mm/srat.c +1 -1
@@ -18,7 +18,7 @@#include <linux/mm.h> #include <asm/proto.h> #include <asm/numa.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/apic.h> #include <asm/uv/uv.h>
arch/x86/pci/i386.c +1 -1
@@ -34,7 +34,7 @@#include <linux/bootmem.h> #include <asm/pat.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/pci_x86.h> #include <asm/io_apic.h>
arch/x86/pci/mmconfig-shared.c +1 -1
@@ -18,7 +18,7 @@#include <linux/slab.h> #include <linux/mutex.h> #include <linux/rculist.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/pci_x86.h> #include <asm/acpi.h>
arch/x86/pci/mmconfig_32.c +1 -1
@@ -12,7 +12,7 @@#include <linux/pci.h> #include <linux/init.h> #include <linux/rcupdate.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/pci_x86.h> /* Assume systems with more busses have correct MCFG */
arch/x86/pci/mmconfig_64.c +1 -1
@@ -10,7 +10,7 @@#include <linux/acpi.h> #include <linux/bitmap.h> #include <linux/rcupdate.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/pci_x86.h> #define PREFIX "PCI: "
arch/x86/platform/efi/efi_64.c +1 -1
@@ -35,7 +35,7 @@#include <asm/setup.h> #include <asm/page.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/pgtable.h> #include <asm/tlbflush.h> #include <asm/proto.h>
arch/x86/xen/mmu.c +1 -1
@@ -58,7 +58,7 @@#include <asm/mmu_context.h> #include <asm/setup.h> #include <asm/paravirt.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/linkage.h> #include <asm/page.h> #include <asm/init.h>
arch/x86/xen/setup.c +1 -1
@@ -14,7 +14,7 @@#include <asm/elf.h> #include <asm/vdso.h> -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/setup.h> #include <asm/acpi.h> #include <asm/numa.h>
drivers/char/agp/amd64-agp.c +1 -1
@@ -14,7 +14,7 @@#include <linux/agp_backend.h> #include <linux/mmzone.h> #include <asm/page.h> /* PAGE_SIZE */ -#include <asm/e820.h> +#include <asm/e820/api.h> #include <asm/amd_nb.h> #include <asm/gart.h> #include "agp.h"
Signature · 1 line
2.7.4
PATCH 4/50 x86/boot/e820: Split minimal UAPI types out into uapi/asm/e820/types.h
In reply to Ingo Molnarbootparam.h, which defines the legacy 'zeropage' boot parameter area, requires a small amount of e280 defines in the UAPI space - provide them.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/acpi.h | 2 ++ arch/x86/include/asm/e820/types.h | 15 ++------------- arch/x86/include/uapi/asm/bootparam.h | 2 +- arch/x86/include/uapi/asm/e820/types.h | 21 +++++++++++++++++++++ 4 files changed, 26 insertions(+), 14 deletions(-)
arch/x86/include/asm/acpi.h +2 -0
@@ -52,6 +52,8 @@ extern u8 acpi_sci_flags;extern int acpi_sci_override_gsi;void acpi_pic_sci_set_trigger (unsigned int ,u16 ); +struct device ; +extern int (*__acpi_register_gsi)(struct device *dev,u32 gsi,int trigger,int polarity);extern void (*__acpi_unregister_gsi)(u32 gsi);
arch/x86/include/asm/e820/types.h +2 -13
@@ -1,12 +1,11 @@#ifndef _ASM_E820_TYPES_H#define _ASM_E820_TYPES_H +#include <uapi/asm/e820/types.h> +/* Our map: */ #define E820MAP 0x2d0 -/* The maximum number of entries in E820MAP: */ -#define E820MAX 128 -/* * The legacy E820 BIOS limits us to 128 (E820MAX) nodes due to the * constrained space in the zeropage.
@@ -69,16 +68,6 @@#include <linux/types.h> /* -* A single E820 map entry, describing a memory range of [addr...addr+size-1], -* of 'type' memory type: -*/ -struct e820entry { -__u64 addr; -__u64 size; -__u32 type; -} __attribute__((packed)); - -/* * The whole array of E820 entries: */ struct e820map {
arch/x86/include/uapi/asm/bootparam.h +1 -1
@@ -34,7 +34,7 @@#include <linux/screen_info.h> #include <linux/apm_bios.h> #include <linux/edd.h> -#include <asm/e820/api.h> +#include <uapi/asm/e820/types.h> #include <asm/ist.h> #include <video/edid.h>
arch/x86/include/uapi/asm/e820/types.h new file +21 -0
@@ -0,0 +1,21 @@ +#ifndef _UAPI_ASM_E820_TYPES_H +#define _UAPI_ASM_E820_TYPES_H + +/* The maximum number of entries in E820MAP: */ +#define E820MAX 128 + +#ifndef __ASSEMBLY__ + +/* +* A single E820 map entry, describing a memory range of [addr...addr+size-1], +* of 'type' memory type: +*/ +struct e820entry { +__u64 addr; +__u64 size; +__u32 type; +} __attribute__((packed)); + +#endif /* __ASSEMBLY__ */ + +#endif /* _UAPI_ASM_E820_TYPES_H */
Signature · 1 line
2.7.4
PATCH 5/50 x86/boot/e820: Clean up the E820_X_MAX definition
In reply to Ingo MolnarE820_X_MAX is defined in a somewhat messy fashion:
- there's a pretty pointless looking #ifndef __KERNEL__ define that makes no sense in the non-UAPI header anymore,
- part of it is defined in api.h, which is not for type definitions,
- plus it's defined in two headers and the main explanation is in the header where we don't have the real definition.
So move it into a single place in e820/types.h and get rid of the !__KERNEL__ case altogether. Drop the smaller comment - the larger one explains it just fine.
Note that the zeropage does not use E820_X_MAX, it uses the legacy 128 entries definition.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 9 --------- arch/x86/include/asm/e820/types.h | 13 +++++++------ 2 files changed, 7 insertions(+), 15 deletions(-)
arch/x86/include/asm/e820/api.h +0 -9
@@ -1,15 +1,6 @@#ifndef _ASM_E820_API_H#define _ASM_E820_API_H -/* -* E820_X_MAX is the maximum size of the extended E820 table. The extended -* table may contain up to 3 extra E820 entries per possible NUMA node, so we -* make room for 3 * MAX_NUMNODES possible entries, beyond the standard 128. -* Also note that E820_X_MAX *must* be defined before we include asm/e820/types.h. -*/ -#include <linux/numa.h> -#define E820_X_MAX (E820MAX + 3 * MAX_NUMNODES) -#include <asm/e820/types.h> #ifndef __ASSEMBLY__
arch/x86/include/asm/e820/types.h +7 -6
@@ -3,9 +3,6 @@#include <uapi/asm/e820/types.h> -/* Our map: */ -#define E820MAP 0x2d0 -/* * The legacy E820 BIOS limits us to 128 (E820MAX) nodes due to the * constrained space in the zeropage.
@@ -31,9 +28,13 @@* to allow more than three entries per node or otherwise refine * this size. */ -#ifndef __KERNEL__ -# define E820_X_MAX E820MAX -#endif + +#include <linux/numa.h> + +#define E820_X_MAX (E820MAX + 3*MAX_NUMNODES) + +/* Our map: */ +#define E820MAP 0x2d0/* Number of entries in E820MAP: */ #define E820NR 0x1e8
Signature · 1 line
2.7.4
PATCH 6/50 x86/boot/e820: Remove spurious asm/e820/api.h inclusions
In reply to Ingo MolnarA commonly used lowlevel x86 header, asm/pgtable.h, includes asm/e820/api.h spuriously, without making direct use of it.
Removing it is not simple: over the years various .c code learned to rely on this indirect inclusion.
Remove the unnecessary include - this should speed up the kernel build a bit, as a large header is not included anymore in totally unrelated code.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/boot/compressed/eboot.c | 2 ++ arch/x86/include/asm/pci_x86.h | 2 ++ arch/x86/include/asm/pgtable.h | 2 -- arch/x86/kernel/acpi/boot.c | 1 + arch/x86/kernel/apic/x2apic_uv_x.c | 1 + arch/x86/kernel/crash.c | 1 + arch/x86/kernel/kexec-bzimage64.c | 1 + arch/x86/mm/kasan_init_64.c | 1 + arch/x86/pci/pcbios.c | 2 ++ arch/x86/platform/efi/efi.c | 1 + arch/x86/platform/efi/quirks.c | 2 ++ arch/x86/power/hibernate_64.c | 1 + 12 files changed, 15 insertions(+), 2 deletions(-)
arch/x86/boot/compressed/eboot.c +2 -0
@@ -9,7 +9,9 @@#include <linux/efi.h> #include <linux/pci.h> +#include <asm/efi.h> +#include <asm/e820/types.h> #include <asm/setup.h> #include <asm/desc.h>
arch/x86/include/asm/pci_x86.h +2 -0
@@ -4,6 +4,8 @@* (c) 1999 Martin Mares <[email protected]> */ +#include <linux/ioport.h> +#undef DEBUG#ifdef DEBUG
arch/x86/include/asm/pgtable.h +0 -2
@@ -2,8 +2,6 @@#define _ASM_X86_PGTABLE_H#include <asm/page.h> -#include <asm/e820/api.h> -#include <asm/pgtable_types.h> /*
arch/x86/kernel/acpi/boot.c +1 -0
@@ -36,6 +36,7 @@#include <linux/ioport.h> #include <linux/pci.h> +#include <asm/e820/api.h> #include <asm/irqdomain.h> #include <asm/pci_x86.h> #include <asm/pgtable.h>
arch/x86/kernel/apic/x2apic_uv_x.c +1 -0
@@ -34,6 +34,7 @@#include <asm/uv/bios.h> #include <asm/uv/uv.h> #include <asm/apic.h> +#include <asm/e820/api.h> #include <asm/ipi.h> #include <asm/smp.h> #include <asm/x86_init.h>
arch/x86/kernel/crash.c +1 -0
@@ -29,6 +29,7 @@#include <asm/nmi.h> #include <asm/hw_irq.h> #include <asm/apic.h> +#include <asm/e820/types.h> #include <asm/io_apic.h> #include <asm/hpet.h> #include <linux/kdebug.h>
arch/x86/kernel/kexec-bzimage64.c +1 -0
@@ -25,6 +25,7 @@#include <asm/setup.h> #include <asm/crash.h> #include <asm/efi.h> +#include <asm/e820/api.h> #include <asm/kexec-bzimage64.h> #define MAX_ELFCOREHDR_STR_LEN 30/* elfcorehdr=0x<64bit-value> */
arch/x86/mm/kasan_init_64.c +1 -0
@@ -6,6 +6,7 @@#include <linux/sched.h> #include <linux/vmalloc.h> +#include <asm/e820/types.h> #include <asm/tlbflush.h> #include <asm/sections.h>
arch/x86/pci/pcbios.c +2 -0
@@ -7,7 +7,9 @@#include <linux/slab.h> #include <linux/module.h> #include <linux/uaccess.h> +#include <asm/pci_x86.h> +#include <asm/e820/types.h> #include <asm/pci-functions.h> #include <asm/cacheflush.h>
arch/x86/platform/efi/efi.c +1 -0
@@ -47,6 +47,7 @@#include <asm/setup.h> #include <asm/efi.h> +#include <asm/e820/api.h> #include <asm/time.h> #include <asm/cacheflush.h> #include <asm/tlbflush.h>
arch/x86/platform/efi/quirks.c +2 -0
@@ -11,6 +11,8 @@#include <linux/bootmem.h> #include <linux/acpi.h> #include <linux/dmi.h> + +#include <asm/e820/api.h> #include <asm/efi.h> #include <asm/uv/uv.h>
arch/x86/power/hibernate_64.c +1 -0
@@ -16,6 +16,7 @@#include <crypto/hash.h> +#include <asm/e820/api.h> #include <asm/init.h> #include <asm/proto.h> #include <asm/page.h>
Signature · 1 line
2.7.4
PATCH 7/50 x86/boot/e820: Remove assembly guard from asm/e820/types.h
In reply to Ingo MolnarThere's an assembly guard in asm/e820/types.h, and only a single .S file includes this header: arch/x86/boot/header.S, but it does not actually make use of any of the E820 defines.
Remove the inclusion and remove the assembly guard as well.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/boot/header.S | 1 - arch/x86/include/asm/e820/types.h | 5 ----- 2 files changed, 6 deletions(-)
arch/x86/boot/header.S +0 -1
@@ -18,7 +18,6 @@ #include <asm/segment.h> #include <generated/utsrelease.h> #include <asm/boot.h> -#include <asm/e820/api.h> #include <asm/page_types.h> #include <asm/setup.h> #include <asm/bootparam.h>
arch/x86/include/asm/e820/types.h +0 -5
@@ -65,9 +65,6 @@*/ #define E820_RESERVED_KERN 128 -#ifndef __ASSEMBLY__ -#include <linux/types.h> -/* * The whole array of E820 entries: */
@@ -88,6 +85,4 @@ struct e820map {#define BIOS_ROM_BASE 0xffe00000#define BIOS_ROM_END 0xffffffff -#endif /* __ASSEMBLY__ */ -#endif /* _ASM_E820_TYPES_H */
Signature · 1 line
2.7.4
PATCH 8/50 x86/boot/e820: Clean up asm/e820/api.h
In reply to Ingo MolnarDo a number of easy cleanups:
- remove spurious linebreaks
- remove spurious whitespace differences and inconsistent tabulation
- remove unused and ugly 'struct setup_data;' pre-declaration
- make all exported functionality 'extern' consistently
- deobfuscate the (s,e) parameters of is_ISA_range(): (start, end)
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 46 ++++++++++++++++++---------------------------- 1 file changed, 18 insertions(+), 28 deletions(-)
arch/x86/include/asm/e820/api.h +18 -28
@@ -9,52 +9,42 @@ extern struct e820map *e820;extern struct e820map *e820_saved;extern unsigned long pci_mem_start; -extern int e820_any_mapped (u64 start,u64 end,unsigned type); -extern int e820_all_mapped (u64 start,u64 end,unsigned type); + +extern int e820_any_mapped (u64 start,u64 end,unsigned type); +extern int e820_all_mapped (u64 start,u64 end,unsigned type);extern void e820_add_region (u64 start,u64 size,int type);extern void e820_print_map (char *who); -extern int -sanitize_e820_map (struct e820entry *biosmap,int max_nr_map,u32 *pnr_map); -extern u64 e820_update_range (u64 start,u64 size,unsigned old_type, -unsigned new_type); -extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type, -int checktype); +extern int sanitize_e820_map (struct e820entry *biosmap,int max_nr_map,u32 *pnr_map); +extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type); +extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void update_e820 (void );extern void e820_setup_gap (void ); -struct setup_data ;extern void parse_e820_ext (u64 phys_addr,u32 data_len); - -#if defined(CONFIG_X86_64 ) || \ - (defined(CONFIG_X86_32 ) && defined(CONFIG_HIBERNATION )) -extern void e820_mark_nosave_regions (unsigned long limit_pfn); -#else -static inline void e820_mark_nosave_regions (unsigned long limit_pfn) -{ -} -#endif -extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void ); -extern u64 early_reserve_e820 (u64 sizet,u64 align); - -void memblock_x86_fill (void ); -void memblock_find_dma_reserve (void ); - +extern u64 early_reserve_e820 (u64 sizet,u64 align); +extern void memblock_x86_fill (void ); +extern void memblock_find_dma_reserve (void );extern void finish_e820_parsing (void );extern void e820_reserve_resources (void );extern void e820_reserve_resources_late (void );extern void setup_memory_map (void );extern char *default_machine_specific_memory_setup (void ); -extern void e820_reallocate_tables (void ); +#if defined(CONFIG_X86_64 ) || defined(CONFIG_X86_32 ) && defined(CONFIG_HIBERNATION ) +extern void e820_mark_nosave_regions (unsigned long limit_pfn); +#else +static inline void e820_mark_nosave_regions (unsigned long limit_pfn) { } +#endif +/* -* Returns true iff the specified range [s,e) is completely contained inside +* Returns true iff the specified range [start,end) is completely contained inside * the ISA region. */ -static inline bool is_ISA_range (u64 s,u64 e) +static inline bool is_ISA_range (u64 start,u64 end) { -return s >=ISA_START_ADDRESS && e <=ISA_END_ADDRESS ; +return start >=ISA_START_ADDRESS && end <=ISA_END_ADDRESS ; }#endif /* __ASSEMBLY__ */
Signature · 1 line
2.7.4
PATCH 9/50 x86/boot/e820: Remove unnecessary __ASSEMBLY__ guard
In reply to Ingo Molnarasm/e820/api.h had a spurious __ASSEMBLY__ guard - but the API header is not included in any assembly files. Remove it.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 -- 1 file changed, 2 deletions(-)
arch/x86/include/asm/e820/api.h +0 -2
@@ -3,7 +3,6 @@#include <asm/e820/types.h> -#ifndef __ASSEMBLY__/* see comment in arch/x86/kernel/e820.c */ extern struct e820map *e820;extern struct e820map *e820_saved;
@@ -47,7 +46,6 @@ static inline bool is_ISA_range(u64 start, u64 end)return start >=ISA_START_ADDRESS && end <=ISA_END_ADDRESS ; } -#endif /* __ASSEMBLY__ */ #include <linux/ioport.h> #define HIGH_MEMORY (1024*1024)
Signature · 1 line
2.7.4
PATCH 10/50 x86/boot/e820: Move HIGH_MEMORY define to asm/e820/types.h
In reply to Ingo MolnarThe HIGH_MEMORY define was in the API header, while it conceptually belongs to the other physical memory ranges in the e820/types.h header.
Move it there - and also convert the 1MB address to hexa, so that it lines up more nicely with the other memory address values.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 1 - arch/x86/include/asm/e820/types.h | 4 +++- 2 files changed, 3 insertions(+), 2 deletions(-)
arch/x86/include/asm/e820/api.h +0 -1
@@ -48,5 +48,4 @@ static inline bool is_ISA_range(u64 start, u64 end)#include <linux/ioport.h> -#define HIGH_MEMORY (1024*1024)#endif /* _ASM_E820_API_H */
arch/x86/include/asm/e820/types.h +3 -1
@@ -74,7 +74,7 @@ struct e820map { };/* -* Various legacy ranges in physical memory: +* Various well-known legacy memory ranges in physical memory: */ #define ISA_START_ADDRESS 0x000a0000#define ISA_END_ADDRESS 0x00100000
@@ -82,6 +82,8 @@ struct e820map {#define BIOS_BEGIN 0x000a0000#define BIOS_END 0x00100000 +#define HIGH_MEMORY 0x00100000 +#define BIOS_ROM_BASE 0xffe00000#define BIOS_ROM_END 0xffffffff
Signature · 1 line
2.7.4
PATCH 11/50 x86/boot/e820: Rename the basic e820 data types to 'struct e820_entry' and 'struct e820_array'
In reply to Ingo MolnarThe 'e820entry' and 'e820map' names have various annoyances:
- the missing underscore departs from the usual kernel style and makes the code look weird,
- in the past I kept confusing the 'map' with the 'entry', because a 'map' is ambiguous in that regard,
- it's not really clear from the 'e820map' that this is a regular C array.
Rename them to 'struct e820_entry' and 'struct e820_array' accordingly.
( Leave the legacy UAPI header alone but do the rename in the bootparam.h
and e820/types.h file - outside tools relying on these defines should either adjust their code, or should use the legacy header, or should create their private copies for the definitions. )
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- Documentation/x86/zero-page.txt | 2 +- arch/x86/boot/compressed/eboot.c | 12 +++++----- arch/x86/boot/compressed/kaslr.c | 2 +- arch/x86/boot/memory.c | 4 ++-- arch/x86/include/asm/e820/api.h | 6 ++--- arch/x86/include/asm/e820/types.h | 4 ++-- arch/x86/include/uapi/asm/bootparam.h | 2 +- arch/x86/include/uapi/asm/e820/types.h | 2 +- arch/x86/kernel/crash.c | 8 +++---- arch/x86/kernel/e820.c | 64 +++++++++++++++++++++++++++--------------------------- arch/x86/kernel/kexec-bzimage64.c | 2 +- arch/x86/kernel/resource.c | 2 +- arch/x86/kernel/setup.c | 2 +- arch/x86/power/hibernate_64.c | 6 ++--- arch/x86/xen/setup.c | 12 +++++----- tools/lguest/lguest.c | 2 +- 16 files changed, 66 insertions(+), 66 deletions(-)
Documentation/x86/zero-page.txt +1 -1
@@ -34,5 +34,5 @@ Offset Proto Name Meaning 1EF/001 ALL sentinel Used to detect broken bootloaders 290/040 ALL edd_mbr_sig_buffer EDD MBR signatures 2D0/A00 ALL e820_map E820 memory map table - (array of struct e820entry) + (array of struct e820_entry) D00/1EC ALL eddbuf EDD data (array of struct edd_info)
arch/x86/boot/compressed/eboot.c +6 -6
@@ -900,7 +900,7 @@ static void add_e820ext(struct boot_params *params,unsigned long size; e820ext->type =SETUP_E820_EXT ; - e820ext->len = nr_entries *sizeof (struct e820entry ); + e820ext->len = nr_entries *sizeof (struct e820_entry ); e820ext->next =0 ; data = (struct setup_data *)(unsigned long )params->hdr.setup_data;
@@ -917,9 +917,9 @@ static void add_e820ext(struct boot_params *params,static efi_status_t setup_e820 (struct boot_params *params,struct setup_data *e820ext,u32 e820ext_size) { -struct e820entry *e820_map = ¶ms->e820_map[0 ]; +struct e820_entry *e820_map = ¶ms->e820_map[0 ];struct efi_info *efi = ¶ms->efi_info; -struct e820entry *prev =NULL ; +struct e820_entry *prev =NULL ;u32 nr_entries;u32 nr_desc;int i;
@@ -983,14 +983,14 @@ static efi_status_t setup_e820(struct boot_params *params, }if (nr_entries ==ARRAY_SIZE (params->e820_map)) { -u32 need = (nr_desc - i) *sizeof (struct e820entry ) + +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 */ - e820_map = (struct e820entry *)e820ext->data; + e820_map = (struct e820_entry *)e820ext->data; } e820_map->addr = d->phys_addr;
@@ -1019,7 +1019,7 @@ static efi_status_t alloc_e820ext(u32 nr_desc, struct setup_data **e820ext,unsigned long size; size =sizeof (struct setup_data ) + -sizeof (struct e820entry ) * nr_desc; +sizeof (struct e820_entry ) * nr_desc;if (*e820ext) {efi_call_early (free_pool, *e820ext);
arch/x86/boot/compressed/kaslr.c +1 -1
@@ -426,7 +426,7 @@ static unsigned long slots_fetch_random(void)return 0 ; } -static void process_e820_entry (struct e820entry *entry, +static void process_e820_entry (struct e820_entry *entry,unsigned long minimum,unsigned long image_size) {
arch/x86/boot/memory.c +2 -2
@@ -21,8 +21,8 @@ static int detect_memory_e820(void) {int count =0 ;struct biosregs ireg, oreg; -struct e820entry *desc = boot_params.e820_map; -static struct e820entry buf;/* static so it is zeroed */ +struct e820_entry *desc = boot_params.e820_map; +static struct e820_entry buf;/* static so it is zeroed */ initregs (&ireg); ireg.ax =0xe820 ;
arch/x86/include/asm/e820/api.h +3 -3
@@ -4,8 +4,8 @@#include <asm/e820/types.h> /* see comment in arch/x86/kernel/e820.c */ -extern struct e820map *e820; -extern struct e820map *e820_saved; +extern struct e820_array *e820; +extern struct e820_array *e820_saved;extern unsigned long pci_mem_start;
@@ -13,7 +13,7 @@ extern int e820_any_mapped(u64 start, u64 end, unsigned type);extern int e820_all_mapped (u64 start,u64 end,unsigned type);extern void e820_add_region (u64 start,u64 size,int type);extern void e820_print_map (char *who); -extern int sanitize_e820_map (struct e820entry *biosmap,int max_nr_map,u32 *pnr_map); +extern int sanitize_e820_map (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type);extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void update_e820 (void );
arch/x86/include/asm/e820/types.h +2 -2
@@ -68,9 +68,9 @@/* * The whole array of E820 entries: */ -struct e820map { +struct e820_array {__u32 nr_map; -struct e820entry map[E820_X_MAX ]; +struct e820_entry map[E820_X_MAX ]; };/*
arch/x86/include/uapi/asm/bootparam.h +1 -1
@@ -152,7 +152,7 @@ struct boot_params {struct setup_header hdr;/* setup header */ /* 0x1f1 */ __u8 _pad7[0x290 -0x1f1 -sizeof (struct setup_header )];__u32 edd_mbr_sig_buffer[EDD_MBR_SIG_MAX ];/* 0x290 */ -struct e820entry e820_map[E820MAX ];/* 0x2d0 */ +struct e820_entry e820_map[E820MAX ];/* 0x2d0 */ __u8 _pad8[48 ];/* 0xcd0 */ struct edd_info eddbuf[EDDMAXNR ];/* 0xd00 */ __u8 _pad9[276 ];/* 0xeec */
arch/x86/include/uapi/asm/e820/types.h +1 -1
@@ -10,7 +10,7 @@* A single E820 map entry, describing a memory range of [addr...addr+size-1], * of 'type' memory type: */ -struct e820entry { +struct e820_entry {__u64 addr;__u64 size;__u32 type;
arch/x86/kernel/crash.c +4 -4
@@ -504,7 +504,7 @@ static int prepare_elf_headers(struct kimage *image, void **addr,return ret; } -static int add_e820_entry (struct boot_params *params,struct e820entry *entry) +static int add_e820_entry (struct boot_params *params,struct e820_entry *entry) {unsigned int nr_e820_entries;
@@ -513,7 +513,7 @@ static int add_e820_entry(struct boot_params *params, struct e820entry *entry)return 1 ;memcpy (¶ms->e820_map[nr_e820_entries], entry, -sizeof (struct e820entry )); +sizeof (struct e820_entry )); params->e820_entries++;return 0 ; }
@@ -522,7 +522,7 @@ static int memmap_entry_callback(u64 start, u64 end, void *arg) {struct crash_memmap_data *cmd = arg;struct boot_params *params = cmd->params; -struct e820entry ei; +struct e820_entry ei; ei.addr = start; ei.size = end - start +1 ;
@@ -561,7 +561,7 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params) {int i, ret =0 ;unsigned long flags; -struct e820entry ei; +struct e820_entry ei;struct crash_memmap_data cmd;struct crash_mem *cmem;
arch/x86/kernel/e820.c +32 -32
215 lines not on this page · raw message
arch/x86/kernel/kexec-bzimage64.c +1 -1
@@ -108,7 +108,7 @@ static int setup_e820_entries(struct boot_params *params) params->e820_entries = nr_e820_entries;memcpy (¶ms->e820_map, &e820_saved->map, - nr_e820_entries *sizeof (struct e820entry )); + nr_e820_entries *sizeof (struct e820_entry ));return 0 ; }
arch/x86/kernel/resource.c +1 -1
@@ -25,7 +25,7 @@ static void resource_clip(struct resource *res, resource_size_t start,static void remove_e820_regions (struct resource *avail) {int i; -struct e820entry *entry; +struct e820_entry *entry;for (i =0 ; i < e820->nr_map; i++) { entry = &e820->map[i];
arch/x86/kernel/setup.c +1 -1
@@ -459,7 +459,7 @@ static void __init e820_reserve_setup_data(void) }sanitize_e820_map (e820->map,ARRAY_SIZE (e820->map), &e820->nr_map); -memcpy (e820_saved, e820,sizeof (struct e820map )); +memcpy (e820_saved, e820,sizeof (struct e820_array ));printk (KERN_INFO "extended physical RAM map:\n" );e820_print_map ("reserve setup_data" ); }
arch/x86/power/hibernate_64.c +3 -3
@@ -201,7 +201,7 @@ struct restore_data_record {* @map: the e820 map to be calculated * @buf: the md5 result to be stored to */ -static int get_e820_md5 (struct e820map *map,void *buf) +static int get_e820_md5 (struct e820_array *map,void *buf) {struct scatterlist sg;struct crypto_ahash *tfm;
@@ -214,8 +214,8 @@ static int get_e820_md5(struct e820map *map, void *buf) {AHASH_REQUEST_ON_STACK (req, tfm); - size = offsetof(struct e820map , map) - +sizeof (struct e820entry ) * map->nr_map; + size = offsetof(struct e820_array , map) + +sizeof (struct e820_entry ) * map->nr_map;ahash_request_set_tfm (req, tfm);sg_init_one (&sg, (u8 *)map, size);ahash_request_set_callback (req,0 ,NULL ,NULL );
arch/x86/xen/setup.c +6 -6
@@ -41,7 +41,7 @@ struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata;unsigned long xen_released_pages;/* E820 map used during setting up memory. */ -static struct e820entry xen_e820_map[E820_X_MAX ]__initdata ; +static struct e820_entry xen_e820_map[E820_X_MAX ]__initdata ;static u32 xen_e820_map_entries__initdata ;/*
@@ -198,7 +198,7 @@ void __init xen_inv_extra_mem(void)*/ static unsigned long __init xen_find_pfn_range (unsigned long *min_pfn) { -const struct e820entry *entry = xen_e820_map; +const struct e820_entry *entry = xen_e820_map;unsigned int i;unsigned long done =0 ;
@@ -457,7 +457,7 @@ static unsigned long __init xen_foreach_remap_area(unsigned long nr_pages, {phys_addr_t start =0 ;unsigned long ret_val =0 ; -const struct e820entry *entry = xen_e820_map; +const struct e820_entry *entry = xen_e820_map;int i;/*
@@ -601,7 +601,7 @@ static void __init xen_align_and_add_e820_region(phys_addr_t start,static void __init xen_ignore_unusable (void ) { -struct e820entry *entry = xen_e820_map; +struct e820_entry *entry = xen_e820_map;unsigned int i;for (i =0 ; i < xen_e820_map_entries; i++, entry++) {
@@ -612,7 +612,7 @@ static void __init xen_ignore_unusable(void)bool __init xen_is_e820_reserved (phys_addr_t start,phys_addr_t size) { -struct e820entry *entry; +struct e820_entry *entry;unsigned mapcnt;phys_addr_t end;
@@ -645,7 +645,7 @@ phys_addr_t __init xen_find_free_area(phys_addr_t size) {unsigned mapcnt;phys_addr_t addr, start; -struct e820entry *entry = xen_e820_map; +struct e820_entry *entry = xen_e820_map;for (mapcnt =0 ; mapcnt < xen_e820_map_entries; mapcnt++, entry++) {if (entry->type !=E820_RAM || entry->size < size)
tools/lguest/lguest.c +1 -1
@@ -3339,7 +3339,7 @@ int main(int argc, char *argv[])* simple, single region. */ boot->e820_entries =1 ; - boot->e820_map[0 ] = ((struct e820entry ) {0 , mem,E820_RAM }); + boot->e820_map[0 ] = ((struct e820_entry ) {0 , mem,E820_RAM });/* * The boot header contains a command line pointer: we put the command * line after the boot header.
Signature · 1 line
2.7.4
PATCH 12/50 x86/boot/e820: Remove unnecessary #include <linux/ioport.h> from asm/e820/api.h
In reply to Ingo MolnarThere's a completely unnecessary inclusion of linux/ioport.h near the end of the asm/e820/api.h file.
Remove it and fix up unrelated code that learned to rely on this spurious inclusion of a generic header.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 -- arch/x86/mm/ioremap.c | 1 + arch/x86/mm/pat.c | 1 + 3 files changed, 2 insertions(+), 2 deletions(-)
arch/x86/include/asm/e820/api.h +0 -2
@@ -46,6 +46,4 @@ static inline bool is_ISA_range(u64 start, u64 end) return start >= ISA_START_ADDRESS && end <= ISA_END_ADDRESS; } -#include <linux/ioport.h> -#endif /* _ASM_E820_API_H */
arch/x86/mm/ioremap.c +1 -0
@@ -9,6 +9,7 @@#include <linux/bootmem.h> #include <linux/init.h> #include <linux/io.h> +#include <linux/ioport.h> #include <linux/slab.h> #include <linux/vmalloc.h> #include <linux/mmiotrace.h>
arch/x86/mm/pat.c +1 -0
@@ -10,6 +10,7 @@#include <linux/seq_file.h> #include <linux/bootmem.h> #include <linux/debugfs.h> +#include <linux/ioport.h> #include <linux/kernel.h> #include <linux/pfn_t.h> #include <linux/slab.h>
Signature · 1 line
2.7.4
PATCH 13/50 x86/boot/e820: Remove e820_mark_nosave_regions() definition uglies
In reply to Ingo MolnarThe e820_mark_nosave_regions definition has a number of ugly #ifdef conditions that unnecessarily uglify both the header and the e820.c file.
Make this function unconditional: most distro kernels have hibernation enabled. If LTO functionality is added in the future it will be able to eliminate unused functions without uglifying the source code.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 5 ----- arch/x86/kernel/e820.c | 3 --- 2 files changed, 8 deletions(-)
arch/x86/include/asm/e820/api.h +0 -5
@@ -30,12 +30,7 @@ extern void e820_reserve_resources_late(void);extern void setup_memory_map (void );extern char *default_machine_specific_memory_setup (void );extern void e820_reallocate_tables (void ); - -#if defined(CONFIG_X86_64 ) || defined(CONFIG_X86_32 ) && defined(CONFIG_HIBERNATION )extern void e820_mark_nosave_regions (unsigned long limit_pfn); -#else -static inline void e820_mark_nosave_regions (unsigned long limit_pfn) { } -#endif /* * Returns true iff the specified range [start,end) is completely contained inside
arch/x86/kernel/e820.c +0 -3
@@ -696,8 +696,6 @@ void __init parse_e820_ext(u64 phys_addr, u32 data_len)e820_print_map ("extended" ); } -#if defined(CONFIG_X86_64 ) || \ - (defined(CONFIG_X86_32 ) && defined(CONFIG_HIBERNATION ))/** * Find the ranges of physical addresses that do not correspond to * e820 RAM areas and mark the corresponding pages as nosave for
@@ -726,7 +724,6 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn)break ; } } -#endif #ifdef CONFIG_ACPI /**
Signature · 1 line
2.7.4
PATCH 14/50 x86/boot/e820: Rename 'e820_map' variables to 'e820_array'
In reply to Ingo MolnarIn line with the rename to 'struct e820_array', harmonize the naming of common e820 table variable names as well:
e820 => e820_array e820_saved => e820_array_saved e820_map => e820_array initial_e820 => e820_array_init
This makes the variable names more consistent and easier to grep for.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- Documentation/x86/zero-page.txt | 4 +- arch/x86/boot/compressed/eboot.c | 22 ++++---- arch/x86/boot/compressed/kaslr.c | 2 +- arch/x86/boot/memory.c | 4 +- arch/x86/include/asm/e820/api.h | 6 +-- arch/x86/include/asm/e820/types.h | 2 +- arch/x86/include/uapi/asm/bootparam.h | 2 +- arch/x86/kernel/crash.c | 2 +- arch/x86/kernel/e820.c | 148 +++++++++++++++++++++++++++--------------------------- arch/x86/kernel/early-quirks.c | 2 +- arch/x86/kernel/kexec-bzimage64.c | 10 ++-- arch/x86/kernel/resource.c | 4 +- arch/x86/kernel/setup.c | 10 ++-- arch/x86/kernel/tboot.c | 8 +-- arch/x86/lguest/boot.c | 6 +-- arch/x86/platform/efi/efi.c | 2 +- arch/x86/power/hibernate_64.c | 4 +- arch/x86/xen/setup.c | 76 ++++++++++++++-------------- tools/lguest/lguest.c | 2 +- 19 files changed, 158 insertions(+), 158 deletions(-)
Documentation/x86/zero-page.txt +2 -2
@@ -27,12 +27,12 @@ Offset Proto Name Meaning 1C0/020 ALL efi_info EFI 32 information (struct efi_info) 1E0/004 ALL alk_mem_k Alternative mem check, in KB 1E4/004 ALL scratch Scratch field for the kernel setup code -1E8/001 ALL e820_entries Number of entries in e820_map (below) +1E8/001 ALL e820_entries Number of entries in e820_array (below) 1E9/001 ALL eddbuf_entries Number of entries in eddbuf (below) 1EA/001 ALL edd_mbr_sig_buf_entries Number of entries in edd_mbr_sig_buffer (below) 1EF/001 ALL sentinel Used to detect broken bootloaders 290/040 ALL edd_mbr_sig_buffer EDD MBR signatures -2D0/A00 ALL e820_map E820 memory map table +2D0/A00 ALL e820_array E820 memory map table (array of struct e820_entry) D00/1EC ALL eddbuf EDD data (array of struct edd_info)
arch/x86/boot/compressed/eboot.c +11 -11
@@ -917,7 +917,7 @@ static void add_e820ext(struct boot_params *params,static efi_status_t setup_e820 (struct boot_params *params,struct setup_data *e820ext,u32 e820ext_size) { -struct e820_entry *e820_map = ¶ms->e820_map[0 ]; +struct e820_entry *e820_array = ¶ms->e820_array[0 ];struct efi_info *efi = ¶ms->efi_info;struct e820_entry *prev =NULL ;u32 nr_entries;
@@ -982,7 +982,7 @@ static efi_status_t setup_e820(struct boot_params *params,continue ; } -if (nr_entries ==ARRAY_SIZE (params->e820_map)) { +if (nr_entries ==ARRAY_SIZE (params->e820_array)) {u32 need = (nr_desc - i) *sizeof (struct e820_entry ) +sizeof (struct setup_data );
@@ -990,18 +990,18 @@ static efi_status_t setup_e820(struct boot_params *params,return EFI_BUFFER_TOO_SMALL ;/* boot_params map full, switch to e820 extended */ - e820_map = (struct e820_entry *)e820ext->data; + e820_array = (struct e820_entry *)e820ext->data; } - e820_map->addr = d->phys_addr; - e820_map->size = d->num_pages <<PAGE_SHIFT ; - e820_map->type = e820_type; - prev = e820_map++; + e820_array->addr = d->phys_addr; + e820_array->size = d->num_pages <<PAGE_SHIFT ; + e820_array->type = e820_type; + prev = e820_array++; nr_entries++; } -if (nr_entries >ARRAY_SIZE (params->e820_map)) { -u32 nr_e820ext = nr_entries -ARRAY_SIZE (params->e820_map); +if (nr_entries >ARRAY_SIZE (params->e820_array)) { +u32 nr_e820ext = nr_entries -ARRAY_SIZE (params->e820_array);add_e820ext (params, e820ext, nr_e820ext); nr_entries -= nr_e820ext;
@@ -1055,9 +1055,9 @@ static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg,if (first) { nr_desc = *map->buff_size / *map->desc_size; -if (nr_desc >ARRAY_SIZE (p->boot_params->e820_map)) { +if (nr_desc >ARRAY_SIZE (p->boot_params->e820_array)) {u32 nr_e820ext = nr_desc - -ARRAY_SIZE (p->boot_params->e820_map); +ARRAY_SIZE (p->boot_params->e820_array); status =alloc_e820ext (nr_e820ext, &p->e820ext, &p->e820ext_size);
arch/x86/boot/compressed/kaslr.c +1 -1
@@ -518,7 +518,7 @@ static unsigned long find_random_phys_addr(unsigned long minimum,/* Verify potential e820 positions, appending to slots list. */ for (i =0 ; i < boot_params->e820_entries; i++) { -process_e820_entry (&boot_params->e820_map[i], minimum, +process_e820_entry (&boot_params->e820_array[i], minimum, image_size);if (slot_area_index ==MAX_SLOT_AREA ) {debug_putstr ("Aborted e820 scan (slot_areas full)!\n" );
arch/x86/boot/memory.c +2 -2
@@ -21,7 +21,7 @@ static int detect_memory_e820(void) {int count =0 ;struct biosregs ireg, oreg; -struct e820_entry *desc = boot_params.e820_map; +struct e820_entry *desc = boot_params.e820_array;static struct e820_entry buf;/* static so it is zeroed */ initregs (&ireg);
@@ -66,7 +66,7 @@ static int detect_memory_e820(void) *desc++ = buf; count++; - }while (ireg.ebx && count <ARRAY_SIZE (boot_params.e820_map)); + }while (ireg.ebx && count <ARRAY_SIZE (boot_params.e820_array));return boot_params.e820_entries = count; }
arch/x86/include/asm/e820/api.h +3 -3
@@ -4,8 +4,8 @@#include <asm/e820/types.h> /* see comment in arch/x86/kernel/e820.c */ -extern struct e820_array *e820; -extern struct e820_array *e820_saved; +extern struct e820_array *e820_array; +extern struct e820_array *e820_array_saved;extern unsigned long pci_mem_start;
@@ -13,7 +13,7 @@ extern int e820_any_mapped(u64 start, u64 end, unsigned type);extern int e820_all_mapped (u64 start,u64 end,unsigned type);extern void e820_add_region (u64 start,u64 size,int type);extern void e820_print_map (char *who); -extern int sanitize_e820_map (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map); +extern int sanitize_e820_array (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type);extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void update_e820 (void );
arch/x86/include/asm/e820/types.h +1 -1
@@ -21,7 +21,7 @@* * This allows for bootstrap/firmware quirks such as possible duplicate * E820 entries that might need room in the same arrays, prior to the -* call to sanitize_e820_map() to remove duplicates. The allowance +* call to sanitize_e820_array() to remove duplicates. The allowance * of three memory map entries per node is "enough" entries for * the initial hardware platform motivating this mechanism to make * use of additional EFI map entries. Future platforms may want
arch/x86/include/uapi/asm/bootparam.h +1 -1
@@ -152,7 +152,7 @@ struct boot_params {struct setup_header hdr;/* setup header */ /* 0x1f1 */ __u8 _pad7[0x290 -0x1f1 -sizeof (struct setup_header )];__u32 edd_mbr_sig_buffer[EDD_MBR_SIG_MAX ];/* 0x290 */ -struct e820_entry e820_map[E820MAX ];/* 0x2d0 */ +struct e820_entry e820_array[E820MAX ];/* 0x2d0 */ __u8 _pad8[48 ];/* 0xcd0 */ struct edd_info eddbuf[EDDMAXNR ];/* 0xd00 */ __u8 _pad9[276 ];/* 0xeec */
arch/x86/kernel/crash.c +1 -1
@@ -512,7 +512,7 @@ static int add_e820_entry(struct boot_params *params, struct e820_entry *entry)if (nr_e820_entries >=E820MAX )return 1 ; -memcpy (¶ms->e820_map[nr_e820_entries], entry, +memcpy (¶ms->e820_array[nr_e820_entries], entry,sizeof (struct e820_entry )); params->e820_entries++;return 0 ;
arch/x86/kernel/e820.c +74 -74
394 lines not on this page · raw message
arch/x86/kernel/early-quirks.c +1 -1
@@ -547,7 +547,7 @@ intel_graphics_stolen(int num, int slot, int func,/* Mark this space as reserved */ e820_add_region (base, size,E820_RESERVED ); -sanitize_e820_map (e820->map,ARRAY_SIZE (e820->map), &e820->nr_map); +sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); }static void __init intel_graphics_quirks (int num,int slot,int func)
arch/x86/kernel/kexec-bzimage64.c +5 -5
@@ -100,14 +100,14 @@ static int setup_e820_entries(struct boot_params *params) {unsigned int nr_e820_entries; - nr_e820_entries = e820_saved->nr_map; + nr_e820_entries = e820_array_saved->nr_map;/* TODO: Pass entries more than E820MAX in bootparams setup data */ if (nr_e820_entries >E820MAX ) nr_e820_entries =E820MAX ; params->e820_entries = nr_e820_entries; -memcpy (¶ms->e820_map, &e820_saved->map, +memcpy (¶ms->e820_array, &e820_array_saved->map, nr_e820_entries *sizeof (struct e820_entry ));return 0 ;
@@ -233,10 +233,10 @@ setup_boot_parameters(struct kimage *image, struct boot_params *params, nr_e820_entries = params->e820_entries;for (i =0 ; i < nr_e820_entries; i++) { -if (params->e820_map[i].type !=E820_RAM ) +if (params->e820_array[i].type !=E820_RAM )continue ; - start = params->e820_map[i].addr; - end = params->e820_map[i].addr + params->e820_map[i].size -1 ; + start = params->e820_array[i].addr; + end = params->e820_array[i].addr + params->e820_array[i].size -1 ;if ((start <=0x100000 ) && end >0x100000 ) { mem_k = (end >>10 ) - (0x100000 >>10 );
arch/x86/kernel/resource.c +2 -2
@@ -27,8 +27,8 @@ static void remove_e820_regions(struct resource *avail)int i;struct e820_entry *entry; -for (i =0 ; i < e820->nr_map; i++) { - entry = &e820->map[i]; +for (i =0 ; i < e820_array->nr_map; i++) { + entry = &e820_array->map[i];resource_clip (avail, entry->addr, entry->addr + entry->size -1 );
arch/x86/kernel/setup.c +5 -5
@@ -458,8 +458,8 @@ static void __init e820_reserve_setup_data(void)early_memunmap (data,sizeof (*data)); } -sanitize_e820_map (e820->map,ARRAY_SIZE (e820->map), &e820->nr_map); -memcpy (e820_saved, e820,sizeof (struct e820_array )); +sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); +memcpy (e820_array_saved, e820_array,sizeof (struct e820_array ));printk (KERN_INFO "extended physical RAM map:\n" );e820_print_map ("reserve setup_data" ); }
@@ -763,7 +763,7 @@ static void __init trim_bios_range(void)*/ e820_remove_range (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_RAM ,1 ); -sanitize_e820_map (e820->map,ARRAY_SIZE (e820->map), &e820->nr_map); +sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); }/* called before trim_bios_range() to spare extra sanitize */
@@ -1026,7 +1026,7 @@ void __init setup_arch(char **cmdline_p)early_dump_pci_devices ();#endif -/* update the e820_saved too */ +/* update the e820_array_saved too */ e820_reserve_setup_data ();finish_e820_parsing ();
@@ -1056,7 +1056,7 @@ void __init setup_arch(char **cmdline_p)if (ppro_with_ram_bug ()) {e820_update_range (0x70000000ULL ,0x40000ULL ,E820_RAM ,E820_RESERVED ); -sanitize_e820_map (e820->map,ARRAY_SIZE (e820->map), &e820->nr_map); +sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map);printk (KERN_INFO "fixed physical RAM map:\n" );e820_print_map ("bad_ppro" ); }
arch/x86/kernel/tboot.c +4 -4
@@ -188,12 +188,12 @@ static int tboot_setup_sleep(void) tboot->num_mac_regions =0 ; -for (i =0 ; i < e820->nr_map; i++) { -if ((e820->map[i].type !=E820_RAM ) - && (e820->map[i].type !=E820_RESERVED_KERN )) +for (i =0 ; i < e820_array->nr_map; i++) { +if ((e820_array->map[i].type !=E820_RAM ) + && (e820_array->map[i].type !=E820_RESERVED_KERN ))continue ; -add_mac_region (e820->map[i].addr, e820->map[i].size); +add_mac_region (e820_array->map[i].addr, e820_array->map[i].size); } tboot->acpi_sinfo.kernel_s3_resume_vector =
arch/x86/lguest/boot.c +3 -3
@@ -1178,9 +1178,9 @@ static __init char *lguest_memory_setup(void)* The Linux bootloader header contains an "e820" memory map: the * Launcher populated the first entry with our memory limit. */ -e820_add_region (boot_params.e820_map[0 ].addr, - boot_params.e820_map[0 ].size, - boot_params.e820_map[0 ].type); +e820_add_region (boot_params.e820_array[0 ].addr, + boot_params.e820_array[0 ].size, + boot_params.e820_array[0 ].type);/* This string is for the boot messages. */ return "LGUEST" ;
arch/x86/platform/efi/efi.c +1 -1
@@ -167,7 +167,7 @@ static void __init do_add_efi_memmap(void) }e820_add_region (start, size, e820_type); } -sanitize_e820_map (e820->map,ARRAY_SIZE (e820->map), &e820->nr_map); +sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); }int __init efi_memblock_x86_reserve_range (void )
arch/x86/power/hibernate_64.c +2 -2
@@ -232,7 +232,7 @@ static int get_e820_md5(struct e820_array *map, void *buf)static void hibernation_e820_save (void *buf) { -get_e820_md5 (e820_saved, buf); +get_e820_md5 (e820_array_saved, buf); }static bool hibernation_e820_mismatch (void *buf)
@@ -245,7 +245,7 @@ static bool hibernation_e820_mismatch(void *buf)if (!memcmp (result, buf,MD5_DIGEST_SIZE ))return false; - ret =get_e820_md5 (e820_saved, result); + ret =get_e820_md5 (e820_array_saved, result);if (ret)return true;
arch/x86/xen/setup.c +38 -38
183 lines not on this page · raw message
tools/lguest/lguest.c +1 -1
@@ -3339,7 +3339,7 @@ int main(int argc, char *argv[])* simple, single region. */ boot->e820_entries =1 ; - boot->e820_map[0 ] = ((struct e820_entry ) {0 , mem,E820_RAM }); + boot->e820_array[0 ] = ((struct e820_entry ) {0 , mem,E820_RAM });/* * The boot header contains a command line pointer: we put the command * line after the boot header.
Signature · 1 line
2.7.4
PATCH 15/50 x86/boot/e820: Rename everything to e820_table
In reply to Ingo MolnarNo change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- Documentation/x86/zero-page.txt | 4 +- arch/x86/boot/compressed/eboot.c | 22 ++++---- arch/x86/boot/compressed/kaslr.c | 2 +- arch/x86/boot/memory.c | 4 +- arch/x86/include/asm/e820/api.h | 6 +-- arch/x86/include/asm/e820/types.h | 4 +- arch/x86/include/uapi/asm/bootparam.h | 2 +- arch/x86/kernel/crash.c | 2 +- arch/x86/kernel/e820.c | 152 +++++++++++++++++++++++++++--------------------------- arch/x86/kernel/early-quirks.c | 2 +- arch/x86/kernel/kexec-bzimage64.c | 10 ++-- arch/x86/kernel/resource.c | 4 +- arch/x86/kernel/setup.c | 10 ++-- arch/x86/kernel/tboot.c | 8 +-- arch/x86/lguest/boot.c | 6 +-- arch/x86/platform/efi/efi.c | 2 +- arch/x86/power/hibernate_64.c | 8 +-- arch/x86/xen/setup.c | 76 +++++++++++++-------------- tools/lguest/lguest.c | 2 +- 19 files changed, 163 insertions(+), 163 deletions(-)
Documentation/x86/zero-page.txt +2 -2
@@ -27,12 +27,12 @@ Offset Proto Name Meaning 1C0/020 ALL efi_info EFI 32 information (struct efi_info) 1E0/004 ALL alk_mem_k Alternative mem check, in KB 1E4/004 ALL scratch Scratch field for the kernel setup code -1E8/001 ALL e820_entries Number of entries in e820_array (below) +1E8/001 ALL e820_entries Number of entries in e820_table (below) 1E9/001 ALL eddbuf_entries Number of entries in eddbuf (below) 1EA/001 ALL edd_mbr_sig_buf_entries Number of entries in edd_mbr_sig_buffer (below) 1EF/001 ALL sentinel Used to detect broken bootloaders 290/040 ALL edd_mbr_sig_buffer EDD MBR signatures -2D0/A00 ALL e820_array E820 memory map table +2D0/A00 ALL e820_table E820 memory map table (array of struct e820_entry) D00/1EC ALL eddbuf EDD data (array of struct edd_info)
arch/x86/boot/compressed/eboot.c +11 -11
@@ -917,7 +917,7 @@ static void add_e820ext(struct boot_params *params,static efi_status_t setup_e820 (struct boot_params *params,struct setup_data *e820ext,u32 e820ext_size) { -struct e820_entry *e820_array = ¶ms->e820_array[0 ]; +struct e820_entry *e820_table = ¶ms->e820_table[0 ];struct efi_info *efi = ¶ms->efi_info;struct e820_entry *prev =NULL ;u32 nr_entries;
@@ -982,7 +982,7 @@ static efi_status_t setup_e820(struct boot_params *params,continue ; } -if (nr_entries ==ARRAY_SIZE (params->e820_array)) { +if (nr_entries ==ARRAY_SIZE (params->e820_table)) {u32 need = (nr_desc - i) *sizeof (struct e820_entry ) +sizeof (struct setup_data );
@@ -990,18 +990,18 @@ static efi_status_t setup_e820(struct boot_params *params,return EFI_BUFFER_TOO_SMALL ;/* boot_params map full, switch to e820 extended */ - e820_array = (struct e820_entry *)e820ext->data; + e820_table = (struct e820_entry *)e820ext->data; } - e820_array->addr = d->phys_addr; - e820_array->size = d->num_pages <<PAGE_SHIFT ; - e820_array->type = e820_type; - prev = e820_array++; + e820_table->addr = d->phys_addr; + e820_table->size = d->num_pages <<PAGE_SHIFT ; + e820_table->type = e820_type; + prev = e820_table++; nr_entries++; } -if (nr_entries >ARRAY_SIZE (params->e820_array)) { -u32 nr_e820ext = nr_entries -ARRAY_SIZE (params->e820_array); +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;
@@ -1055,9 +1055,9 @@ static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg,if (first) { nr_desc = *map->buff_size / *map->desc_size; -if (nr_desc >ARRAY_SIZE (p->boot_params->e820_array)) { +if (nr_desc >ARRAY_SIZE (p->boot_params->e820_table)) {u32 nr_e820ext = nr_desc - -ARRAY_SIZE (p->boot_params->e820_array); +ARRAY_SIZE (p->boot_params->e820_table); status =alloc_e820ext (nr_e820ext, &p->e820ext, &p->e820ext_size);
arch/x86/boot/compressed/kaslr.c +1 -1
@@ -518,7 +518,7 @@ static unsigned long find_random_phys_addr(unsigned long minimum,/* Verify potential e820 positions, appending to slots list. */ for (i =0 ; i < boot_params->e820_entries; i++) { -process_e820_entry (&boot_params->e820_array[i], minimum, +process_e820_entry (&boot_params->e820_table[i], minimum, image_size);if (slot_area_index ==MAX_SLOT_AREA ) {debug_putstr ("Aborted e820 scan (slot_areas full)!\n" );
arch/x86/boot/memory.c +2 -2
@@ -21,7 +21,7 @@ static int detect_memory_e820(void) {int count =0 ;struct biosregs ireg, oreg; -struct e820_entry *desc = boot_params.e820_array; +struct e820_entry *desc = boot_params.e820_table;static struct e820_entry buf;/* static so it is zeroed */ initregs (&ireg);
@@ -66,7 +66,7 @@ static int detect_memory_e820(void) *desc++ = buf; count++; - }while (ireg.ebx && count <ARRAY_SIZE (boot_params.e820_array)); + }while (ireg.ebx && count <ARRAY_SIZE (boot_params.e820_table));return boot_params.e820_entries = count; }
arch/x86/include/asm/e820/api.h +3 -3
@@ -4,8 +4,8 @@#include <asm/e820/types.h> /* see comment in arch/x86/kernel/e820.c */ -extern struct e820_array *e820_array; -extern struct e820_array *e820_array_saved; +extern struct e820_table *e820_table; +extern struct e820_table *e820_table_saved;extern unsigned long pci_mem_start;
@@ -13,7 +13,7 @@ extern int e820_any_mapped(u64 start, u64 end, unsigned type);extern int e820_all_mapped (u64 start,u64 end,unsigned type);extern void e820_add_region (u64 start,u64 size,int type);extern void e820_print_map (char *who); -extern int sanitize_e820_array (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map); +extern int sanitize_e820_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type);extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void update_e820 (void );
arch/x86/include/asm/e820/types.h +2 -2
@@ -21,7 +21,7 @@* * This allows for bootstrap/firmware quirks such as possible duplicate * E820 entries that might need room in the same arrays, prior to the -* call to sanitize_e820_array() to remove duplicates. The allowance +* call to sanitize_e820_table() to remove duplicates. The allowance * of three memory map entries per node is "enough" entries for * the initial hardware platform motivating this mechanism to make * use of additional EFI map entries. Future platforms may want
@@ -68,7 +68,7 @@/* * The whole array of E820 entries: */ -struct e820_array { +struct e820_table {__u32 nr_map;struct e820_entry map[E820_X_MAX ]; };
arch/x86/include/uapi/asm/bootparam.h +1 -1
@@ -152,7 +152,7 @@ struct boot_params {struct setup_header hdr;/* setup header */ /* 0x1f1 */ __u8 _pad7[0x290 -0x1f1 -sizeof (struct setup_header )];__u32 edd_mbr_sig_buffer[EDD_MBR_SIG_MAX ];/* 0x290 */ -struct e820_entry e820_array[E820MAX ];/* 0x2d0 */ +struct e820_entry e820_table[E820MAX ];/* 0x2d0 */ __u8 _pad8[48 ];/* 0xcd0 */ struct edd_info eddbuf[EDDMAXNR ];/* 0xd00 */ __u8 _pad9[276 ];/* 0xeec */
arch/x86/kernel/crash.c +1 -1
@@ -512,7 +512,7 @@ static int add_e820_entry(struct boot_params *params, struct e820_entry *entry)if (nr_e820_entries >=E820MAX )return 1 ; -memcpy (¶ms->e820_array[nr_e820_entries], entry, +memcpy (¶ms->e820_table[nr_e820_entries], entry,sizeof (struct e820_entry )); params->e820_entries++;return 0 ;
arch/x86/kernel/e820.c +76 -76
405 lines not on this page · raw message
arch/x86/kernel/early-quirks.c +1 -1
@@ -547,7 +547,7 @@ intel_graphics_stolen(int num, int slot, int func,/* Mark this space as reserved */ e820_add_region (base, size,E820_RESERVED ); -sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); +sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); }static void __init intel_graphics_quirks (int num,int slot,int func)
arch/x86/kernel/kexec-bzimage64.c +5 -5
@@ -100,14 +100,14 @@ static int setup_e820_entries(struct boot_params *params) {unsigned int nr_e820_entries; - nr_e820_entries = e820_array_saved->nr_map; + nr_e820_entries = e820_table_saved->nr_map;/* TODO: Pass entries more than E820MAX in bootparams setup data */ if (nr_e820_entries >E820MAX ) nr_e820_entries =E820MAX ; params->e820_entries = nr_e820_entries; -memcpy (¶ms->e820_array, &e820_array_saved->map, +memcpy (¶ms->e820_table, &e820_table_saved->map, nr_e820_entries *sizeof (struct e820_entry ));return 0 ;
@@ -233,10 +233,10 @@ setup_boot_parameters(struct kimage *image, struct boot_params *params, nr_e820_entries = params->e820_entries;for (i =0 ; i < nr_e820_entries; i++) { -if (params->e820_array[i].type !=E820_RAM ) +if (params->e820_table[i].type !=E820_RAM )continue ; - start = params->e820_array[i].addr; - end = params->e820_array[i].addr + params->e820_array[i].size -1 ; + start = params->e820_table[i].addr; + end = params->e820_table[i].addr + params->e820_table[i].size -1 ;if ((start <=0x100000 ) && end >0x100000 ) { mem_k = (end >>10 ) - (0x100000 >>10 );
arch/x86/kernel/resource.c +2 -2
@@ -27,8 +27,8 @@ static void remove_e820_regions(struct resource *avail)int i;struct e820_entry *entry; -for (i =0 ; i < e820_array->nr_map; i++) { - entry = &e820_array->map[i]; +for (i =0 ; i < e820_table->nr_map; i++) { + entry = &e820_table->map[i];resource_clip (avail, entry->addr, entry->addr + entry->size -1 );
arch/x86/kernel/setup.c +5 -5
@@ -458,8 +458,8 @@ static void __init e820_reserve_setup_data(void)early_memunmap (data,sizeof (*data)); } -sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); -memcpy (e820_array_saved, e820_array,sizeof (struct e820_array )); +sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); +memcpy (e820_table_saved, e820_table,sizeof (struct e820_table ));printk (KERN_INFO "extended physical RAM map:\n" );e820_print_map ("reserve setup_data" ); }
@@ -763,7 +763,7 @@ static void __init trim_bios_range(void)*/ e820_remove_range (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_RAM ,1 ); -sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); +sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); }/* called before trim_bios_range() to spare extra sanitize */
@@ -1026,7 +1026,7 @@ void __init setup_arch(char **cmdline_p)early_dump_pci_devices ();#endif -/* update the e820_array_saved too */ +/* update the e820_table_saved too */ e820_reserve_setup_data ();finish_e820_parsing ();
@@ -1056,7 +1056,7 @@ void __init setup_arch(char **cmdline_p)if (ppro_with_ram_bug ()) {e820_update_range (0x70000000ULL ,0x40000ULL ,E820_RAM ,E820_RESERVED ); -sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); +sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map);printk (KERN_INFO "fixed physical RAM map:\n" );e820_print_map ("bad_ppro" ); }
arch/x86/kernel/tboot.c +4 -4
@@ -188,12 +188,12 @@ static int tboot_setup_sleep(void) tboot->num_mac_regions =0 ; -for (i =0 ; i < e820_array->nr_map; i++) { -if ((e820_array->map[i].type !=E820_RAM ) - && (e820_array->map[i].type !=E820_RESERVED_KERN )) +for (i =0 ; i < e820_table->nr_map; i++) { +if ((e820_table->map[i].type !=E820_RAM ) + && (e820_table->map[i].type !=E820_RESERVED_KERN ))continue ; -add_mac_region (e820_array->map[i].addr, e820_array->map[i].size); +add_mac_region (e820_table->map[i].addr, e820_table->map[i].size); } tboot->acpi_sinfo.kernel_s3_resume_vector =
arch/x86/lguest/boot.c +3 -3
@@ -1178,9 +1178,9 @@ static __init char *lguest_memory_setup(void)* The Linux bootloader header contains an "e820" memory map: the * Launcher populated the first entry with our memory limit. */ -e820_add_region (boot_params.e820_array[0 ].addr, - boot_params.e820_array[0 ].size, - boot_params.e820_array[0 ].type); +e820_add_region (boot_params.e820_table[0 ].addr, + boot_params.e820_table[0 ].size, + boot_params.e820_table[0 ].type);/* This string is for the boot messages. */ return "LGUEST" ;
arch/x86/platform/efi/efi.c +1 -1
@@ -167,7 +167,7 @@ static void __init do_add_efi_memmap(void) }e820_add_region (start, size, e820_type); } -sanitize_e820_array (e820_array->map,ARRAY_SIZE (e820_array->map), &e820_array->nr_map); +sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); }int __init efi_memblock_x86_reserve_range (void )
arch/x86/power/hibernate_64.c +4 -4
@@ -201,7 +201,7 @@ struct restore_data_record {* @map: the e820 map to be calculated * @buf: the md5 result to be stored to */ -static int get_e820_md5 (struct e820_array *map,void *buf) +static int get_e820_md5 (struct e820_table *map,void *buf) {struct scatterlist sg;struct crypto_ahash *tfm;
@@ -214,7 +214,7 @@ static int get_e820_md5(struct e820_array *map, void *buf) {AHASH_REQUEST_ON_STACK (req, tfm); - size = offsetof(struct e820_array , map) + size = offsetof(struct e820_table , map) +sizeof (struct e820_entry ) * map->nr_map;ahash_request_set_tfm (req, tfm);sg_init_one (&sg, (u8 *)map, size);
@@ -232,7 +232,7 @@ static int get_e820_md5(struct e820_array *map, void *buf)static void hibernation_e820_save (void *buf) { -get_e820_md5 (e820_array_saved, buf); +get_e820_md5 (e820_table_saved, buf); }static bool hibernation_e820_mismatch (void *buf)
@@ -245,7 +245,7 @@ static bool hibernation_e820_mismatch(void *buf)if (!memcmp (result, buf,MD5_DIGEST_SIZE ))return false; - ret =get_e820_md5 (e820_array_saved, result); + ret =get_e820_md5 (e820_table_saved, result);if (ret)return true;
arch/x86/xen/setup.c +38 -38
183 lines not on this page · raw message
tools/lguest/lguest.c +1 -1
@@ -3339,7 +3339,7 @@ int main(int argc, char *argv[])* simple, single region. */ boot->e820_entries =1 ; - boot->e820_array[0 ] = ((struct e820_entry ) {0 , mem,E820_RAM }); + boot->e820_table[0 ] = ((struct e820_entry ) {0 , mem,E820_RAM });/* * The boot header contains a command line pointer: we put the command * line after the boot header.
Signature · 1 line
2.7.4
PATCH 16/50 x86/boot/e820: Harmonize the 'struct e820_table' fields
In reply to Ingo MolnarSo the e820_table->map and e820_table->nr_map names are a bit confusing, because it's not clear what a 'map' really means (it could be a bitmap, or some other data structure), nor is it clear what nr_map means (is it a current index, or some other count).
Rename the fields from:
e820_table->map => e820_table->entries e820_table->nr_map => e820_table->nr_entries
which makes it abundantly clear that these are entries of the table, and that the size of the table is ->nr_entries.
Propagate the changes to all affected files. Where necessary, adjust local variable names to better reflect the new field names.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/types.h | 4 +-- arch/x86/kernel/e820.c | 114 +++++++++++++++++++++++++++++----------------------------- arch/x86/kernel/early-quirks.c | 2 +- arch/x86/kernel/kexec-bzimage64.c | 5 ++- arch/x86/kernel/resource.c | 4 +-- arch/x86/kernel/setup.c | 6 ++-- arch/x86/kernel/tboot.c | 8 ++--- arch/x86/platform/efi/efi.c | 2 +- arch/x86/power/hibernate_64.c | 11 +++--- arch/x86/xen/setup.c | 2 +- 10 files changed, 77 insertions(+), 81 deletions(-)
arch/x86/include/asm/e820/types.h +2 -2
@@ -69,8 +69,8 @@* The whole array of E820 entries: */ struct e820_table { -__u32 nr_map; -struct e820_entry map[E820_X_MAX ]; +__u32 nr_entries; +struct e820_entry entries[E820_X_MAX ]; };/*
arch/x86/kernel/e820.c +56 -58
295 lines not on this page · raw message
arch/x86/kernel/early-quirks.c +1 -1
@@ -547,7 +547,7 @@ intel_graphics_stolen(int num, int slot, int func,/* Mark this space as reserved */ e820_add_region (base, size,E820_RESERVED ); -sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); +sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }static void __init intel_graphics_quirks (int num,int slot,int func)
arch/x86/kernel/kexec-bzimage64.c +2 -3
@@ -100,15 +100,14 @@ static int setup_e820_entries(struct boot_params *params) {unsigned int nr_e820_entries; - nr_e820_entries = e820_table_saved->nr_map; + nr_e820_entries = e820_table_saved->nr_entries;/* TODO: Pass entries more than E820MAX in bootparams setup data */ if (nr_e820_entries >E820MAX ) nr_e820_entries =E820MAX ; params->e820_entries = nr_e820_entries; -memcpy (¶ms->e820_table, &e820_table_saved->map, - nr_e820_entries *sizeof (struct e820_entry )); +memcpy (¶ms->e820_table, &e820_table_saved->entries, nr_e820_entries*sizeof (struct e820_entry ));return 0 ; }
arch/x86/kernel/resource.c +2 -2
@@ -27,8 +27,8 @@ static void remove_e820_regions(struct resource *avail)int i;struct e820_entry *entry; -for (i =0 ; i < e820_table->nr_map; i++) { - entry = &e820_table->map[i]; +for (i =0 ; i < e820_table->nr_entries; i++) { + entry = &e820_table->entries[i];resource_clip (avail, entry->addr, entry->addr + entry->size -1 );
arch/x86/kernel/setup.c +3 -3
@@ -458,7 +458,7 @@ static void __init e820_reserve_setup_data(void)early_memunmap (data,sizeof (*data)); } -sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); +sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);memcpy (e820_table_saved, e820_table,sizeof (struct e820_table ));printk (KERN_INFO "extended physical RAM map:\n" );e820_print_map ("reserve setup_data" );
@@ -763,7 +763,7 @@ static void __init trim_bios_range(void)*/ e820_remove_range (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_RAM ,1 ); -sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); +sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }/* called before trim_bios_range() to spare extra sanitize */
@@ -1056,7 +1056,7 @@ void __init setup_arch(char **cmdline_p)if (ppro_with_ram_bug ()) {e820_update_range (0x70000000ULL ,0x40000ULL ,E820_RAM ,E820_RESERVED ); -sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); +sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);printk (KERN_INFO "fixed physical RAM map:\n" );e820_print_map ("bad_ppro" ); }
arch/x86/kernel/tboot.c +4 -4
@@ -188,12 +188,12 @@ static int tboot_setup_sleep(void) tboot->num_mac_regions =0 ; -for (i =0 ; i < e820_table->nr_map; i++) { -if ((e820_table->map[i].type !=E820_RAM ) - && (e820_table->map[i].type !=E820_RESERVED_KERN )) +for (i =0 ; i < e820_table->nr_entries; i++) { +if ((e820_table->entries[i].type !=E820_RAM ) + && (e820_table->entries[i].type !=E820_RESERVED_KERN ))continue ; -add_mac_region (e820_table->map[i].addr, e820_table->map[i].size); +add_mac_region (e820_table->entries[i].addr, e820_table->entries[i].size); } tboot->acpi_sinfo.kernel_s3_resume_vector =
arch/x86/platform/efi/efi.c +1 -1
@@ -167,7 +167,7 @@ static void __init do_add_efi_memmap(void) }e820_add_region (start, size, e820_type); } -sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); +sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }int __init efi_memblock_x86_reserve_range (void )
arch/x86/power/hibernate_64.c +5 -6
@@ -196,12 +196,12 @@ struct restore_data_record {#if IS_BUILTIN (CONFIG_CRYPTO_MD5 )/** -* get_e820_md5 - calculate md5 according to given e820 map +* get_e820_md5 - calculate md5 according to given e820 table * -* @map: the e820 map to be calculated +* @table: the e820 table to be calculated * @buf: the md5 result to be stored to */ -static int get_e820_md5 (struct e820_table *map,void *buf) +static int get_e820_md5 (struct e820_table *table,void *buf) {struct scatterlist sg;struct crypto_ahash *tfm;
@@ -214,10 +214,9 @@ static int get_e820_md5(struct e820_table *map, void *buf) {AHASH_REQUEST_ON_STACK (req, tfm); - size = offsetof(struct e820_table , map) - +sizeof (struct e820_entry ) * map->nr_map; + size = offsetof(struct e820_table , entries) +sizeof (struct e820_entry ) * table->nr_entries;ahash_request_set_tfm (req, tfm); -sg_init_one (&sg, (u8 *)map, size); +sg_init_one (&sg, (u8 *)table, size);ahash_request_set_callback (req,0 ,NULL ,NULL );ahash_request_set_crypt (req, &sg, buf, size);
arch/x86/xen/setup.c +1 -1
@@ -861,7 +861,7 @@ char * __init xen_memory_setup(void)e820_add_region (ISA_START_ADDRESS ,ISA_END_ADDRESS -ISA_START_ADDRESS ,E820_RESERVED ); -sanitize_e820_table (e820_table->map,ARRAY_SIZE (e820_table->map), &e820_table->nr_map); +sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);/* * Check whether the kernel itself conflicts with the target E820 map.
Signature · 1 line
2.7.4
PATCH 17/50 x86/boot/e820: Rename default_machine_specific_memory_setup() to e820__memory_setup_default()
In reply to Ingo MolnarThe default_machine_specific_memory_setup() is a mouthful and despite the many words it doesn't actually tell us clearly what it does.
The function is the x86 legacy memory layout setup code, based on E820-formatted memory layout information passed by the bootloader via the boot_params.
Rename it to e820__memory_setup_default() to better signal its purpose.
Also rename the related higher level function to be consistent with this new naming:
setup_memory_map() => e820__memory_setup()
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 4 ++-- arch/x86/kernel/e820.c | 9 +++++++-- arch/x86/kernel/setup.c | 2 +- arch/x86/kernel/x86_init.c | 2 +- 4 files changed, 11 insertions(+), 6 deletions(-)
arch/x86/include/asm/e820/api.h +2 -2
@@ -27,8 +27,8 @@ extern void memblock_find_dma_reserve(void);extern void finish_e820_parsing (void );extern void e820_reserve_resources (void );extern void e820_reserve_resources_late (void ); -extern void setup_memory_map (void ); -extern char *default_machine_specific_memory_setup (void ); +extern void e820__memory_setup (void ); +extern char *e820__memory_setup_default (void );extern void e820_reallocate_tables (void );extern void e820_mark_nosave_regions (unsigned long limit_pfn);
arch/x86/kernel/e820.c +7 -2
@@ -1097,7 +1097,7 @@ void __init e820_reserve_resources_late(void) } } -char *__init default_machine_specific_memory_setup (void ) +char *__init e820__memory_setup_default (void ) {char *who ="BIOS-e820" ;u32 new_nr;
@@ -1135,7 +1135,12 @@ char *__init default_machine_specific_memory_setup(void)return who; } -void __init setup_memory_map (void ) +/* +* Calls e820__memory_setup_default() in essence to pick up the firmware/bootloader +* E820 map - with an optional platform quirk available for virtual platforms +* to override this method of boot environment processing: +*/ +void __init e820__memory_setup (void ) {char *who;
arch/x86/kernel/setup.c +1 -1
@@ -937,7 +937,7 @@ void __init setup_arch(char **cmdline_p) x86_init.oem.arch_setup (); iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) -1 ; -setup_memory_map (); +e820__memory_setup ();parse_setup_data ();copy_edd ();
arch/x86/kernel/x86_init.c +1 -1
@@ -38,7 +38,7 @@ struct x86_init_ops x86_init __initdata = { .resources = { .probe_roms = probe_roms, .reserve_resources = reserve_standard_io_resources, - .memory_setup = default_machine_specific_memory_setup, + .memory_setup = e820__memory_setup_default, }, .mpparse = {
Signature · 1 line
2.7.4
PATCH 18/50 x86/boot/e820: Rename e820_table_saved to e820_table_firmware and improve the description
In reply to Ingo MolnarSo the 'e820_table_saved' is a bit of a misnomer that hides its real purpose.
At first sight the name suggests that it's some sort save/restore mechanism, as this is how we typically name such facilities in the kernel.
But that is not so, e820_table_saved is the original firmware version of the e820 table, not modified by the kernel. This table is displayed in the /sys/firmware/memmap file, and it's also used by the hibernation code to calculate a physical memory layout MD5 fingerprint checksum which is invariant of the kernel.
So rename it to 'e820_table_firmware' and update all the comments to better describe the main e820 data strutures.
Also rename:
'initial_e820_table_saved' => 'e820_table_firmware_init' 'e820_update_range_saved' => 'e820_update_range_firmware'
... to better match the new nomenclature.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 3 +-- arch/x86/kernel/e820.c | 78 +++++++++++++++++++++++++++++++++++++---------------------- arch/x86/kernel/kexec-bzimage64.c | 4 +-- arch/x86/kernel/setup.c | 4 +-- arch/x86/power/hibernate_64.c | 4 +-- 5 files changed, 56 insertions(+), 37 deletions(-)
arch/x86/include/asm/e820/api.h +1 -2
@@ -3,9 +3,8 @@#include <asm/e820/types.h> -/* see comment in arch/x86/kernel/e820.c */ extern struct e820_table *e820_table; -extern struct e820_table *e820_table_saved; +extern struct e820_table *e820_table_firmware;extern unsigned long pci_mem_start;
arch/x86/kernel/e820.c +49 -29
140 lines not on this page · raw message
arch/x86/kernel/kexec-bzimage64.c +2 -2
@@ -100,14 +100,14 @@ static int setup_e820_entries(struct boot_params *params) {unsigned int nr_e820_entries; - nr_e820_entries = e820_table_saved->nr_entries; + nr_e820_entries = e820_table_firmware->nr_entries;/* TODO: Pass entries more than E820MAX in bootparams setup data */ if (nr_e820_entries >E820MAX ) nr_e820_entries =E820MAX ; params->e820_entries = nr_e820_entries; -memcpy (¶ms->e820_table, &e820_table_saved->entries, nr_e820_entries*sizeof (struct e820_entry )); +memcpy (¶ms->e820_table, &e820_table_firmware->entries, nr_e820_entries*sizeof (struct e820_entry ));return 0 ; }
arch/x86/kernel/setup.c +2 -2
@@ -459,7 +459,7 @@ static void __init e820_reserve_setup_data(void) }sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); -memcpy (e820_table_saved, e820_table,sizeof (struct e820_table )); +memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table ));printk (KERN_INFO "extended physical RAM map:\n" );e820_print_map ("reserve setup_data" ); }
@@ -1026,7 +1026,7 @@ void __init setup_arch(char **cmdline_p)early_dump_pci_devices ();#endif -/* update the e820_table_saved too */ +/* update the e820_table_firmware too */ e820_reserve_setup_data ();finish_e820_parsing ();
arch/x86/power/hibernate_64.c +2 -2
@@ -231,7 +231,7 @@ static int get_e820_md5(struct e820_table *table, void *buf)static void hibernation_e820_save (void *buf) { -get_e820_md5 (e820_table_saved, buf); +get_e820_md5 (e820_table_firmware, buf); }static bool hibernation_e820_mismatch (void *buf)
@@ -244,7 +244,7 @@ static bool hibernation_e820_mismatch(void *buf)if (!memcmp (result, buf,MD5_DIGEST_SIZE ))return false; - ret =get_e820_md5 (e820_table_saved, result); + ret =get_e820_md5 (e820_table_firmware, result);if (ret)return true;
Signature · 1 line
2.7.4
PATCH 19/50 x86/boot/e820: Basic cleanup of e820.c
In reply to Ingo MolnarOver the last decade or so e820.c has become an ureadable mess of tinkerware. Perform some very basic cleanups before doing more intricate cleanups, so that my eyes don't start bleeding when I look at it.
Here's some of the excesses:
- Total disregard of countless aspects of Documentation/CodingStyle.
- Totally inconsistent hodge-podge of various coding styles and practices.
- Gems like:
(unsigned long long) e820_table->entries[i].addr
... which is a completely unnecessary type conversion of an u64 value.
- Incomprehensible comments while there are major functions with absolutely no explanation - plus an armada of typos and grammar mistakes.
- Mindless checkpatch artifacts such as:
if (append_e820_table(boot_params.e820_table, boot_params.e820_entries)
< 0) {
for_each_free_mem_range(u, NUMA_NO_NODE, MEMBLOCK_NONE, &start, &end,
NULL) {- Actively misleading comments:
/* In case someone cares... */
return who; ( The usage site of the return value just a few lines further down makes it
clear that we very much care about the return value, we use it to print out the e820 map... )
- Colorfully inconsistent capitalization and punctuation throughout.
- etc.
This patch fixes only the worst excesses - there's more to fix.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/kernel/e820.c | 447 ++++++++++++++++++++++++++++++++------------------------------------- 1 file changed, 207 insertions(+), 240 deletions(-)
arch/x86/kernel/e820.c +207 -240
@@ -1,12 +1,12 @@/* -* Handle the memory map. -* The functions here do the job until bootmem takes over. +* Low level x86 E820 memory map handling functions. * -* Getting sanitize_e820_table() in sync with i386 version by applying change: -* - Provisions for empty E820 memory regions (reported by certain BIOSes). -* Alex Achenbach <[email protected]>, December 2002. -* Venkatesh Pallipadi <[email protected]> +* The firmware and bootloader passes us the "E820 table", which is the primary +* physical memory layout description available about x86 systems. * +* The kernel takes the E820 memory layout and optionally modifies it with +* quirks and other tweaks, and feeds that into the generic Linux memory +* allocation code routines via a platform independent interface (memblock, etc.). */ #include <linux/kernel.h> #include <linux/types.h>
@@ -27,13 +27,6 @@#include <asm/cpufeature.h> /* -* The firmware and bootloader passes us an E820 table that is the primary -* physical memory layout description available about x86 systems. -* -* The kernel takes the e820 memory layout and optionally modifies it with -* quirks and other tweaks, and feeds that into the generic Linux memory -* allocation code routines via a platform independent interface (memblock, etc.). -* * We organize the E820 table into two main data structures: * * - 'e820_table_firmware': the original firmware version passed to us by the
@@ -45,16 +38,16 @@* - the hibernation code uses it to generate a kernel-independent MD5 * fingerprint of the physical memory layout of a system. * -* - kexec, which is a bootloader in disguise, uses the original e820 +* - kexec, which is a bootloader in disguise, uses the original E820 * layout to pass to the kexec-ed kernel. This way the original kernel -* can have a restricted e820 map while the kexec()-ed kexec-kernel +* can have a restricted E820 map while the kexec()-ed kexec-kernel * can have access to full memory - etc. * -* - 'e820_table': this is the main e820 table that is massaged by the +* - 'e820_table': this is the main E820 table that is massaged by the * low level x86 platform code, or modified by boot parameters, before * passed on to higher level MM layers. * -* Once the e820 map has been converted to the standard Linux memory layout +* Once the E820 map has been converted to the standard Linux memory layout * information its role stops - modifying it has no effect and does not get * re-propagated. So itsmain role is a temporary bootstrap storage of firmware * specific memory layout data during early bootup.
@@ -75,8 +68,7 @@ EXPORT_SYMBOL(pci_mem_start);* This function checks if any part of the range <start,end> is mapped * with type. */ -int -e820_any_mapped (u64 start,u64 end,unsigned type) +int e820_any_mapped (u64 start,u64 end,unsigned type) {int i;
@@ -94,10 +86,10 @@ e820_any_mapped(u64 start, u64 end, unsigned type)EXPORT_SYMBOL_GPL (e820_any_mapped);/* -* This function checks if the entire range <start,end> is mapped with type. +* This function checks if the entire <start,end> range is mapped with 'type'. * -* Note: this function only works correct if the e820 table is sorted and -* not-overlapping, which is the case +* Note: this function only works correctly once the E820 table is sorted and +* not-overlapping (at least for the range specified), which is the case normally. */ int __init e820_all_mapped (u64 start,u64 end,unsigned type) {
@@ -108,18 +100,21 @@ int __init e820_all_mapped(u64 start, u64 end, unsigned type)if (type && ei->type != type)continue ; -/* is the region (part) in overlap with the current region ?*/ + +/* Is the region (part) in overlap with the current region? */ if (ei->addr >= end || ei->addr + ei->size <= start)continue ; -/* if the region is at the beginning of <start,end> we move -* start to the end of the region since it's ok until there +/* +* If the region is at the beginning of <start,end> we move +* 'start' to the end of the region since it's ok until there */ if (ei->addr <= start) start = ei->addr + ei->size; +/* -* if start is now at or beyond end, we're done, full -* coverage +* If 'start' is now at or beyond 'end', we're done, full +* coverage of the desired range exists: */ if (start >= end)return 1 ;
@@ -128,16 +123,14 @@ int __init e820_all_mapped(u64 start, u64 end, unsigned type) }/* -* Add a memory region to the kernel e820 map. +* Add a memory region to the kernel E820 map. */ static void __init __e820_add_region (struct e820_table *table,u64 start,u64 size,int type) {int x = table->nr_entries;if (x >=ARRAY_SIZE (table->entries)) { -printk (KERN_ERR "e820: too many entries; ignoring [mem %#010llx-%#010llx]\n" , - (unsigned long long ) start, - (unsigned long long ) (start + size -1 )); +printk (KERN_ERR "e820: too many entries; ignoring [mem %#010llx-%#010llx]\n" , start, start + size -1 );return ; }
@@ -155,29 +148,15 @@ void __init e820_add_region(u64 start, u64 size, int type)static void __init e820_print_type (u32 type) {switch (type) { -case E820_RAM : -case E820_RESERVED_KERN : -printk (KERN_CONT "usable" ); -break ; -case E820_RESERVED : -printk (KERN_CONT "reserved" ); -break ; -case E820_ACPI : -printk (KERN_CONT "ACPI data" ); -break ; -case E820_NVS : -printk (KERN_CONT "ACPI NVS" ); -break ; -case E820_UNUSABLE : -printk (KERN_CONT "unusable" ); -break ; -case E820_PMEM : -case E820_PRAM : -printk (KERN_CONT "persistent (type %u)" , type); -break ; -default : -printk (KERN_CONT "type %u" , type); -break ; +case E820_RAM :/* Fall through: */ +case E820_RESERVED_KERN :printk (KERN_CONT "usable" );break ; +case E820_RESERVED :printk (KERN_CONT "reserved" );break ; +case E820_ACPI :printk (KERN_CONT "ACPI data" );break ; +case E820_NVS :printk (KERN_CONT "ACPI NVS" );break ; +case E820_UNUSABLE :printk (KERN_CONT "unusable" );break ; +case E820_PMEM :/* Fall through: */ +case E820_PRAM :printk (KERN_CONT "persistent (type %u)" , type);break ; +default :printk (KERN_CONT "type %u" , type);break ; } }
@@ -187,26 +166,26 @@ void __init e820_print_map(char *who)for (i =0 ; i < e820_table->nr_entries; i++) {printk (KERN_INFO "%s: [mem %#018Lx-%#018Lx] " , who, - (unsigned long long ) e820_table->entries[i].addr, - (unsigned long long ) - (e820_table->entries[i].addr + e820_table->entries[i].size -1 )); + e820_table->entries[i].addr, + e820_table->entries[i].addr + e820_table->entries[i].size -1 ); +e820_print_type (e820_table->entries[i].type);printk (KERN_CONT "\n" ); } }/* -* Sanitize the BIOS e820 map. +* Sanitize the BIOS E820 map. * -* Some e820 responses include overlapping entries. The following -* replaces the original e820 map with a new one, removing overlaps, +* Some E820 responses include overlapping entries. The following +* replaces the original E820 map with a new one, removing overlaps, * and resolving conflicting memory types in favor of highest * numbered type. * * The input parameter biosmap points to an array of 'struct * e820_entry' which on entry has elements in the range [0, *pnr_map) * valid, and which has space for up to max_nr_map entries. -* On return, the resulting sanitized e820 map entries will be in +* On return, the resulting sanitized E820 map entries will be in * overwritten in the same location, starting at biosmap. * * The integer pointed to by pnr_map must be valid on entry (the
@@ -257,8 +236,10 @@ void __init e820_print_map(char *who)* ______________________4_ */ struct change_member { -struct e820_entry *pbios;/* pointer to original bios entry */ -unsigned long long addr;/* address for this change point */ +/* Pointer to the original BIOS entry: */ +struct e820_entry *pbios; +/* Address for this change point: */ +unsigned long long addr; };static int __init cpcompare (const void *a,const void *b)
@@ -268,7 +249,7 @@ static int __init cpcompare(const void *a, const void *b)/* * Inputs are pointers to two elements of change_point[]. If their -* addresses are unequal, their difference dominates. If the addresses +* addresses are not equal, their difference dominates. If the addresses * are equal, then consider one that represents the end of its region * to be greater than one that does not. */
@@ -278,8 +259,7 @@ static int __init cpcompare(const void *a, const void *b)return (ap->addr != ap->pbios->addr) - (bp->addr != bp->pbios->addr); } -int __init sanitize_e820_table (struct e820_entry *biosmap,int max_nr_map, -u32 *pnr_map) +int __init sanitize_e820_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map) {static struct change_member change_point_list[2 *E820_X_MAX ]__initdata ;static struct change_member *change_point[2 *E820_X_MAX ]__initdata ;
@@ -293,112 +273,96 @@ int __init sanitize_e820_table(struct e820_entry *biosmap, int max_nr_map,int old_nr, new_nr, chg_nr;int i; -/* if there's only one memory region, don't bother */ +/* If there's only one memory region, don't bother: */ if (*pnr_map <2 )return -1 ; old_nr = *pnr_map;BUG_ON (old_nr > max_nr_map); -/* bail out if we find any unreasonable addresses in bios map */ -for (i =0 ; i < old_nr; i++) +/* Bail out if we find any unreasonable addresses in the BIOS map: */ +for (i =0 ; i < old_nr; i++) {if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)return -1 ; + } -/* create pointers for initial change-point information (for sorting) */ +/* Create pointers for initial change-point information (for sorting): */ for (i =0 ; i <2 * old_nr; i++) change_point[i] = &change_point_list[i]; -/* record all known change-points (starting and ending addresses), -omitting those that are for empty memory regions */ +/* +* Record all known change-points (starting and ending addresses), +* omitting empty memory regions: +*/ chgidx =0 ;for (i =0 ; i < old_nr; i++) {if (biosmap[i].size !=0 ) { - change_point[chgidx]->addr = biosmap[i].addr; - change_point[chgidx++]->pbios = &biosmap[i]; - change_point[chgidx]->addr = biosmap[i].addr + - biosmap[i].size; - change_point[chgidx++]->pbios = &biosmap[i]; + change_point[chgidx]->addr = biosmap[i].addr; + change_point[chgidx++]->pbios = &biosmap[i]; + change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size; + change_point[chgidx++]->pbios = &biosmap[i]; } } chg_nr = chgidx; -/* sort change-point list by memory addresses (low -> high) */ +/* Sort change-point list by memory addresses (low -> high): */ sort (change_point, chg_nr,sizeof *change_point, cpcompare,NULL ); -/* create a new bios memory map, removing overlaps */ - overlap_entries =0 ;/* number of entries in the overlap table */ - new_bios_entry =0 ;/* index for creating new bios map entries */ - last_type =0 ;/* start with undefined memory type */ - last_addr =0 ;/* start with 0 as last starting address */ +/* Create a new BIOS memory map, removing overlaps: */ + overlap_entries =0 ;/* Number of entries in the overlap table */ + new_bios_entry =0 ;/* Index for creating new bios map entries */ + last_type =0 ;/* Start with undefined memory type */ + last_addr =0 ;/* Start with 0 as last starting address */ -/* loop through change-points, determining affect on the new bios map */ +/* Loop through change-points, determining effect on the new BIOS map: */ for (chgidx =0 ; chgidx < chg_nr; chgidx++) { -/* keep track of all overlapping bios entries */ -if (change_point[chgidx]->addr == - change_point[chgidx]->pbios->addr) { -/* -* add map entry to overlap list (> 1 entry -* implies an overlap) -*/ - overlap_list[overlap_entries++] = - change_point[chgidx]->pbios; +/* Keep track of all overlapping BIOS entries */ +if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr) { +/* Add map entry to overlap list (> 1 entry implies an overlap) */ + overlap_list[overlap_entries++] = change_point[chgidx]->pbios; }else { -/* -* remove entry from list (order independent, -* so swap with last) -*/ +/* Remove entry from list (order independent, so swap with last): */ for (i =0 ; i < overlap_entries; i++) { -if (overlap_list[i] == - change_point[chgidx]->pbios) - overlap_list[i] = - overlap_list[overlap_entries-1 ]; +if (overlap_list[i] == change_point[chgidx]->pbios) + overlap_list[i] = overlap_list[overlap_entries-1 ]; } overlap_entries--; }/* -* if there are overlapping entries, decide which +* If there are overlapping entries, decide which * "type" to use (larger value takes precedence -- * 1=usable, 2,3,4,4+=unusable) */ current_type =0 ; -for (i =0 ; i < overlap_entries; i++) +for (i =0 ; i < overlap_entries; i++) {if (overlap_list[i]->type > current_type) current_type = overlap_list[i]->type; -/* -* continue building up new bios map based on this -* information -*/ + } + +/* Continue building up new BIOS map based on this information: */ if (current_type != last_type || current_type ==E820_PRAM ) {if (last_type !=0 ) { - new_bios[new_bios_entry].size = - change_point[chgidx]->addr - last_addr; -/* -* move forward only if the new size -* was non-zero -*/ + new_bios[new_bios_entry].size = change_point[chgidx]->addr - last_addr; +/* Move forward only if the new size was non-zero: */ if (new_bios[new_bios_entry].size !=0 ) -/* -* no more space left for new -* bios entries ? -*/ +/* No more space left for new BIOS entries? */ if (++new_bios_entry >= max_nr_map)break ; }if (current_type !=0 ) { - new_bios[new_bios_entry].addr = - change_point[chgidx]->addr; + new_bios[new_bios_entry].addr = change_point[chgidx]->addr; new_bios[new_bios_entry].type = current_type; last_addr = change_point[chgidx]->addr; } last_type = current_type; } } -/* retain count for new bios entries */ + +/* Retain count for new BIOS entries: */ new_nr = new_bios_entry; -/* copy new bios mapping into original location */ -memcpy (biosmap, new_bios, new_nr *sizeof (struct e820_entry )); +/* Copy new BIOS mapping into the original location: */ +memcpy (biosmap, new_bios, new_nr*sizeof (struct e820_entry )); *pnr_map = new_nr;return 0 ;
@@ -412,7 +376,7 @@ static int __init __append_e820_table(struct e820_entry *biosmap, int nr_map)u64 end = start + size -1 ;u32 type = biosmap->type; -/* Overflow in 64 bits? Ignore the memory map. */ +/* Ignore the entry on 64-bit overflow: */ if (start > end &&likely (size))return -1 ;
@@ -425,7 +389,7 @@ static int __init __append_e820_table(struct e820_entry *biosmap, int nr_map) }/* -* Copy the BIOS e820 map into a safe place. +* Copy the BIOS E820 map into a safe place. * * Sanity-check it while we're at it.. *
@@ -442,9 +406,8 @@ static int __init append_e820_table(struct e820_entry *biosmap, int nr_map)return __append_e820_table (biosmap, nr_map); } -static u64 __init __e820_update_range (struct e820_table *table,u64 start, -u64 size,unsigned old_type, -unsigned new_type) +static u64 __init +__e820_update_range (struct e820_table *table,u64 start,u64 size,unsigned old_type,unsigned new_type) {u64 end;unsigned int i;
@@ -456,8 +419,7 @@ static u64 __init __e820_update_range(struct e820_table *table, u64 start, size =ULLONG_MAX - start; end = start + size; -printk (KERN_DEBUG "e820: update [mem %#010Lx-%#010Lx] " , - (unsigned long long ) start, (unsigned long long ) (end -1 )); +printk (KERN_DEBUG "e820: update [mem %#010Lx-%#010Lx] " , start, end -1 );e820_print_type (old_type);printk (KERN_CONT " ==> " );e820_print_type (new_type);
@@ -472,14 +434,15 @@ static u64 __init __e820_update_range(struct e820_table *table, u64 start,continue ; ei_end = ei->addr + ei->size; -/* totally covered by new range? */ + +/* Completely covered by new range? */ if (ei->addr >= start && ei_end <= end) { ei->type = new_type; real_updated_size += ei->size;continue ; } -/* new range is totally covered? */ +/* New range is completely covered? */ if (ei->addr < start && ei_end > end) {__e820_add_region (table, start, size, new_type);__e820_add_region (table, end, ei_end - end, ei->type);
@@ -488,45 +451,41 @@ static u64 __init __e820_update_range(struct e820_table *table, u64 start,continue ; } -/* partially covered */ +/* Partially covered: */ final_start =max (start, ei->addr); final_end =min (end, ei_end);if (final_start >= final_end)continue ; -__e820_add_region (table, final_start, final_end - final_start, - new_type); +__e820_add_region (table, final_start, final_end - final_start, new_type); real_updated_size += final_end - final_start;/* -* left range could be head or tail, so need to update -* size at first. +* Left range could be head or tail, so need to update +* its size first: */ ei->size -= final_end - final_start;if (ei->addr < final_start)continue ; + ei->addr = final_end; }return real_updated_size; } -u64 __init e820_update_range (u64 start,u64 size,unsigned old_type, -unsigned new_type) +u64 __init e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type) {return __e820_update_range (e820_table, start, size, old_type, new_type); } -static u64 __init e820_update_range_firmware (u64 start,u64 size, -unsigned old_type,unsigned new_type) +static u64 __init e820_update_range_firmware (u64 start,u64 size,unsigned old_type,unsigned new_type) { -return __e820_update_range (e820_table_firmware, start, size, old_type, - new_type); +return __e820_update_range (e820_table_firmware, start, size, old_type, new_type); } -/* make e820 not cover the range */ -u64 __init e820_remove_range (u64 start,u64 size,unsigned old_type, -int checktype) +/* Remove a range of memory from the E820 table: */ +u64 __init e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype) {int i;u64 end;
@@ -536,8 +495,7 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, size =ULLONG_MAX - start; end = start + size; -printk (KERN_DEBUG "e820: remove [mem %#010Lx-%#010Lx] " , - (unsigned long long ) start, (unsigned long long ) (end -1 )); +printk (KERN_DEBUG "e820: remove [mem %#010Lx-%#010Lx] " , start, end -1 );if (checktype)e820_print_type (old_type);printk (KERN_CONT "\n" );
@@ -551,14 +509,15 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,continue ; ei_end = ei->addr + ei->size; -/* totally covered? */ + +/* Completely covered? */ if (ei->addr >= start && ei_end <= end) { real_removed_size += ei->size;memset (ei,0 ,sizeof (struct e820_entry ));continue ; } -/* new range is totally covered? */ +/* Is the new range completely covered? */ if (ei->addr < start && ei_end > end) {e820_add_region (end, ei_end - end, ei->type); ei->size = start - ei->addr;
@@ -566,20 +525,22 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,continue ; } -/* partially covered */ +/* Partially covered: */ final_start =max (start, ei->addr); final_end =min (end, ei_end);if (final_start >= final_end)continue ; + real_removed_size += final_end - final_start;/* -* left range could be head or tail, so need to update -* size at first. +* Left range could be head or tail, so need to update +* the size first: */ ei->size -= final_end - final_start;if (ei->addr < final_start)continue ; + ei->addr = final_end; }return real_removed_size;
@@ -589,19 +550,22 @@ void __init update_e820(void) {if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries))return ; +printk (KERN_INFO "e820: modified physical RAM map:\n" );e820_print_map ("modified" ); } +static void __init update_e820_table_firmware (void ) {sanitize_e820_table (e820_table_firmware->entries,ARRAY_SIZE (e820_table_firmware->entries), &e820_table_firmware->nr_entries); } +#define MAX_GAP_END 0x100000000ull +/* -* Search for a gap in the e820 memory space from 0 to MAX_GAP_END. +* Search for a gap in the E820 memory space from 0 to MAX_GAP_END (4GB). */ -static int __init e820_search_gap (unsigned long *gapstart, -unsigned long *gapsize) +static int __init e820_search_gap (unsigned long *gapstart,unsigned long *gapsize) {unsigned long long last =MAX_GAP_END ;int i = e820_table->nr_entries;
@@ -613,7 +577,7 @@ static int __init e820_search_gap(unsigned long *gapstart,/* * Since "last" is at most 4GB, we know we'll -* fit in 32 bits if this condition is true +* fit in 32 bits if this condition is true: */ if (last > end) {unsigned long gap = last - end;
@@ -631,9 +595,11 @@ static int __init e820_search_gap(unsigned long *gapstart, }/* -* Search for the biggest gap in the low 32 bits of the e820 -* memory space. We pass this space to PCI to assign MMIO resources -* for hotplug or unconfigured devices in. +* Search for the biggest gap in the low 32 bits of the E820 +* memory space. We pass this space to the PCI subsystem, so +* that it can assign MMIO resources for hotplug or +* unconfigured devices in. +* * Hopefully the BIOS let enough space left. */ __init void e820_setup_gap (void )
@@ -648,8 +614,8 @@ __init void e820_setup_gap(void)#ifdef CONFIG_X86_64 gapstart = (max_pfn <<PAGE_SHIFT ) +1024 *1024 ;printk (KERN_ERR -"e820: cannot find a gap in the 32bit address range\n" -"e820: PCI devices with unassigned 32bit BARs may break!\n" ); +"e820: Cannot find an available gap in the 32-bit address range\n" +"e820: PCI devices with unassigned 32-bit BARs may not work!\n" );#else gapstart =0x10000000 ;#endif
@@ -660,43 +626,44 @@ __init void e820_setup_gap(void)*/ pci_mem_start = gapstart; -printk (KERN_INFO -"e820: [mem %#010lx-%#010lx] available for PCI devices\n" , - gapstart, gapstart + gapsize -1 ); +printk (KERN_INFO "e820: [mem %#010lx-%#010lx] available for PCI devices\n" , gapstart, gapstart + gapsize -1 ); }/* * Called late during init, in free_initmem(). * -* Initial e820 and e820_table_firmware are largish __initdata arrays. -* Copy them to (usually much smaller) dynamically allocated area. -* This is done after all tweaks we ever do to them: -* all functions which modify them are __init functions, -* they won't exist after this point. +* Initial e820_table and e820_table_firmware are largish __initdata arrays. +* +* Copy them to a (usually much smaller) dynamically allocated area that is +* sized precisely after the number of e820 entries. +* +* This is done after we've performed all the fixes and tweaks to the tables. +* All functions which modify them are __init functions, which won't exist +* after free_initmem(). */ __init void e820_reallocate_tables (void ) {struct e820_table *n;int size; - size = offsetof(struct e820_table , entries) +sizeof (struct e820_entry ) * e820_table->nr_entries; + size = offsetof(struct e820_table , entries) +sizeof (struct e820_entry )*e820_table->nr_entries; n =kmalloc (size,GFP_KERNEL );BUG_ON (!n);memcpy (n, e820_table, size); e820_table = n; - size = offsetof(struct e820_table , entries) +sizeof (struct e820_entry ) * e820_table_firmware->nr_entries; + size = offsetof(struct e820_table , entries) +sizeof (struct e820_entry )*e820_table_firmware->nr_entries; n =kmalloc (size,GFP_KERNEL );BUG_ON (!n);memcpy (n, e820_table_firmware, size); e820_table_firmware = n; } -/** -* Because of the size limitation of struct boot_params, only first -* 128 E820 memory entries are passed to kernel via -* boot_params.e820_table, others are passed via SETUP_E820_EXT node of -* linked list of struct setup_data, which is parsed here. +/* +* Because of the small fixed size of struct boot_params, only the first +* 128 E820 memory entries are passed to the kernel via boot_params.e820_table, +* the remaining (if any) entries are passed via the SETUP_E820_EXT node of +* struct setup_data, which is parsed here. */ void __init parse_e820_ext (u64 phys_addr,u32 data_len) {
@@ -707,8 +674,10 @@ void __init parse_e820_ext(u64 phys_addr, u32 data_len) sdata =early_memremap (phys_addr, data_len); entries = sdata->len /sizeof (struct e820_entry ); extmap = (struct e820_entry *)(sdata->data); +__append_e820_table (extmap, entries);sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +early_memunmap (sdata, data_len);printk (KERN_INFO "e820: extended physical RAM map:\n" );e820_print_map ("extended" );
@@ -716,10 +685,10 @@ void __init parse_e820_ext(u64 phys_addr, u32 data_len)/** * Find the ranges of physical addresses that do not correspond to -* e820 RAM areas and mark the corresponding pages as nosave for -* hibernation (32 bit) or software suspend and suspend to RAM (64 bit). +* E820 RAM areas and mark the corresponding pages as 'nosave' for +* hibernation (32-bit) or software suspend and suspend to RAM (64-bit). * -* This function requires the e820 map to be sorted and without any +* This function requires the E820 map to be sorted and without any * overlapping entries. */ void __init e820_mark_nosave_regions (unsigned long limit_pfn)
@@ -744,9 +713,9 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn) }#ifdef CONFIG_ACPI -/** -* Mark ACPI NVS memory region, so that we can save/restore it during -* hibernation and the subsequent resume. +/* +* Register ACPI NVS memory regions, so that we can save/restore them during +* hibernation and the subsequent resume: */ static int __init e820_mark_nvs_memory (void ) {
@@ -828,6 +797,7 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type) last_pfn, max_arch_pfn);return last_pfn; } +unsigned long __init e820_end_of_ram_pfn (void ) {return e820_end_pfn (MAX_ARCH_PFN ,E820_RAM );
@@ -846,7 +816,7 @@ static void __init early_panic(char *msg)static int userdef__initdata ; -/* "mem=nopentium" disables the 4MB page tables. */ +/* The "mem=nopentium" boot option disables 4MB page tables on 32-bit kernels: */ static int __init parse_memopt (char *p) {u64 mem_size;
@@ -866,9 +836,11 @@ static int __init parse_memopt(char *p) userdef =1 ; mem_size =memparse (p, &p); -/* don't remove all of memory when handling "mem={invalid}" param */ + +/* Don't remove all memory when getting "mem={invalid}" parameter: */ if (mem_size ==0 )return -EINVAL ; +e820_remove_range (mem_size,ULLONG_MAX - mem_size,E820_RAM ,1 );return 0 ;
@@ -887,7 +859,7 @@ static int __init parse_memmap_one(char *p)#ifdef CONFIG_CRASH_DUMP /* * If we are doing a crash dump, we still need to know -* the real mem size before original memory map is +* the real memory size before the original memory map is * reset. */ saved_max_pfn =e820_end_of_ram_pfn ();
@@ -915,11 +887,13 @@ static int __init parse_memmap_one(char *p) }else if (*p =='!' ) { start_at =memparse (p+1 , &p);e820_add_region (start_at, mem_size,E820_PRAM ); - }else + }else {e820_remove_range (mem_size,ULLONG_MAX - mem_size,E820_RAM ,1 ); + }return *p =='\0' ?0 : -EINVAL ; } +static int __init parse_memmap_opt (char *str) {while (str) {
@@ -939,8 +913,7 @@ early_param("memmap", parse_memmap_opt);void __init finish_e820_parsing (void ) {if (userdef) { -if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), - &e820_table->nr_entries) <0 ) +if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries) <0 )early_panic ("Invalid user supplied memory map" );printk (KERN_INFO "e820: user-defined physical RAM map:\n" );
@@ -951,49 +924,42 @@ void __init finish_e820_parsing(void)static const char *__init e820_type_to_string (int e820_type) {switch (e820_type) { -case E820_RESERVED_KERN : -case E820_RAM :return "System RAM" ; -case E820_ACPI :return "ACPI Tables" ; -case E820_NVS :return "ACPI Non-volatile Storage" ; -case E820_UNUSABLE :return "Unusable memory" ; -case E820_PRAM :return "Persistent Memory (legacy)" ; -case E820_PMEM :return "Persistent Memory" ; -default :return "reserved" ; +case E820_RESERVED_KERN :/* Fall-through: */ +case E820_RAM :return "System RAM" ; +case E820_ACPI :return "ACPI Tables" ; +case E820_NVS :return "ACPI Non-volatile Storage" ; +case E820_UNUSABLE :return "Unusable memory" ; +case E820_PRAM :return "Persistent Memory (legacy)" ; +case E820_PMEM :return "Persistent Memory" ; +default :return "Reserved" ; } }static unsigned long __init e820_type_to_iomem_type (int e820_type) {switch (e820_type) { -case E820_RESERVED_KERN : -case E820_RAM : -return IORESOURCE_SYSTEM_RAM ; -case E820_ACPI : -case E820_NVS : -case E820_UNUSABLE : -case E820_PRAM : -case E820_PMEM : -default : -return IORESOURCE_MEM ; +case E820_RESERVED_KERN :/* Fall-through: */ +case E820_RAM :return IORESOURCE_SYSTEM_RAM ; +case E820_ACPI :/* Fall-through: */ +case E820_NVS :/* Fall-through: */ +case E820_UNUSABLE :/* Fall-through: */ +case E820_PRAM :/* Fall-through: */ +case E820_PMEM :/* Fall-through: */ +default :return IORESOURCE_MEM ; } }static unsigned long __init e820_type_to_iores_desc (int e820_type) {switch (e820_type) { -case E820_ACPI : -return IORES_DESC_ACPI_TABLES ; -case E820_NVS : -return IORES_DESC_ACPI_NV_STORAGE ; -case E820_PMEM : -return IORES_DESC_PERSISTENT_MEMORY ; -case E820_PRAM : -return IORES_DESC_PERSISTENT_MEMORY_LEGACY ; -case E820_RESERVED_KERN : -case E820_RAM : -case E820_UNUSABLE : -default : -return IORES_DESC_NONE ; +case E820_ACPI :return IORES_DESC_ACPI_TABLES ; +case E820_NVS :return IORES_DESC_ACPI_NV_STORAGE ; +case E820_PMEM :return IORES_DESC_PERSISTENT_MEMORY ; +case E820_PRAM :return IORES_DESC_PERSISTENT_MEMORY_LEGACY ; +case E820_RESERVED_KERN :/* Fall-through: */ +case E820_RAM :/* Fall-through: */ +case E820_UNUSABLE :/* Fall-through: */ +default :return IORES_DESC_NONE ; } }
@@ -1018,9 +984,11 @@ static bool __init do_mark_busy(u32 type, struct resource *res) }/* -* Mark e820 reserved areas as busy for the resource manager. +* Mark E820 reserved areas as busy for the resource manager: */ +static struct resource __initdata *e820_res; +void __init e820_reserve_resources (void ) {int i;
@@ -1056,9 +1024,8 @@ void __init e820_reserve_resources(void)for (i =0 ; i < e820_table_firmware->nr_entries; i++) {struct e820_entry *entry = &e820_table_firmware->entries[i]; -firmware_map_add_early (entry->addr, - entry->addr + entry->size, -e820_type_to_string (entry->type)); + +firmware_map_add_early (entry->addr, entry->addr + entry->size,e820_type_to_string (entry->type)); } }
@@ -1094,7 +1061,7 @@ void __init e820_reserve_resources_late(void) }/* -* Try to bump up RAM regions to reasonable boundaries to +* Try to bump up RAM regions to reasonable boundaries, to * avoid stolen RAM: */ for (i =0 ; i < e820_table->nr_entries; i++) {
@@ -1103,24 +1070,27 @@ void __init e820_reserve_resources_late(void)if (entry->type !=E820_RAM )continue ; + start = entry->addr + entry->size; end =round_up (start,ram_alignment (start)) -1 ;if (end >MAX_RESOURCE_SIZE ) end =MAX_RESOURCE_SIZE ;if (start >= end)continue ; -printk (KERN_DEBUG -"e820: reserve RAM buffer [mem %#010llx-%#010llx]\n" , - start, end); -reserve_region_with_split (&iomem_resource, start, end, -"RAM buffer" ); + +printk (KERN_DEBUG "e820: reserve RAM buffer [mem %#010llx-%#010llx]\n" , start, end); +reserve_region_with_split (&iomem_resource, start, end,"RAM buffer" ); } } +/* +* Pass the firmware (bootloader) E820 map to the kernel and process it: +*/ char *__init e820__memory_setup_default (void ) {char *who ="BIOS-e820" ;u32 new_nr; +/* * Try to copy the BIOS-supplied E820-map. *
@@ -1128,17 +1098,14 @@ char *__init e820__memory_setup_default(void)* the next section from 1mb->appropriate_mem_k */ new_nr = boot_params.e820_entries; -sanitize_e820_table (boot_params.e820_table, -ARRAY_SIZE (boot_params.e820_table), - &new_nr); +sanitize_e820_table (boot_params.e820_table,ARRAY_SIZE (boot_params.e820_table), &new_nr); boot_params.e820_entries = new_nr; -if (append_e820_table (boot_params.e820_table, boot_params.e820_entries) - <0 ) { + +if (append_e820_table (boot_params.e820_table, boot_params.e820_entries) <0 ) {u64 mem_size; -/* compare results from other methods and take the greater */ -if (boot_params.alt_mem_k - < boot_params.screen_info.ext_mem_k) { +/* Compare results from other methods and take the one that gives more RAM: */ +if (boot_params.alt_mem_k < boot_params.screen_info.ext_mem_k) { mem_size = boot_params.screen_info.ext_mem_k; who ="BIOS-88" ; }else {
@@ -1151,7 +1118,6 @@ char *__init e820__memory_setup_default(void)e820_add_region (HIGH_MEMORY , mem_size <<10 ,E820_RAM ); } -/* In case someone cares... */ return who; }
@@ -1165,7 +1131,9 @@ void __init e820__memory_setup(void)char *who; who = x86_init.resources.memory_setup (); +memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table )); +printk (KERN_INFO "e820: BIOS-provided physical RAM map:\n" );e820_print_map (who); }
@@ -1221,8 +1189,7 @@ void __init memblock_find_dma_reserve(void) nr_pages += end_pfn - start_pfn; } -for_each_free_mem_range (u,NUMA_NO_NODE ,MEMBLOCK_NONE , &start, &end, -NULL ) { +for_each_free_mem_range (u,NUMA_NO_NODE ,MEMBLOCK_NONE , &start, &end,NULL ) { start_pfn = min_t(unsigned long, PFN_UP(start), MAX_DMA_PFN); end_pfn = min_t(unsigned long, PFN_DOWN(end), MAX_DMA_PFN);if (start_pfn < end_pfn)
Signature · 1 line
2.7.4
PATCH 20/50 x86/boot/e820: Rename memblock_x86_fill() to e820__memblock_setup() and improve the explanations
In reply to Ingo MolnarSo memblock_x86_fill() is another E820 code misnomer:
- nothing in its name tells us that it's part of the E820 subsystem ...
- The 'fill' wording is ambiguous and doesn't tell us whether it's a single entry or some process - while the _real_ purpose of the function is hidden, which is to do a complete setup of the (platform independent) memblock regions.
So rename it accordingly, to e820__memblock_setup().
Also translate this incomprehensible and misleading comment:
/*
* EFI may have more than 128 entries
* We are safe to enable resizing, beause memblock_x86_fill()
* is rather later for x86
*/
memblock_allow_resize();
The worst aspect of this comment isn't even the sloppy typos, but that it casually mentions a '128' number with no explanation, which makes one lead to the assumption that this is related to the well-known limit of a maximum of 128 E820 entries passed via legacy bootloaders.
But no, the _real_ meaning of 128 here is that of the memblock subsystem, which too happens to have a 128 entries limit for very early memblock regions (which is unrelated to E820), via INIT_MEMBLOCK_REGIONS ...
So change the comment to a more comprehensible version:
/*
* The bootstrap memblock region count maximum is 128 entries
* (INIT_MEMBLOCK_REGIONS), but EFI might pass us more E820 entries
* than that - so allow memblock resizing.
*
* This is safe, because this call happens pretty late during x86 setup,
* so we know about reserved memory regions already. (This is important
* so that memblock resizing does no stomp over reserved areas.) */
memblock_allow_resize();
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/e820.c | 14 +++++++++----- arch/x86/kernel/setup.c | 4 ++-- 3 files changed, 12 insertions(+), 8 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -21,7 +21,7 @@ extern void parse_e820_ext(u64 phys_addr, u32 data_len);extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void );extern u64 early_reserve_e820 (u64 sizet,u64 align); -extern void memblock_x86_fill (void ); +extern void e820__memblock_setup (void );extern void memblock_find_dma_reserve (void );extern void finish_e820_parsing (void );extern void e820_reserve_resources (void );
arch/x86/kernel/e820.c +9 -5
@@ -1138,15 +1138,19 @@ void __init e820__memory_setup(void)e820_print_map (who); } -void __init memblock_x86_fill (void ) +void __init e820__memblock_setup (void ) {int i;u64 end;/* -* EFI may have more than 128 entries -* We are safe to enable resizing, beause memblock_x86_fill() -* is rather later for x86 +* The bootstrap memblock region count maximum is 128 entries +* (INIT_MEMBLOCK_REGIONS), but EFI might pass us more E820 entries +* than that - so allow memblock resizing. +* +* This is safe, because this call happens pretty late during x86 setup, +* so we know about reserved memory regions already. (This is important +* so that memblock resizing does no stomp over reserved areas.) */ memblock_allow_resize ();
@@ -1163,7 +1167,7 @@ void __init memblock_x86_fill(void)memblock_add (ei->addr, ei->size); } -/* throw away partial pages */ +/* Throw away partial pages: */ memblock_trim_memory (PAGE_SIZE );memblock_dump_all ();
arch/x86/kernel/setup.c +2 -2
@@ -1109,7 +1109,7 @@ void __init setup_arch(char **cmdline_p)early_alloc_pgt_buf ();/* -* Need to conclude brk, before memblock_x86_fill() +* Need to conclude brk, before e820__memblock_setup() * it could use memblock_find_in_range, could overlap with * brk area. */
@@ -1118,7 +1118,7 @@ void __init setup_arch(char **cmdline_p)cleanup_highmap ();memblock_set_current_limit (ISA_END_ADDRESS ); -memblock_x86_fill (); +e820__memblock_setup ();reserve_bios_regions ();
Signature · 1 line
2.7.4
PATCH 21/50 x86/boot/e820: Consolidate 'struct e820_entry *entry' local variable names
In reply to Ingo MolnarSo the E820 code has a lot of cases of:
struct e820_entry *ei;
... but the 'ei' name makes very little sense if you think about it, it's not an abbreviation of anything obviously related to E820 table entries.
This results in weird looking lines such as:
if (type && ei->type != type)
where you might have to double check what 'ei' really means, plus weird looking secondary variable names, such as:
u64 ei_end;
The 'ei' name was introduced in a single function over a decade ago, and then mindlessly cargo-copied over into other functions - with usage growing to over 60 uses altogether (!).
( My best guess is that it might have been originally meant as abbreviation
of 'entry interval'. )
Anyway, rename these to the much more obvious:
struct e820_entry *entry;
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/kernel/e820.c | 110 ++++++++++++++++++++++++++++++++++----------------------------------- 1 file changed, 55 insertions(+), 55 deletions(-)
arch/x86/kernel/e820.c +55 -55
@@ -73,11 +73,11 @@ int e820_any_mapped(u64 start, u64 end, unsigned type)int i;for (i =0 ; i < e820_table->nr_entries; i++) { -struct e820_entry *ei = &e820_table->entries[i]; +struct e820_entry *entry = &e820_table->entries[i]; -if (type && ei->type != type) +if (type && entry->type != type)continue ; -if (ei->addr >= end || ei->addr + ei->size <= start) +if (entry->addr >= end || entry->addr + entry->size <= start)continue ;return 1 ; }
@@ -96,21 +96,21 @@ int __init e820_all_mapped(u64 start, u64 end, unsigned type)int i;for (i =0 ; i < e820_table->nr_entries; i++) { -struct e820_entry *ei = &e820_table->entries[i]; +struct e820_entry *entry = &e820_table->entries[i]; -if (type && ei->type != type) +if (type && entry->type != type)continue ;/* Is the region (part) in overlap with the current region? */ -if (ei->addr >= end || ei->addr + ei->size <= start) +if (entry->addr >= end || entry->addr + entry->size <= start)continue ;/* * If the region is at the beginning of <start,end> we move * 'start' to the end of the region since it's ok until there */ -if (ei->addr <= start) - start = ei->addr + ei->size; +if (entry->addr <= start) + start = entry->addr + entry->size;/* * If 'start' is now at or beyond 'end', we're done, full
@@ -426,34 +426,34 @@ __e820_update_range(struct e820_table *table, u64 start, u64 size, unsigned old_printk (KERN_CONT "\n" );for (i =0 ; i < table->nr_entries; i++) { -struct e820_entry *ei = &table->entries[i]; +struct e820_entry *entry = &table->entries[i];u64 final_start, final_end; -u64 ei_end; +u64 entry_end; -if (ei->type != old_type) +if (entry->type != old_type)continue ; - ei_end = ei->addr + ei->size; + entry_end = entry->addr + entry->size;/* Completely covered by new range? */ -if (ei->addr >= start && ei_end <= end) { - ei->type = new_type; - real_updated_size += ei->size; +if (entry->addr >= start && entry_end <= end) { + entry->type = new_type; + real_updated_size += entry->size;continue ; }/* New range is completely covered? */ -if (ei->addr < start && ei_end > end) { +if (entry->addr < start && entry_end > end) {__e820_add_region (table, start, size, new_type); -__e820_add_region (table, end, ei_end - end, ei->type); - ei->size = start - ei->addr; +__e820_add_region (table, end, entry_end - end, entry->type); + entry->size = start - entry->addr; real_updated_size += size;continue ; }/* Partially covered: */ - final_start =max (start, ei->addr); - final_end =min (end, ei_end); + final_start =max (start, entry->addr); + final_end =min (end, entry_end);if (final_start >= final_end)continue ;
@@ -465,11 +465,11 @@ __e820_update_range(struct e820_table *table, u64 start, u64 size, unsigned old_* Left range could be head or tail, so need to update * its size first: */ - ei->size -= final_end - final_start; -if (ei->addr < final_start) + entry->size -= final_end - final_start; +if (entry->addr < final_start)continue ; - ei->addr = final_end; + entry->addr = final_end; }return real_updated_size; }
@@ -501,33 +501,33 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, int checktyprintk (KERN_CONT "\n" );for (i =0 ; i < e820_table->nr_entries; i++) { -struct e820_entry *ei = &e820_table->entries[i]; +struct e820_entry *entry = &e820_table->entries[i];u64 final_start, final_end; -u64 ei_end; +u64 entry_end; -if (checktype && ei->type != old_type) +if (checktype && entry->type != old_type)continue ; - ei_end = ei->addr + ei->size; + entry_end = entry->addr + entry->size;/* Completely covered? */ -if (ei->addr >= start && ei_end <= end) { - real_removed_size += ei->size; -memset (ei,0 ,sizeof (struct e820_entry )); +if (entry->addr >= start && entry_end <= end) { + real_removed_size += entry->size; +memset (entry,0 ,sizeof (struct e820_entry ));continue ; }/* Is the new range completely covered? */ -if (ei->addr < start && ei_end > end) { -e820_add_region (end, ei_end - end, ei->type); - ei->size = start - ei->addr; +if (entry->addr < start && entry_end > end) { +e820_add_region (end, entry_end - end, entry->type); + entry->size = start - entry->addr; real_removed_size += size;continue ; }/* Partially covered: */ - final_start =max (start, ei->addr); - final_end =min (end, ei_end); + final_start =max (start, entry->addr); + final_end =min (end, entry_end);if (final_start >= final_end)continue ;
@@ -537,11 +537,11 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, int checkty* Left range could be head or tail, so need to update * the size first: */ - ei->size -= final_end - final_start; -if (ei->addr < final_start) + entry->size -= final_end - final_start; +if (entry->addr < final_start)continue ; - ei->addr = final_end; + entry->addr = final_end; }return real_removed_size; }
@@ -697,15 +697,15 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn)unsigned long pfn =0 ;for (i =0 ; i < e820_table->nr_entries; i++) { -struct e820_entry *ei = &e820_table->entries[i]; +struct e820_entry *entry = &e820_table->entries[i]; -if (pfn <PFN_UP (ei->addr)) -register_nosave_region (pfn,PFN_UP (ei->addr)); +if (pfn <PFN_UP (entry->addr)) +register_nosave_region (pfn,PFN_UP (entry->addr)); - pfn =PFN_DOWN (ei->addr + ei->size); + pfn =PFN_DOWN (entry->addr + entry->size); -if (ei->type !=E820_RAM && ei->type !=E820_RESERVED_KERN ) -register_nosave_region (PFN_UP (ei->addr), pfn); +if (entry->type !=E820_RAM && entry->type !=E820_RESERVED_KERN ) +register_nosave_region (PFN_UP (entry->addr), pfn);if (pfn >= limit_pfn)break ;
@@ -722,10 +722,10 @@ static int __init e820_mark_nvs_memory(void)int i;for (i =0 ; i < e820_table->nr_entries; i++) { -struct e820_entry *ei = &e820_table->entries[i]; +struct e820_entry *entry = &e820_table->entries[i]; -if (ei->type ==E820_NVS ) -acpi_nvs_register (ei->addr, ei->size); +if (entry->type ==E820_NVS ) +acpi_nvs_register (entry->addr, entry->size); }return 0 ;
@@ -770,15 +770,15 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type)unsigned long max_arch_pfn =MAX_ARCH_PFN ;for (i =0 ; i < e820_table->nr_entries; i++) { -struct e820_entry *ei = &e820_table->entries[i]; +struct e820_entry *entry = &e820_table->entries[i];unsigned long start_pfn;unsigned long end_pfn; -if (ei->type != type) +if (entry->type != type)continue ; - start_pfn = ei->addr >>PAGE_SHIFT ; - end_pfn = (ei->addr + ei->size) >>PAGE_SHIFT ; + start_pfn = entry->addr >>PAGE_SHIFT ; + end_pfn = (entry->addr + entry->size) >>PAGE_SHIFT ;if (start_pfn >= limit_pfn)continue ;
@@ -1155,16 +1155,16 @@ void __init e820__memblock_setup(void)memblock_allow_resize ();for (i =0 ; i < e820_table->nr_entries; i++) { -struct e820_entry *ei = &e820_table->entries[i]; +struct e820_entry *entry = &e820_table->entries[i]; - end = ei->addr + ei->size; + end = entry->addr + entry->size;if (end != (resource_size_t )end)continue ; -if (ei->type !=E820_RAM && ei->type !=E820_RESERVED_KERN ) +if (entry->type !=E820_RAM && entry->type !=E820_RESERVED_KERN )continue ; -memblock_add (ei->addr, ei->size); +memblock_add (entry->addr, entry->size); }/* Throw away partial pages: */
Signature · 1 line
2.7.4
PATCH 22/50 x86/boot/e820: Convert printk(KERN_* ...) to pr_*()
In reply to Ingo MolnarNo change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/kernel/e820.c | 50 +++++++++++++++++++++++++------------------------- 1 file changed, 25 insertions(+), 25 deletions(-)
arch/x86/kernel/e820.c +25 -25
@@ -130,7 +130,7 @@ static void __init __e820_add_region(struct e820_table *table, u64 start, u64 siint x = table->nr_entries;if (x >=ARRAY_SIZE (table->entries)) { -printk (KERN_ERR "e820: too many entries; ignoring [mem %#010llx-%#010llx]\n" , start, start + size -1 ); +pr_err ("e820: too many entries; ignoring [mem %#010llx-%#010llx]\n" , start, start + size -1 );return ; }
@@ -149,14 +149,14 @@ static void __init e820_print_type(u32 type) {switch (type) {case E820_RAM :/* Fall through: */ -case E820_RESERVED_KERN :printk (KERN_CONT "usable" );break ; -case E820_RESERVED :printk (KERN_CONT "reserved" );break ; -case E820_ACPI :printk (KERN_CONT "ACPI data" );break ; -case E820_NVS :printk (KERN_CONT "ACPI NVS" );break ; -case E820_UNUSABLE :printk (KERN_CONT "unusable" );break ; +case E820_RESERVED_KERN :pr_cont ("usable" );break ; +case E820_RESERVED :pr_cont ("reserved" );break ; +case E820_ACPI :pr_cont ("ACPI data" );break ; +case E820_NVS :pr_cont ("ACPI NVS" );break ; +case E820_UNUSABLE :pr_cont ("unusable" );break ;case E820_PMEM :/* Fall through: */ -case E820_PRAM :printk (KERN_CONT "persistent (type %u)" , type);break ; -default :printk (KERN_CONT "type %u" , type);break ; +case E820_PRAM :pr_cont ("persistent (type %u)" , type);break ; +default :pr_cont ("type %u" , type);break ; } }
@@ -165,12 +165,12 @@ void __init e820_print_map(char *who)int i;for (i =0 ; i < e820_table->nr_entries; i++) { -printk (KERN_INFO "%s: [mem %#018Lx-%#018Lx] " , who, +pr_info ("%s: [mem %#018Lx-%#018Lx] " , who, e820_table->entries[i].addr, e820_table->entries[i].addr + e820_table->entries[i].size -1 );e820_print_type (e820_table->entries[i].type); -printk (KERN_CONT "\n" ); +pr_cont ("\n" ); } }
@@ -419,11 +419,11 @@ __e820_update_range(struct e820_table *table, u64 start, u64 size, unsigned old_ size =ULLONG_MAX - start; end = start + size; -printk (KERN_DEBUG "e820: update [mem %#010Lx-%#010Lx] " , start, end -1 ); +pr_debug ("e820: update [mem %#010Lx-%#010Lx] " , start, end -1 );e820_print_type (old_type); -printk (KERN_CONT " ==> " ); +pr_cont (" ==> " );e820_print_type (new_type); -printk (KERN_CONT "\n" ); +pr_cont ("\n" );for (i =0 ; i < table->nr_entries; i++) {struct e820_entry *entry = &table->entries[i];
@@ -495,10 +495,10 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, int checkty size =ULLONG_MAX - start; end = start + size; -printk (KERN_DEBUG "e820: remove [mem %#010Lx-%#010Lx] " , start, end -1 ); +pr_debug ("e820: remove [mem %#010Lx-%#010Lx] " , start, end -1 );if (checktype)e820_print_type (old_type); -printk (KERN_CONT "\n" ); +pr_cont ("\n" );for (i =0 ; i < e820_table->nr_entries; i++) {struct e820_entry *entry = &e820_table->entries[i];
@@ -551,7 +551,7 @@ void __init update_e820(void)if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries))return ; -printk (KERN_INFO "e820: modified physical RAM map:\n" ); +pr_info ("e820: modified physical RAM map:\n" );e820_print_map ("modified" ); }
@@ -613,7 +613,7 @@ __init void e820_setup_gap(void)if (!found) {#ifdef CONFIG_X86_64 gapstart = (max_pfn <<PAGE_SHIFT ) +1024 *1024 ; -printk (KERN_ERR +pr_err ("e820: Cannot find an available gap in the 32-bit address range\n" "e820: PCI devices with unassigned 32-bit BARs may not work!\n" );#else
@@ -626,7 +626,7 @@ __init void e820_setup_gap(void)*/ pci_mem_start = gapstart; -printk (KERN_INFO "e820: [mem %#010lx-%#010lx] available for PCI devices\n" , gapstart, gapstart + gapsize -1 ); +pr_info ("e820: [mem %#010lx-%#010lx] available for PCI devices\n" , gapstart, gapstart + gapsize -1 ); }/*
@@ -679,7 +679,7 @@ void __init parse_e820_ext(u64 phys_addr, u32 data_len)sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);early_memunmap (sdata, data_len); -printk (KERN_INFO "e820: extended physical RAM map:\n" ); +pr_info ("e820: extended physical RAM map:\n" );e820_print_map ("extended" ); }
@@ -743,7 +743,7 @@ u64 __init early_reserve_e820(u64 size, u64 align) addr =__memblock_alloc_base (size, align,MEMBLOCK_ALLOC_ACCESSIBLE );if (addr) {e820_update_range_firmware (addr, size,E820_RAM ,E820_RESERVED ); -printk (KERN_INFO "e820: update e820_table_firmware for early_reserve_e820\n" ); +pr_info ("e820: update e820_table_firmware for early_reserve_e820\n" );update_e820_table_firmware (); }
@@ -793,7 +793,7 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type)if (last_pfn > max_arch_pfn) last_pfn = max_arch_pfn; -printk (KERN_INFO "e820: last_pfn = %#lx max_arch_pfn = %#lx\n" , +pr_info ("e820: last_pfn = %#lx max_arch_pfn = %#lx\n" , last_pfn, max_arch_pfn);return last_pfn; }
@@ -829,7 +829,7 @@ static int __init parse_memopt(char *p)setup_clear_cpu_cap (X86_FEATURE_PSE );return 0 ;#else -printk (KERN_WARNING "mem=nopentium ignored! (only supported on x86_32)\n" ); +pr_warn ("mem=nopentium ignored! (only supported on x86_32)\n" );return -EINVAL ;#endif }
@@ -916,7 +916,7 @@ void __init finish_e820_parsing(void)if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries) <0 )early_panic ("Invalid user supplied memory map" ); -printk (KERN_INFO "e820: user-defined physical RAM map:\n" ); +pr_info ("e820: user-defined physical RAM map:\n" );e820_print_map ("user" ); } }
@@ -1078,7 +1078,7 @@ void __init e820_reserve_resources_late(void)if (start >= end)continue ; -printk (KERN_DEBUG "e820: reserve RAM buffer [mem %#010llx-%#010llx]\n" , start, end); +pr_debug ("e820: reserve RAM buffer [mem %#010llx-%#010llx]\n" , start, end);reserve_region_with_split (&iomem_resource, start, end,"RAM buffer" ); } }
@@ -1134,7 +1134,7 @@ void __init e820__memory_setup(void)memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table )); -printk (KERN_INFO "e820: BIOS-provided physical RAM map:\n" ); +pr_info ("e820: BIOS-provided physical RAM map:\n" );e820_print_map (who); }
Signature · 1 line
2.7.4
Re: [PATCH 22/50] x86/boot/e820: Convert printk(KERN_* ...) to pr_*()
Quoted 1 line · Ingo Molnar
No change in functionality.
Not true.
arch/x86/kernel/e820.c __e820_update_range(struct e820_table *table, u64 start, u64 size, unsigned old_ · line 422
Quoted 6 lines
arch/x86/kernel/e820.c +1
-1@@ -419,11 +419,11 @@ __e820_update_range(struct e820_table *table, u64 start, u64 size, unsigned old_ size =ULLONG_MAX - start; end = start + size; -printk (KERN_DEBUG "e820: update [mem %#010Lx-%#010Lx] " , start, end -1 ); +pr_debug ("e820: update [mem %#010Lx-%#010Lx] " , start, end -1 );
#define DEBUG is not set here so this conversion is not equivalent.
pr_debug will be removed unless CONFIG_DYNAMIC_DEBUG is enabled and also will not be enabled by default.
arch/x86/kernel/e820.c __e820_update_range(struct e820_table *table, u64 start, u64 size, unsigned old_ · line 424
Quoted 3 lines
arch/x86/kernel/e820.c +1
-1e820_print_type (old_type); -printk (KERN_CONT " ==> " ); +pr_cont (" ==> " );
This will always be emitted.
arch/x86/kernel/e820.c u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, int checkty · line 498
Quoted 6 lines
arch/x86/kernel/e820.c +1
-1@@ -495,10 +495,10 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, int checkty size =ULLONG_MAX - start; end = start + size; -printk (KERN_DEBUG "e820: remove [mem %#010Lx-%#010Lx] " , start, end -1 ); + pr_debug("e820: remove [mem %#010Lx-%#010Lx] ", start,
etc...
PATCH 23/50 x86/boot/e820: Move the memblock_find_dma_reserve() function and rename it to memblock_set_dma_reserve()
In reply to Ingo MolnarWe introduced memblock_find_dma_reserve() in this commit:
6f2a75369e75 x86, memblock: Use memblock_memory_size()/memblock_free_memory_size() to get correct dma_reserve
But there's several problems with it:
- The changelog is full of typos and is incomprehensible in general, and the comments in the code are not much better either.
- The function was inexplicably placed into e820.c, while it has very little connection to the E820 table: when we call memblock_find_dma_reserve() then memblock is already set up and we are not using the E820 table anymore.
- The function is a wrapper around set_dma_reserve(), but changed the 'set' name to 'find' - actively misleading about its primary purpose, which is still to set the DMA-reserve value.
- The function is limited to 64-bit systems, but neither the changelog nor the comments explain why. The change would appear to be relevant to 32-bit systems as well, as the ISA DMA zone is the first 16 MB of RAM.
So address some of these problems:
- Move it into arch/x86/mm/init.c, next to the other zone setup related functions.
- Clean up the code flow and names of local variables a bit.
- Rename it to memblock_set_dma_reserve()
- Improve the comments.
No change in functionality. Enabling it for 32-bit systems is left for a separate patch.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 1 - arch/x86/include/asm/pgtable.h | 1 + arch/x86/kernel/e820.c | 31 ------------------------------- arch/x86/mm/init.c | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 48 insertions(+), 32 deletions(-)
arch/x86/include/asm/e820/api.h +0 -1
@@ -22,7 +22,6 @@ extern unsigned long e820_end_of_ram_pfn(void);extern unsigned long e820_end_of_low_ram_pfn (void );extern u64 early_reserve_e820 (u64 sizet,u64 align);extern void e820__memblock_setup (void ); -extern void memblock_find_dma_reserve (void );extern void finish_e820_parsing (void );extern void e820_reserve_resources (void );extern void e820_reserve_resources_late (void );
arch/x86/include/asm/pgtable.h +1 -0
@@ -733,6 +733,7 @@ static inline int pgd_none(pgd_t pgd)extern int direct_gbpages;void init_mem_mapping (void );void early_alloc_pgt_buf (void ); +extern void memblock_find_dma_reserve (void );#ifdef CONFIG_X86_64 /* Realmode trampoline initialization. */
arch/x86/kernel/e820.c +0 -31
@@ -1172,34 +1172,3 @@ void __init e820__memblock_setup(void)memblock_dump_all (); } - -void __init memblock_find_dma_reserve (void ) -{ -#ifdef CONFIG_X86_64 -u64 nr_pages =0 , nr_free_pages =0 ; -unsigned long start_pfn, end_pfn; -phys_addr_t start, end; -int i; -u64 u; - -/* -* need to find out used area below MAX_DMA_PFN -* need to use memblock to get free size in [0, MAX_DMA_PFN] -* at first, and assume boot_mem will not take below MAX_DMA_PFN -*/ -for_each_mem_pfn_range (i,MAX_NUMNODES , &start_pfn, &end_pfn,NULL ) { - start_pfn =min (start_pfn,MAX_DMA_PFN ); - end_pfn =min (end_pfn,MAX_DMA_PFN ); - nr_pages += end_pfn - start_pfn; - } - -for_each_free_mem_range (u,NUMA_NO_NODE ,MEMBLOCK_NONE , &start, &end,NULL ) { - start_pfn = min_t(unsigned long, PFN_UP(start), MAX_DMA_PFN); - end_pfn = min_t(unsigned long, PFN_DOWN(end), MAX_DMA_PFN); -if (start_pfn < end_pfn) - nr_free_pages += end_pfn - start_pfn; - } - -set_dma_reserve (nr_pages - nr_free_pages); -#endif -}
arch/x86/mm/init.c +47 -0
53 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH 24/50 x86/boot/e820: Rename parse_e820_ext() to e820__memory_setup_extended()
In reply to Ingo Molnarparse_e820_ext() is very similar to e820__memory_setup_default(), both are taking bootloader provided data, add it to the E820 table and then pass it sanitize_e820_table().
Rename it to e820__memory_setup_extended() to better signal their similar role.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/e820.c | 2 +- arch/x86/kernel/setup.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -17,7 +17,7 @@ extern u64 e820_update_range(u64 start, u64 size, unsigned old_type, unsigned nextern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void update_e820 (void );extern void e820_setup_gap (void ); -extern void parse_e820_ext (u64 phys_addr,u32 data_len); +extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len);extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void );extern u64 early_reserve_e820 (u64 sizet,u64 align);
arch/x86/kernel/e820.c +1 -1
@@ -665,7 +665,7 @@ __init void e820_reallocate_tables(void)* the remaining (if any) entries are passed via the SETUP_E820_EXT node of * struct setup_data, which is parsed here. */ -void __init parse_e820_ext (u64 phys_addr,u32 data_len) +void __init e820__memory_setup_extended (u64 phys_addr,u32 data_len) {int entries;struct e820_entry *extmap;
arch/x86/kernel/setup.c +1 -1
@@ -426,7 +426,7 @@ static void __init parse_setup_data(void)switch (data_type) {case SETUP_E820_EXT : -parse_e820_ext (pa_data, data_len); +e820__memory_setup_extended (pa_data, data_len);break ;case SETUP_DTB :add_dtb (pa_data);
Signature · 1 line
2.7.4
PATCH 25/50 x86/boot/e820: Move e820_reserve_setup_data() to e820.c
In reply to Ingo MolnarThe e820_reserve_setup_data() is local to arch/x86/kernel/setup.c, but it is E820 functionality - so move it to e820.c to better isolate E820 functionality.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 1 + arch/x86/kernel/e820.c | 22 ++++++++++++++++++++++ arch/x86/kernel/setup.c | 23 ----------------------- 3 files changed, 23 insertions(+), 23 deletions(-)
arch/x86/include/asm/e820/api.h +1 -0
@@ -22,6 +22,7 @@ extern unsigned long e820_end_of_ram_pfn(void);extern unsigned long e820_end_of_low_ram_pfn (void );extern u64 early_reserve_e820 (u64 sizet,u64 align);extern void e820__memblock_setup (void ); +extern void e820_reserve_setup_data (void );extern void finish_e820_parsing (void );extern void e820_reserve_resources (void );extern void e820_reserve_resources_late (void );
arch/x86/kernel/e820.c +22 -0
@@ -910,6 +910,28 @@ static int __init parse_memmap_opt(char *str) }early_param ("memmap" , parse_memmap_opt); +void __init e820_reserve_setup_data (void ) +{ +struct setup_data *data; +u64 pa_data; + + pa_data = boot_params.hdr.setup_data; +if (!pa_data) +return ; + +while (pa_data) { + data =early_memremap (pa_data,sizeof (*data)); +e820_update_range (pa_data,sizeof (*data)+data->len,E820_RAM ,E820_RESERVED_KERN ); + pa_data = data->next; +early_memunmap (data,sizeof (*data)); + } + +sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table )); +printk (KERN_INFO "extended physical RAM map:\n" ); +e820_print_map ("reserve setup_data" ); +} +void __init finish_e820_parsing (void ) {if (userdef) {
arch/x86/kernel/setup.c +0 -23
@@ -441,29 +441,6 @@ static void __init parse_setup_data(void) } } -static void __init e820_reserve_setup_data (void ) -{ -struct setup_data *data; -u64 pa_data; - - pa_data = boot_params.hdr.setup_data; -if (!pa_data) -return ; - -while (pa_data) { - data =early_memremap (pa_data,sizeof (*data)); -e820_update_range (pa_data,sizeof (*data)+data->len, -E820_RAM ,E820_RESERVED_KERN ); - pa_data = data->next; -early_memunmap (data,sizeof (*data)); - } - -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); -memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table )); -printk (KERN_INFO "extended physical RAM map:\n" ); -e820_print_map ("reserve setup_data" ); -} -static void __init memblock_x86_reserve_range_setup_data (void ) {struct setup_data *data;
Signature · 1 line
2.7.4
PATCH 26/50 x86/boot/e820: Clarify the role of finish_e820_parsing() and rename it to e820__finish_early_params()
In reply to Ingo Molnarfinish_e820_parsing() is closely related to parse_early_params(), but the name does not tell us this clearly, so rename it to e820__finish_early_params().
Also add a few comments to explain what the function does.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/e820.c | 7 ++++++- arch/x86/kernel/setup.c | 2 +- 3 files changed, 8 insertions(+), 3 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -23,7 +23,7 @@ extern unsigned long e820_end_of_low_ram_pfn(void);extern u64 early_reserve_e820 (u64 sizet,u64 align);extern void e820__memblock_setup (void );extern void e820_reserve_setup_data (void ); -extern void finish_e820_parsing (void ); +extern void e820__finish_early_params (void );extern void e820_reserve_resources (void );extern void e820_reserve_resources_late (void );extern void e820__memory_setup (void );
arch/x86/kernel/e820.c +6 -1
@@ -932,7 +932,12 @@ void __init e820_reserve_setup_data(void)e820_print_map ("reserve setup_data" ); } -void __init finish_e820_parsing (void ) +/* +* Called after parse_early_param(), after early parameters (such as mem=) +* have been processed, in which case we already have an E820 table filled in +* via the parameter callback function(s), but it's not sorted and printed yet: +*/ +void __init e820__finish_early_params (void ) {if (userdef) {if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries) <0 )
arch/x86/kernel/setup.c +1 -1
@@ -1005,7 +1005,7 @@ void __init setup_arch(char **cmdline_p)/* update the e820_table_firmware too */ e820_reserve_setup_data (); -finish_e820_parsing (); +e820__finish_early_params ();if (efi_enabled (EFI_BOOT ))efi_init ();
Signature · 1 line
2.7.4
PATCH 27/50 x86/boot/e820: Rename early_reserve_e820() to e820__memblock_alloc() and document it
In reply to Ingo Molnarearly_reserve_e820() is an early hack for kexec that does a limited fixup of the mptable and passes it to the kexec kernel as if it was the real thing.
For this it needs to allocate memory - but no memory allocator is available yet beyond the memblock allocator, so early_reserve_e820() is really a wrapper around memblock_alloc() plus a hack to update the e820_table_firmware entries.
The name 'reserve' is really a bit of a misnomer, as 'reserved' memory typically means memory completely inaccessible to the kernel - while here what we want to do is a special RAM allocation for our own purposes and insert that as RAM_RESERVED.
Rename the function to e820__memblock_alloc_reserved() to better signal this dual purpose, plus document it better, which was omitted when it was merged. The barely comprehensible and cryptic comment:
/*
* pre allocated 4k and reserved it in memblock and e820_table_firmware */
u64 __init e820__memblock_alloc_reserved(u64 size, u64 align)
... does not count as documentation, replace it with:
/*
* Allocate the requested number of bytes with the requsted alignment
* and return (the physical address) to the caller. Also register this
* range in the 'firmware' E820 table.
*
* This allows kexec to fake a new mptable, as if it came from the real
* system.
*/
u64 __init e820__memblock_alloc_reserved(u64 size, u64 align)
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/include/asm/mpspec.h | 4 ++-- arch/x86/kernel/e820.c | 11 ++++++++--- arch/x86/kernel/mpparse.c | 4 ++-- arch/x86/kernel/setup.c | 2 +- 5 files changed, 14 insertions(+), 9 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -20,7 +20,7 @@ extern void e820_setup_gap(void);extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len);extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void ); -extern u64 early_reserve_e820 (u64 sizet,u64 align); +extern u64 e820__memblock_alloc_reserved (u64 sizet,u64 align);extern void e820__memblock_setup (void );extern void e820_reserve_setup_data (void );extern void e820__finish_early_params (void );
arch/x86/include/asm/mpspec.h +2 -2
@@ -64,7 +64,7 @@ static inline void find_smp_config(void) }#ifdef CONFIG_X86_MPPARSE -extern void early_reserve_e820_mpc_new (void ); +extern void e820__memblock_alloc_reserved_mpc_new (void );extern int enable_update_mptable;extern int default_mpc_apic_id (struct mpc_cpu *m);extern void default_smp_read_mpc_oem (struct mpc_table *mpc);
@@ -76,7 +76,7 @@ extern void default_mpc_oem_bus_info(struct mpc_bus *m, char *str);extern void default_find_smp_config (void );extern void default_get_smp_config (unsigned int early);#else -static inline void early_reserve_e820_mpc_new (void ) { } +static inline void e820__memblock_alloc_reserved_mpc_new (void ) { }#define enable_update_mptable 0#define default_mpc_apic_id NULL#define default_smp_read_mpc_oem NULL
arch/x86/kernel/e820.c +8 -3
@@ -734,16 +734,21 @@ core_initcall(e820_mark_nvs_memory);#endif /* -* pre allocated 4k and reserved it in memblock and e820_table_firmware +* Allocate the requested number of bytes with the requsted alignment +* and return (the physical address) to the caller. Also register this +* range in the 'firmware' E820 table as a reserved range. +* +* This allows kexec to fake a new mptable, as if it came from the real +* system. */ -u64 __init early_reserve_e820 (u64 size,u64 align) +u64 __init e820__memblock_alloc_reserved (u64 size,u64 align) {u64 addr; addr =__memblock_alloc_base (size, align,MEMBLOCK_ALLOC_ACCESSIBLE );if (addr) {e820_update_range_firmware (addr, size,E820_RAM ,E820_RESERVED ); -pr_info ("e820: update e820_table_firmware for early_reserve_e820\n" ); +pr_info ("e820: update e820_table_firmware for e820__memblock_alloc_reserved()\n" );update_e820_table_firmware (); }
arch/x86/kernel/mpparse.c +2 -2
@@ -826,10 +826,10 @@ static int __init parse_alloc_mptable_opt(char *p) }early_param ("alloc_mptable" , parse_alloc_mptable_opt); -void __init early_reserve_e820_mpc_new (void ) +void __init e820__memblock_alloc_reserved_mpc_new (void ) {if (enable_update_mptable && alloc_mptable) - mpc_new_phys =early_reserve_e820 (mpc_new_length,4 ); + mpc_new_phys =e820__memblock_alloc_reserved (mpc_new_length,4 ); }static int __init update_mp_table (void )
arch/x86/kernel/setup.c +1 -1
@@ -1112,7 +1112,7 @@ void __init setup_arch(char **cmdline_p) }/* preallocate 4k for mptable mpc */ -early_reserve_e820_mpc_new (); +e820__memblock_alloc_reserved_mpc_new ();#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION setup_bios_corruption_check ();
Signature · 1 line
2.7.4
PATCH 28/50 x86/boot/e820: Rename update_e820() to e820__update_table()
In reply to Ingo Molnarupdate_e820() should have 'e820' as a prefix as most of the other E820 functions have - but it's also a bit unclear about its purpose, as it's unclear what is updated - the whole table, or an entry?
Also, the name does not express that it's a trivial wrapper around sanitize_e820_table() that also prints out the resulting table.
So rename it to e820__update_table_print(). This also makes it harmonize with the e820__update_table_firmware() function which has a very similar purpose.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/acpi/boot.c | 2 +- arch/x86/kernel/aperture_64.c | 2 +- arch/x86/kernel/cpu/mtrr/cleanup.c | 2 +- arch/x86/kernel/e820.c | 6 +++--- 5 files changed, 7 insertions(+), 7 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -15,7 +15,7 @@ extern void e820_print_map(char *who);extern int sanitize_e820_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type);extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype); -extern void update_e820 (void ); +extern void e820__update_table_print (void );extern void e820_setup_gap (void );extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len);extern unsigned long e820_end_of_ram_pfn (void );
arch/x86/kernel/acpi/boot.c +1 -1
@@ -1716,5 +1716,5 @@ int __acpi_release_global_lock(unsigned int *lock)void __init arch_reserve_mem_area (acpi_physical_address addr,size_t size) {e820_add_region (addr, size,E820_ACPI ); -update_e820 (); +e820__update_table_print (); }
arch/x86/kernel/aperture_64.c +1 -1
@@ -312,7 +312,7 @@ void __init early_gart_iommu_check(void)pr_info ("e820: reserve [mem %#010Lx-%#010Lx] for GART\n" , aper_base, aper_base + aper_size -1 );e820_add_region (aper_base, aper_size,E820_RESERVED ); -update_e820 (); +e820__update_table_print (); } }
arch/x86/kernel/cpu/mtrr/cleanup.c +1 -1
@@ -978,7 +978,7 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)WARN_ON (1 );pr_info ("update e820 for mtrr\n" ); -update_e820 (); +e820__update_table_print ();return 1 ; }
arch/x86/kernel/e820.c +3 -3
@@ -546,7 +546,7 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, int checktyreturn real_removed_size; } -void __init update_e820 (void ) +void __init e820__update_table_print (void ) {if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries))return ;
@@ -555,7 +555,7 @@ void __init update_e820(void)e820_print_map ("modified" ); } -static void __init update_e820_table_firmware (void ) +static void __init e820__update_table_firmware (void ) {sanitize_e820_table (e820_table_firmware->entries,ARRAY_SIZE (e820_table_firmware->entries), &e820_table_firmware->nr_entries); }
@@ -749,7 +749,7 @@ u64 __init e820__memblock_alloc_reserved(u64 size, u64 align)if (addr) {e820_update_range_firmware (addr, size,E820_RAM ,E820_RESERVED );pr_info ("e820: update e820_table_firmware for e820__memblock_alloc_reserved()\n" ); -update_e820_table_firmware (); +e820__update_table_firmware (); }return addr;
Signature · 1 line
2.7.4
PATCH 29/50 x86/boot/e820: Rename sanitize_e820_table() to e820__update_table()
In reply to Ingo Molnarsanitize_e820_table() is a minor misnomer in that it suggests that the E820 table requires sanitizing - which implies that it will only do anything if the E820 table is irregular (not sane).
That is wrong, because sanitize_e820_table() also does a very regular sorting of the E820 table, which is a necessity in the basic append-only flow of E820 updates the kernel is allowed to perform to it.
So rename it to e820__update_table() to include that purpose as well.
This also lines up all the table-update functions into a coherent naming family:
int e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *pnr_map); void e820__update_table_print(void); void e820__update_table_firmware(void);
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/include/asm/e820/types.h | 2 +- arch/x86/kernel/e820.c | 16 ++++++++-------- arch/x86/kernel/early-quirks.c | 2 +- arch/x86/kernel/setup.c | 4 ++-- arch/x86/platform/efi/efi.c | 2 +- arch/x86/xen/setup.c | 6 +++--- 7 files changed, 17 insertions(+), 17 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -12,7 +12,7 @@ extern int e820_any_mapped(u64 start, u64 end, unsigned type);extern int e820_all_mapped (u64 start,u64 end,unsigned type);extern void e820_add_region (u64 start,u64 size,int type);extern void e820_print_map (char *who); -extern int sanitize_e820_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map); +extern int e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type);extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void e820__update_table_print (void );
arch/x86/include/asm/e820/types.h +1 -1
@@ -21,7 +21,7 @@* * This allows for bootstrap/firmware quirks such as possible duplicate * E820 entries that might need room in the same arrays, prior to the -* call to sanitize_e820_table() to remove duplicates. The allowance +* call to e820__update_table() to remove duplicates. The allowance * of three memory map entries per node is "enough" entries for * the initial hardware platform motivating this mechanism to make * use of additional EFI map entries. Future platforms may want
arch/x86/kernel/e820.c +8 -8
@@ -193,7 +193,7 @@ void __init e820_print_map(char *who)* sanitizing succeeds the *pnr_map will be updated with the new * number of valid entries (something no more than max_nr_map). * -* The return value from sanitize_e820_table() is zero if it +* The return value from e820__update_table() is zero if it * successfully 'sanitized' the map entries passed in, and is -1 * if it did nothing, which can happen if either of (1) it was * only passed one map entry, or (2) any of the input map entries
@@ -259,7 +259,7 @@ static int __init cpcompare(const void *a, const void *b)return (ap->addr != ap->pbios->addr) - (bp->addr != bp->pbios->addr); } -int __init sanitize_e820_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map) +int __init e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map) {static struct change_member change_point_list[2 *E820_X_MAX ]__initdata ;static struct change_member *change_point[2 *E820_X_MAX ]__initdata ;
@@ -548,7 +548,7 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, int checktyvoid __init e820__update_table_print (void ) { -if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries)) +if (e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries))return ;pr_info ("e820: modified physical RAM map:\n" );
@@ -557,7 +557,7 @@ void __init e820__update_table_print(void)static void __init e820__update_table_firmware (void ) { -sanitize_e820_table (e820_table_firmware->entries,ARRAY_SIZE (e820_table_firmware->entries), &e820_table_firmware->nr_entries); +e820__update_table (e820_table_firmware->entries,ARRAY_SIZE (e820_table_firmware->entries), &e820_table_firmware->nr_entries); }#define MAX_GAP_END 0x100000000ull
@@ -676,7 +676,7 @@ void __init e820__memory_setup_extended(u64 phys_addr, u32 data_len) extmap = (struct e820_entry *)(sdata->data);__append_e820_table (extmap, entries); -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);early_memunmap (sdata, data_len);pr_info ("e820: extended physical RAM map:\n" );
@@ -931,7 +931,7 @@ void __init e820_reserve_setup_data(void)early_memunmap (data,sizeof (*data)); } -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table ));printk (KERN_INFO "extended physical RAM map:\n" );e820_print_map ("reserve setup_data" );
@@ -945,7 +945,7 @@ void __init e820_reserve_setup_data(void)void __init e820__finish_early_params (void ) {if (userdef) { -if (sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries) <0 ) +if (e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries) <0 )early_panic ("Invalid user supplied memory map" );pr_info ("e820: user-defined physical RAM map:\n" );
@@ -1130,7 +1130,7 @@ char *__init e820__memory_setup_default(void)* the next section from 1mb->appropriate_mem_k */ new_nr = boot_params.e820_entries; -sanitize_e820_table (boot_params.e820_table,ARRAY_SIZE (boot_params.e820_table), &new_nr); +e820__update_table (boot_params.e820_table,ARRAY_SIZE (boot_params.e820_table), &new_nr); boot_params.e820_entries = new_nr;if (append_e820_table (boot_params.e820_table, boot_params.e820_entries) <0 ) {
arch/x86/kernel/early-quirks.c +1 -1
@@ -547,7 +547,7 @@ intel_graphics_stolen(int num, int slot, int func,/* Mark this space as reserved */ e820_add_region (base, size,E820_RESERVED ); -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }static void __init intel_graphics_quirks (int num,int slot,int func)
arch/x86/kernel/setup.c +2 -2
@@ -740,7 +740,7 @@ static void __init trim_bios_range(void)*/ e820_remove_range (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_RAM ,1 ); -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }/* called before trim_bios_range() to spare extra sanitize */
@@ -1033,7 +1033,7 @@ void __init setup_arch(char **cmdline_p)if (ppro_with_ram_bug ()) {e820_update_range (0x70000000ULL ,0x40000ULL ,E820_RAM ,E820_RESERVED ); -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);printk (KERN_INFO "fixed physical RAM map:\n" );e820_print_map ("bad_ppro" ); }
arch/x86/platform/efi/efi.c +1 -1
@@ -167,7 +167,7 @@ static void __init do_add_efi_memmap(void) }e820_add_region (start, size, e820_type); } -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }int __init efi_memblock_x86_reserve_range (void )
arch/x86/xen/setup.c +3 -3
@@ -783,7 +783,7 @@ char * __init xen_memory_setup(void)xen_ignore_unusable ();/* Make sure the Xen-supplied memory map is well-ordered. */ -sanitize_e820_table (xen_e820_table,ARRAY_SIZE (xen_e820_table), +e820__update_table (xen_e820_table,ARRAY_SIZE (xen_e820_table), &xen_e820_table_entries); max_pages =xen_get_max_pages ();
@@ -861,7 +861,7 @@ char * __init xen_memory_setup(void)e820_add_region (ISA_START_ADDRESS ,ISA_END_ADDRESS -ISA_START_ADDRESS ,E820_RESERVED ); -sanitize_e820_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);/* * Check whether the kernel itself conflicts with the target E820 map.
@@ -932,7 +932,7 @@ char * __init xen_auto_xlated_memory_setup(void) xen_e820_table_entries = memmap.nr_entries; -sanitize_e820_table (xen_e820_table,ARRAY_SIZE (xen_e820_table), +e820__update_table (xen_e820_table,ARRAY_SIZE (xen_e820_table), &xen_e820_table_entries);for (i =0 ; i < xen_e820_table_entries; i++)
Signature · 1 line
2.7.4
PATCH 30/50 x86/boot/e820: Rename e820_any_mapped()/e820_all_mapped() to e820__mapped_any()/e820__mapped_all()
In reply to Ingo MolnarThe 'any' and 'all' are modified to the 'mapped' concept, so move them last in the name.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 4 ++-- arch/x86/include/asm/gart.h | 2 +- arch/x86/kernel/aperture_64.c | 2 +- arch/x86/kernel/e820.c | 6 +++--- arch/x86/kernel/setup.c | 2 +- arch/x86/kernel/tboot.c | 2 +- arch/x86/mm/init_64.c | 12 ++++++------ arch/x86/pci/mmconfig-shared.c | 4 ++-- arch/x86/platform/efi/quirks.c | 2 +- 9 files changed, 18 insertions(+), 18 deletions(-)
arch/x86/include/asm/e820/api.h +2 -2
@@ -8,8 +8,8 @@ extern struct e820_table *e820_table_firmware;extern unsigned long pci_mem_start; -extern int e820_any_mapped (u64 start,u64 end,unsigned type); -extern int e820_all_mapped (u64 start,u64 end,unsigned type); +extern int e820__mapped_any (u64 start,u64 end,unsigned type); +extern int e820__mapped_all (u64 start,u64 end,unsigned type);extern void e820_add_region (u64 start,u64 size,int type);extern void e820_print_map (char *who);extern int e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);
arch/x86/include/asm/gart.h +1 -1
@@ -97,7 +97,7 @@ static inline int aperture_valid(u64 aper_base, u32 aper_size, u32 min_size)printk (KERN_INFO "Aperture beyond 4GB. Ignoring.\n" );return 0 ; } -if (e820_any_mapped (aper_base, aper_base + aper_size,E820_RAM )) { +if (e820__mapped_any (aper_base, aper_base + aper_size,E820_RAM )) {printk (KERN_INFO "Aperture pointing to e820 RAM. Ignoring.\n" );return 0 ; }
arch/x86/kernel/aperture_64.c +1 -1
@@ -306,7 +306,7 @@ void __init early_gart_iommu_check(void) fix =1 ;if (gart_fix_e820 && !fix && aper_enabled) { -if (e820_any_mapped (aper_base, aper_base + aper_size, +if (e820__mapped_any (aper_base, aper_base + aper_size,E820_RAM )) {/* reserve it, so we can reuse it in second kernel */ pr_info("e820: reserve [mem %#010Lx-%#010Lx] for GART\n",
arch/x86/kernel/e820.c +3 -3
@@ -68,7 +68,7 @@ EXPORT_SYMBOL(pci_mem_start);* This function checks if any part of the range <start,end> is mapped * with type. */ -int e820_any_mapped (u64 start,u64 end,unsigned type) +int e820__mapped_any (u64 start,u64 end,unsigned type) {int i;
@@ -83,7 +83,7 @@ int e820_any_mapped(u64 start, u64 end, unsigned type) }return 0 ; } -EXPORT_SYMBOL_GPL (e820_any_mapped); +EXPORT_SYMBOL_GPL (e820__mapped_any);/* * This function checks if the entire <start,end> range is mapped with 'type'.
@@ -91,7 +91,7 @@ EXPORT_SYMBOL_GPL(e820_any_mapped);* Note: this function only works correctly once the E820 table is sorted and * not-overlapping (at least for the range specified), which is the case normally. */ -int __init e820_all_mapped (u64 start,u64 end,unsigned type) +int __init e820__mapped_all (u64 start,u64 end,unsigned type) {int i;
arch/x86/kernel/setup.c +1 -1
@@ -756,7 +756,7 @@ static void __init e820_add_kernel_range(void)* exclude kernel range. If we really are running on top non-RAM, * we will crash later anyways. */ -if (e820_all_mapped (start, start + size,E820_RAM )) +if (e820__mapped_all (start, start + size,E820_RAM ))return ;pr_warn (".text .data .bss are not marked as E820_RAM!\n" );
arch/x86/kernel/tboot.c +1 -1
@@ -68,7 +68,7 @@ void __init tboot_probe(void)* also verify that it is mapped as we expect it before calling * set_fixmap(), to reduce chance of garbage value causing crash */ -if (!e820_any_mapped (boot_params.tboot_addr, +if (!e820__mapped_any (boot_params.tboot_addr, boot_params.tboot_addr,E820_RESERVED )) {pr_warning ("non-0 tboot_addr but it is not of type E820_RESERVED\n" );return ;
arch/x86/mm/init_64.c +6 -6
@@ -337,9 +337,9 @@ phys_pte_init(pte_t *pte_page, unsigned long paddr, unsigned long paddr_end, paddr_next = (paddr &PAGE_MASK ) +PAGE_SIZE ;if (paddr >= paddr_end) {if (!after_bootmem && - !e820_any_mapped (paddr &PAGE_MASK , paddr_next, + !e820__mapped_any (paddr &PAGE_MASK , paddr_next,E820_RAM ) && - !e820_any_mapped (paddr &PAGE_MASK , paddr_next, + !e820__mapped_any (paddr &PAGE_MASK , paddr_next,E820_RESERVED_KERN ))set_pte (pte,__pte (0 ));continue ;
@@ -392,9 +392,9 @@ phys_pmd_init(pmd_t *pmd_page, unsigned long paddr, unsigned long paddr_end, paddr_next = (paddr &PMD_MASK ) +PMD_SIZE ;if (paddr >= paddr_end) {if (!after_bootmem && - !e820_any_mapped (paddr &PMD_MASK , paddr_next, + !e820__mapped_any (paddr &PMD_MASK , paddr_next,E820_RAM ) && - !e820_any_mapped (paddr &PMD_MASK , paddr_next, + !e820__mapped_any (paddr &PMD_MASK , paddr_next,E820_RESERVED_KERN ))set_pmd (pmd,__pmd (0 ));continue ;
@@ -478,9 +478,9 @@ phys_pud_init(pud_t *pud_page, unsigned long paddr, unsigned long paddr_end,if (paddr >= paddr_end) {if (!after_bootmem && - !e820_any_mapped (paddr &PUD_MASK , paddr_next, + !e820__mapped_any (paddr &PUD_MASK , paddr_next,E820_RAM ) && - !e820_any_mapped (paddr &PUD_MASK , paddr_next, + !e820__mapped_any (paddr &PUD_MASK , paddr_next,E820_RESERVED_KERN ))set_pud (pud,__pud (0 ));continue ;
arch/x86/pci/mmconfig-shared.c +2 -2
@@ -514,7 +514,7 @@ static int __ref pci_mmcfg_check_reserved(struct device *dev, }/* -* e820_all_mapped() is marked as __init. +* e820__mapped_all() is marked as __init. * All entries from ACPI MCFG table have been checked at boot time. * For MCFG information constructed from hotpluggable host bridge's * _CBA method, just assume it's reserved.
@@ -525,7 +525,7 @@ static int __ref pci_mmcfg_check_reserved(struct device *dev,/* Don't try to do this check unless configuration type 1 is available. how about type 2 ?*/ if (raw_pci_ops) -return is_mmconf_reserved (e820_all_mapped, cfg, dev,1 ); +return is_mmconf_reserved (e820__mapped_all, cfg, dev,1 );return 0 ; }
arch/x86/platform/efi/quirks.c +1 -1
@@ -249,7 +249,7 @@ static bool can_free_region(u64 start, u64 size)if (start + size >__pa_symbol (_text) && start <=__pa_symbol (_end))return false; -if (!e820_all_mapped (start, start+size,E820_RAM )) +if (!e820__mapped_all (start, start+size,E820_RAM ))return false;return true;
Signature · 1 line
2.7.4
PATCH 31/50 x86/boot/e820: Rename e820_setup_gap() to e820__setup_pci_gap()
In reply to Ingo MolnarThe e820_setup_gap() function name is unnecessarily silent about what kind of gap it sets up. Make it clear that it's about the PCI gap.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/e820.c | 2 +- arch/x86/kernel/setup.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -16,7 +16,7 @@ extern int e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type);extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void e820__update_table_print (void ); -extern void e820_setup_gap (void ); +extern void e820__setup_pci_gap (void );extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len);extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void );
arch/x86/kernel/e820.c +1 -1
@@ -602,7 +602,7 @@ static int __init e820_search_gap(unsigned long *gapstart, unsigned long *gapsiz* * Hopefully the BIOS let enough space left. */ -__init void e820_setup_gap (void ) +__init void e820__setup_pci_gap (void ) {unsigned long gapstart, gapsize;int found;
arch/x86/kernel/setup.c +1 -1
@@ -1241,7 +1241,7 @@ void __init setup_arch(char **cmdline_p) x86_init.resources.reserve_resources (); -e820_setup_gap (); +e820__setup_pci_gap ();#ifdef CONFIG_VT #if defined(CONFIG_VGA_CONSOLE )
Signature · 1 line
2.7.4
PATCH 32/50 x86/boot/e820: Create coherent API function names for E820 range operations
In reply to Ingo MolnarWe have these three related functions:
extern void e820_add_region(u64 start, u64 size, int type);
extern u64 e820_update_range(u64 start, u64 size, unsigned old_type, unsigned new_type); extern u64 e820_remove_range(u64 start, u64 size, unsigned old_type, int checktype);
But it's not clear from the naming that they are 3 operations based around the same 'memory range' concept. Rename them to better signal this, and move the prototypes next to each other:
extern void e820__range_add (u64 start, u64 size, int type);
extern u64 e820__range_update(u64 start, u64 size, unsigned old_type, unsigned new_type); extern u64 e820__range_remove(u64 start, u64 size, unsigned old_type, int checktype);
Note that this improved organization of the functions shows another problem that was easy to miss before: sometimes the E820 entry type is 'int', sometimes 'unsigned int' - but this will be fixed in a separate patch.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 8 +++++--- arch/x86/kernel/acpi/boot.c | 2 +- arch/x86/kernel/aperture_64.c | 2 +- arch/x86/kernel/cpu/mtrr/cleanup.c | 2 +- arch/x86/kernel/e820.c | 48 ++++++++++++++++++++++++------------------------ arch/x86/kernel/early-quirks.c | 2 +- arch/x86/kernel/setup.c | 10 +++++----- arch/x86/lguest/boot.c | 2 +- arch/x86/platform/efi/efi.c | 2 +- arch/x86/xen/setup.c | 6 +++--- drivers/acpi/tables.c | 2 +- 11 files changed, 44 insertions(+), 42 deletions(-)
arch/x86/include/asm/e820/api.h +5 -3
@@ -10,11 +10,13 @@ extern unsigned long pci_mem_start;extern int e820__mapped_any (u64 start,u64 end,unsigned type);extern int e820__mapped_all (u64 start,u64 end,unsigned type); -extern void e820_add_region (u64 start,u64 size,int type); + +extern void e820__range_add (u64 start,u64 size,int type); +extern u64 e820__range_update (u64 start,u64 size,unsigned old_type,unsigned new_type); +extern u64 e820__range_remove (u64 start,u64 size,unsigned old_type,int checktype); +extern void e820_print_map (char *who);extern int e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map); -extern u64 e820_update_range (u64 start,u64 size,unsigned old_type,unsigned new_type); -extern u64 e820_remove_range (u64 start,u64 size,unsigned old_type,int checktype);extern void e820__update_table_print (void );extern void e820__setup_pci_gap (void );extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len);
arch/x86/kernel/acpi/boot.c +1 -1
@@ -1715,6 +1715,6 @@ int __acpi_release_global_lock(unsigned int *lock)void __init arch_reserve_mem_area (acpi_physical_address addr,size_t size) { -e820_add_region (addr, size,E820_ACPI ); +e820__range_add (addr, size,E820_ACPI );e820__update_table_print (); }
arch/x86/kernel/aperture_64.c +1 -1
@@ -311,7 +311,7 @@ void __init early_gart_iommu_check(void)/* reserve it, so we can reuse it in second kernel */ pr_info ("e820: reserve [mem %#010Lx-%#010Lx] for GART\n" , aper_base, aper_base + aper_size -1 ); -e820_add_region (aper_base, aper_size,E820_RESERVED ); +e820__range_add (aper_base, aper_size,E820_RESERVED );e820__update_table_print (); } }
arch/x86/kernel/cpu/mtrr/cleanup.c +1 -1
@@ -860,7 +860,7 @@ real_trim_memory(unsigned long start_pfn, unsigned long limit_pfn) trim_size <<=PAGE_SHIFT ; trim_size -= trim_start; -return e820_update_range (trim_start, trim_size,E820_RAM ,E820_RESERVED ); +return e820__range_update (trim_start, trim_size,E820_RAM ,E820_RESERVED ); }/**
arch/x86/kernel/e820.c +24 -24
141 lines not on this page · raw message
arch/x86/kernel/early-quirks.c +1 -1
@@ -546,7 +546,7 @@ intel_graphics_stolen(int num, int slot, int func, &base, &end);/* Mark this space as reserved */ -e820_add_region (base, size,E820_RESERVED ); +e820__range_add (base, size,E820_RESERVED );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }
arch/x86/kernel/setup.c +5 -5
@@ -731,14 +731,14 @@ static void __init trim_bios_range(void)* since some BIOSes are known to corrupt low memory. See the * Kconfig help text for X86_RESERVE_LOW. */ -e820_update_range (0 ,PAGE_SIZE ,E820_RAM ,E820_RESERVED ); +e820__range_update (0 ,PAGE_SIZE ,E820_RAM ,E820_RESERVED );/* * special case: Some BIOSen report the PC BIOS * area (640->1Mb) as ram even though it is not. * take them out. */ -e820_remove_range (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_RAM ,1 ); +e820__range_remove (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_RAM ,1 );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }
@@ -760,8 +760,8 @@ static void __init e820_add_kernel_range(void)return ;pr_warn (".text .data .bss are not marked as E820_RAM!\n" ); -e820_remove_range (start, size,E820_RAM ,0 ); -e820_add_region (start, size,E820_RAM ); +e820__range_remove (start, size,E820_RAM ,0 ); +e820__range_add (start, size,E820_RAM ); }static unsigned reserve_low =CONFIG_X86_RESERVE_LOW <<10 ;
@@ -1031,7 +1031,7 @@ void __init setup_arch(char **cmdline_p)trim_bios_range ();#ifdef CONFIG_X86_32 if (ppro_with_ram_bug ()) { -e820_update_range (0x70000000ULL ,0x40000ULL ,E820_RAM , +e820__range_update (0x70000000ULL ,0x40000ULL ,E820_RAM ,E820_RESERVED );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);printk (KERN_INFO "fixed physical RAM map:\n" );
arch/x86/lguest/boot.c +1 -1
@@ -1178,7 +1178,7 @@ static __init char *lguest_memory_setup(void)* The Linux bootloader header contains an "e820" memory map: the * Launcher populated the first entry with our memory limit. */ -e820_add_region (boot_params.e820_table[0 ].addr, +e820__range_add (boot_params.e820_table[0 ].addr, boot_params.e820_table[0 ].size, boot_params.e820_table[0 ].type);
arch/x86/platform/efi/efi.c +1 -1
@@ -165,7 +165,7 @@ static void __init do_add_efi_memmap(void) e820_type =E820_RESERVED ;break ; } -e820_add_region (start, size, e820_type); +e820__range_add (start, size, e820_type); }e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }
arch/x86/xen/setup.c +3 -3
@@ -596,7 +596,7 @@ static void __init xen_align_and_add_e820_region(phys_addr_t start, end &= ~((phys_addr_t )PAGE_SIZE -1 ); } -e820_add_region (start, end - start, type); +e820__range_add (start, end - start, type); }static void __init xen_ignore_unusable (void )
@@ -858,7 +858,7 @@ char * __init xen_memory_setup(void)* reserve ISA memory anyway because too many things poke * about in there. */ -e820_add_region (ISA_START_ADDRESS ,ISA_END_ADDRESS -ISA_START_ADDRESS , +e820__range_add (ISA_START_ADDRESS ,ISA_END_ADDRESS -ISA_START_ADDRESS ,E820_RESERVED );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);
@@ -936,7 +936,7 @@ char * __init xen_auto_xlated_memory_setup(void) &xen_e820_table_entries);for (i =0 ; i < xen_e820_table_entries; i++) -e820_add_region (xen_e820_table[i].addr, xen_e820_table[i].size, +e820__range_add (xen_e820_table[i].addr, xen_e820_table[i].size, xen_e820_table[i].type);/* Remove p2m info, it is not needed. */
drivers/acpi/tables.c +1 -1
@@ -556,7 +556,7 @@ void __init acpi_table_upgrade(void)* But it's not enough on X86 because ioremap will * complain later (used by acpi_os_map_memory) that the pages * that should get mapped are not marked "reserved". -* Both memblock_reserve and e820_add_region (via arch_reserve_mem_area) +* Both memblock_reserve and e820__range_add (via arch_reserve_mem_area) * works fine. */ memblock_reserve (acpi_tables_addr, all_tables_size);
Signature · 1 line
2.7.4
PATCH 33/50 x86/boot/e820: Rename e820_print_map() to e820__print_table()
In reply to Ingo MolnarAll other table-level methods are already named 'table' in some way, to change this one over to the (now consistent) nomenclature.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/e820.c | 12 ++++++------ arch/x86/kernel/setup.c | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -15,7 +15,7 @@ extern void e820__range_add (u64 start, u64 size, int type);extern u64 e820__range_update (u64 start,u64 size,unsigned old_type,unsigned new_type);extern u64 e820__range_remove (u64 start,u64 size,unsigned old_type,int checktype); -extern void e820_print_map (char *who); +extern void e820__print_table (char *who);extern int e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);extern void e820__update_table_print (void );extern void e820__setup_pci_gap (void );
arch/x86/kernel/e820.c +6 -6
@@ -160,7 +160,7 @@ static void __init e820_print_type(u32 type) } } -void __init e820_print_map (char *who) +void __init e820__print_table (char *who) {int i;
@@ -552,7 +552,7 @@ void __init e820__update_table_print(void)return ;pr_info ("e820: modified physical RAM map:\n" ); -e820_print_map ("modified" ); +e820__print_table ("modified" ); }static void __init e820__update_table_firmware (void )
@@ -680,7 +680,7 @@ void __init e820__memory_setup_extended(u64 phys_addr, u32 data_len)early_memunmap (sdata, data_len);pr_info ("e820: extended physical RAM map:\n" ); -e820_print_map ("extended" ); +e820__print_table ("extended" ); }/**
@@ -934,7 +934,7 @@ void __init e820_reserve_setup_data(void)e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table ));printk (KERN_INFO "extended physical RAM map:\n" ); -e820_print_map ("reserve setup_data" ); +e820__print_table ("reserve setup_data" ); }/*
@@ -949,7 +949,7 @@ void __init e820__finish_early_params(void)early_panic ("Invalid user supplied memory map" );pr_info ("e820: user-defined physical RAM map:\n" ); -e820_print_map ("user" ); +e820__print_table ("user" ); } }
@@ -1167,7 +1167,7 @@ void __init e820__memory_setup(void)memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table ));pr_info ("e820: BIOS-provided physical RAM map:\n" ); -e820_print_map (who); +e820__print_table (who); }void __init e820__memblock_setup (void )
arch/x86/kernel/setup.c +1 -1
@@ -1035,7 +1035,7 @@ void __init setup_arch(char **cmdline_p) E820_RESERVED);e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);printk (KERN_INFO "fixed physical RAM map:\n" ); - e820_print_map("bad_ppro"); + e820__print_table("bad_ppro"); }#else early_gart_iommu_check ();
Signature · 1 line
2.7.4
PATCH 34/50 x86/boot/e820: Reorder the function prototypes in api.h
In reply to Ingo MolnarReorder the function prototypes in api.h a bit, to group related functions together.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
arch/x86/include/asm/e820/api.h +7 -2
@@ -18,18 +18,23 @@ extern u64 e820__range_remove(u64 start, u64 size, unsigned old_type, int checkextern void e820__print_table (char *who);extern int e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);extern void e820__update_table_print (void ); -extern void e820__setup_pci_gap (void ); -extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len); +extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void ); +extern u64 e820__memblock_alloc_reserved (u64 sizet,u64 align);extern void e820__memblock_setup (void ); +extern void e820_reserve_setup_data (void );extern void e820__finish_early_params (void );extern void e820_reserve_resources (void );extern void e820_reserve_resources_late (void ); +extern void e820__memory_setup (void ); +extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len);extern char *e820__memory_setup_default (void ); +extern void e820__setup_pci_gap (void ); +extern void e820_reallocate_tables (void );extern void e820_mark_nosave_regions (unsigned long limit_pfn);
Signature · 1 line
2.7.4
PATCH 35/50 x86/boot/e820: Simplify e820_reserve_resources()
In reply to Ingo MolnarRemove unnecessary duplications of "e820_table->entries[i]." via a local variable, plus pass in 'entry' to the type_to_*() functions which further improves the readability of the code - and other small tweaks.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/kernel/e820.c | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-)
arch/x86/kernel/e820.c +19 -17
@@ -953,9 +953,9 @@ void __init e820__finish_early_params(void) } } -static const char *__init e820_type_to_string (int e820_type) +static const char *__init e820_type_to_string (struct e820_entry *entry) { -switch (e820_type) { +switch (entry->type) {case E820_RESERVED_KERN :/* Fall-through: */ case E820_RAM :return "System RAM" ;case E820_ACPI :return "ACPI Tables" ;
@@ -967,9 +967,9 @@ static const char *__init e820_type_to_string(int e820_type) } } -static unsigned long __init e820_type_to_iomem_type (int e820_type) +static unsigned long __init e820_type_to_iomem_type (struct e820_entry *entry) { -switch (e820_type) { +switch (entry->type) {case E820_RESERVED_KERN :/* Fall-through: */ case E820_RAM :return IORESOURCE_SYSTEM_RAM ;case E820_ACPI :/* Fall-through: */
@@ -981,9 +981,9 @@ static unsigned long __init e820_type_to_iomem_type(int e820_type) } } -static unsigned long __init e820_type_to_iores_desc (int e820_type) +static unsigned long __init e820_type_to_iores_desc (struct e820_entry *entry) { -switch (e820_type) { +switch (entry->type) {case E820_ACPI :return IORES_DESC_ACPI_TABLES ;case E820_NVS :return IORES_DESC_ACPI_NV_STORAGE ;case E820_PMEM :return IORES_DESC_PERSISTENT_MEMORY ;
@@ -1027,27 +1027,29 @@ void __init e820_reserve_resources(void)struct resource *res;u64 end; - res =alloc_bootmem (sizeof (struct resource ) * e820_table->nr_entries); + res =alloc_bootmem (sizeof (*res) * e820_table->nr_entries); e820_res = res; +for (i =0 ; i < e820_table->nr_entries; i++) { - end = e820_table->entries[i].addr + e820_table->entries[i].size -1 ; +struct e820_entry *entry = e820_table->entries + i; + + end = entry->addr + entry->size -1 ;if (end != (resource_size_t )end) { res++;continue ; } - res->name =e820_type_to_string (e820_table->entries[i].type); - res->start = e820_table->entries[i].addr; - res->end = end; - - res->flags =e820_type_to_iomem_type (e820_table->entries[i].type); - res->desc =e820_type_to_iores_desc (e820_table->entries[i].type); + res->start = entry->addr; + res->end = end; + res->name =e820_type_to_string (entry); + res->flags =e820_type_to_iomem_type (entry); + res->desc =e820_type_to_iores_desc (entry);/* * don't register the region that could be conflicted with * pci device BAR resource and insert them later in * pcibios_resource_survey() */ -if (do_mark_busy (e820_table->entries[i].type, res)) { +if (do_mark_busy (entry->type, res)) { res->flags |=IORESOURCE_BUSY ;insert_resource (&iomem_resource, res); }
@@ -1055,9 +1057,9 @@ void __init e820_reserve_resources(void) }for (i =0 ; i < e820_table_firmware->nr_entries; i++) { -struct e820_entry *entry = &e820_table_firmware->entries[i]; +struct e820_entry *entry = e820_table_firmware->entries + i; -firmware_map_add_early (entry->addr, entry->addr + entry->size,e820_type_to_string (entry->type)); +firmware_map_add_early (entry->addr, entry->addr + entry->size,e820_type_to_string (entry)); } }
Signature · 1 line
2.7.4
PATCH 36/50 x86/boot/e820: Introduce 'enum e820_type'
In reply to Ingo MolnarUse an enum instead of CPP #define.
Also fix various small annoyances in the descriptions of the various E820 types.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/types.h | 57 +++++++++++++++++++++++++++++++-------------------------- 1 file changed, 31 insertions(+), 26 deletions(-)
arch/x86/include/asm/e820/types.h +31 -26
@@ -1,6 +1,37 @@#ifndef _ASM_E820_TYPES_H#define _ASM_E820_TYPES_H +enum e820_type { +E820_RAM =1 , +E820_RESERVED =2 , +E820_ACPI =3 , +E820_NVS =4 , +E820_UNUSABLE =5 , +E820_PMEM =7 , + +/* +* This is a non-standardized way to represent ADR or +* NVDIMM regions that persist over a reboot. +* +* The kernel will ignore their special capabilities +* unless the CONFIG_X86_PMEM_LEGACY=y option is set. +* +* ( Note that older platforms also used 6 for the same +* type of memory, but newer versions switched to 12 as +* 6 was assigned differently. Some time they will learn... ) +*/ +E820_PRAM =12 , + +/* +* Reserved RAM used by the kernel itself if +* CONFIG_INTEL_TXT=y is enabled, memory of this type +* will be included in the S3 integrity calculation +* and so should not include any memory that the BIOS +* might alter over the S3 transition: +*/ +E820_RESERVED_KERN =128 , +}; +#include <uapi/asm/e820/types.h> /*
@@ -39,32 +70,6 @@/* Number of entries in E820MAP: */ #define E820NR 0x1e8 -#define E820_RAM 1 -#define E820_RESERVED 2 -#define E820_ACPI 3 -#define E820_NVS 4 -#define E820_UNUSABLE 5 -#define E820_PMEM 7 - -/* -* This is a non-standardized way to represent ADR or NVDIMM regions that -* persist over a reboot. The kernel will ignore their special capabilities -* unless the CONFIG_X86_PMEM_LEGACY option is set. -* -* ( Note that older platforms also used 6 for the same type of memory, -* but newer versions switched to 12 as 6 was assigned differently. Some -* time they will learn... ) -*/ -#define E820_PRAM 12 - -/* -* reserved RAM used by kernel itself -* if CONFIG_INTEL_TXT is enabled, memory of this type will be -* included in the S3 integrity calculation and so should not include -* any memory that BIOS might alter over the S3 transition -*/ -#define E820_RESERVED_KERN 128 -/* * The whole array of E820 entries: */
Signature · 1 line
2.7.4
PATCH 37/50 x86/boot/e820: Use 'enum e820_type' in 'struct e820_entry'
In reply to Ingo MolnarUse a stricter type for struct e820_entry. Add a build-time check to make sure the compiler won't ever pack the enum into a field smaller than 'int'.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/types.h | 31 ------------------------------- arch/x86/include/uapi/asm/e820/types.h | 37 ++++++++++++++++++++++++++++++++++--- arch/x86/kernel/e820.c | 3 +++ 3 files changed, 37 insertions(+), 34 deletions(-)
arch/x86/include/asm/e820/types.h +0 -31
@@ -1,37 +1,6 @@#ifndef _ASM_E820_TYPES_H#define _ASM_E820_TYPES_H -enum e820_type { -E820_RAM =1 , -E820_RESERVED =2 , -E820_ACPI =3 , -E820_NVS =4 , -E820_UNUSABLE =5 , -E820_PMEM =7 , - -/* -* This is a non-standardized way to represent ADR or -* NVDIMM regions that persist over a reboot. -* -* The kernel will ignore their special capabilities -* unless the CONFIG_X86_PMEM_LEGACY=y option is set. -* -* ( Note that older platforms also used 6 for the same -* type of memory, but newer versions switched to 12 as -* 6 was assigned differently. Some time they will learn... ) -*/ -E820_PRAM =12 , - -/* -* Reserved RAM used by the kernel itself if -* CONFIG_INTEL_TXT=y is enabled, memory of this type -* will be included in the S3 integrity calculation -* and so should not include any memory that the BIOS -* might alter over the S3 transition: -*/ -E820_RESERVED_KERN =128 , -}; -#include <uapi/asm/e820/types.h> /*
arch/x86/include/uapi/asm/e820/types.h +34 -3
@@ -6,14 +6,45 @@#ifndef __ASSEMBLY__ +enum e820_type { +E820_RAM =1 , +E820_RESERVED =2 , +E820_ACPI =3 , +E820_NVS =4 , +E820_UNUSABLE =5 , +E820_PMEM =7 , + +/* +* This is a non-standardized way to represent ADR or +* NVDIMM regions that persist over a reboot. +* +* The kernel will ignore their special capabilities +* unless the CONFIG_X86_PMEM_LEGACY=y option is set. +* +* ( Note that older platforms also used 6 for the same +* type of memory, but newer versions switched to 12 as +* 6 was assigned differently. Some time they will learn... ) +*/ +E820_PRAM =12 , + +/* +* Reserved RAM used by the kernel itself if +* CONFIG_INTEL_TXT=y is enabled, memory of this type +* will be included in the S3 integrity calculation +* and so should not include any memory that the BIOS +* might alter over the S3 transition: +*/ +E820_RESERVED_KERN =128 , +}; +/* * A single E820 map entry, describing a memory range of [addr...addr+size-1], * of 'type' memory type: */ struct e820_entry { -__u64 addr; -__u64 size; -__u32 type; +__u64 addr; +__u64 size; +enum e820_type type; } __attribute__((packed));#endif /* __ASSEMBLY__ */
arch/x86/kernel/e820.c +3 -0
@@ -1164,6 +1164,9 @@ void __init e820__memory_setup(void) {char *who; +/* This is a firmware interface ABI - make sure we don't break it: */ +BUILD_BUG_ON (sizeof (struct e820_entry ) !=20 ); + who = x86_init.resources.memory_setup ();memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table ));
Signature · 1 line
2.7.4
Re: [PATCH 37/50] x86/boot/e820: Use 'enum e820_type' in 'struct e820_entry'
Quoted 3 lines · Ingo Molnar
Use a stricter type for struct
e820_entry. Add a build-time check to make sure the compiler won't ever pack the enum into a field smaller than 'int'.
I'm not sure this is a good idea. In fact, I'm pretty sure it's a horrible idea.
The compiler that *users* use might decide that the "enum" fits in a 8-bit unsigned char, and decide to use that. The kernel build won't notice and the BUG_ON() won't help, because we use a different compiler.
(Or even if it's the same compiler you can have build flags - the size of an enum very much depends on various compiler options, particularly "--short-enums" for gcc).
Basically, we should not use "enum"s in types exported to user space. The size just isn't sufficiently well defined, and it's a maintenance nightmare.
Use explicitly sized members only, please. No "enum".
Linus
Re: [PATCH 37/50] x86/boot/e820: Use 'enum e820_type' in 'struct e820_entry'
Quoted 11 lines · Linus Torvalds
Quoted 3 lines · Ingo Molnar
Use a stricter type for struct
e820_entry. Add a build-time check to make sure the compiler won't ever pack the enum into a field smaller than 'int'.I'm not sure this is a good idea. In fact, I'm pretty sure it's a horrible idea.
The compiler that *users* use might decide that the "enum" fits in a 8-bit unsigned char, and decide to use that. The kernel build won't notice and the
BUG_ON()won't help, because we use a different compiler.
Hm, good point, have not considered that.
Quoted 9 lines
(Or even if it's the same compiler you can have build flags - the size of an enum very much depends on various compiler options, particularly "--short-enums" for gcc).
Basically, we should not use "enum"s in types exported to user space. The size just isn't sufficiently well defined, and it's a maintenance nightmare.
Use explicitly sized members only, please. No "enum".
Ok.
Would it be acceptable to use enum for the kernel internal representation (our e820_table structures never actually comes directly, we construct it ourselves), and maintain the very explicitly sized ABI type for the boot protocol only (i.e. uapi/asm/bootparam.h)?
( I actually partially implemented that originally, but chickened out after
running into header dependency hell - but I think it could be tackled with a bit more effort. )
The vagueness of the C spec about enum size and the resulting enum auto-packing efforts of compilers is annoying and a real problem for ABIs, but the reason I'm pushing them in this case is that enums also have some advantages within the kernel:
1) they are pretty good self-documenting types
2) GCC at least has some useful enum warnings for switch() statements, one of which we use in the kernel today:
-Wswitch
Warn whenever a "switch" statement has an index of enumerated type and lacks a "case" for one or more of the named codes of that enumeration. (The presence of a "default" label prevents this warning.) "case" labels outside the enumeration range also provoke warnings when this option is used (even if there is a "default" label).
This warning is enabled by -Wall.
There are also more intrusive warnings which found/prevented quite a few bugs in various user-space efforts I've been involved with (such as tools/perf):
-Wswitch-default
Warn whenever a "switch" statement does not have a "default" case.
-Wswitch-enum
Warn whenever a "switch" statement has an index of enumerated type and lacks a "case" for one or more of the named codes of that enumeration. "case" labels outside the enumeration range also provoke warnings when this option is used. The only difference between -Wswitch and this option is that this option gives a warning about an omitted enumeration code even if there is a "default" label.
So if say one of the e820 functions didn't handle E820_TYPE_PMEM, we'd today generate this warning in the kernel build:
arch/x86/kernel/e820.c: In function ‘e820_print_type’:
arch/x86/kernel/e820.c:143:2: warning: enumeration value ‘E820_TYPE_PMEM’ not handled in switch [-Wswitch]
switch (type) {
^ arch/x86/kernel/e820.c:143:2: warning: enumeration value ‘E820_TYPE_PRAM’ not handled in switch [-Wswitch]
And in fact, we could go further than that - the kernel does not enable -Wswitch-enum right now (because there are valid patterns that it warns about, such as enums with extensive list of values where listing all the values would make thecode worse), but when enabled for e820.c it generates this warning:
arch/x86/kernel/e820.c: In function ‘e820_type_to_string’:
arch/x86/kernel/e820.c:965:2: warning: enumeration value ‘E820_TYPE_RESERVED’ not handled in switch [-Wswitch-enum]
switch (entry->type) {
^ arch/x86/kernel/e820.c: In function ‘e820_type_to_iomem_type’:
arch/x86/kernel/e820.c:979:2: warning: enumeration value ‘E820_TYPE_RESERVED’ not handled in switch [-Wswitch-enum]
switch (entry->type) {
^ arch/x86/kernel/e820.c: In function ‘e820_type_to_iores_desc’:
arch/x86/kernel/e820.c:993:2: warning: enumeration value ‘E820_TYPE_RESERVED’ not handled in switch [-Wswitch-enum]
switch (entry->type) {
^ arch/x86/kernel/e820.c: In function ‘do_mark_busy’:
arch/x86/kernel/e820.c:1015:2: warning: enumeration value ‘E820_TYPE_RAM’ not handled in switch [-Wswitch-enum]
switch (type) {
^All four warnings are interesting IMHO:
The one in e820_type_to_string() should be fixed this way I think:
arch/x86/kernel/e820.c +2 -1
@@ -970,7 +970,8 @@ static const char *__init e820_type_to_string(struct e820_entry *entry)case E820_TYPE_UNUSABLE :return "Unusable memory" ;case E820_TYPE_PRAM :return "Persistent Memory (legacy)" ;case E820_TYPE_PMEM :return "Persistent Memory" ; -default :return "Reserved" ; +case E820_TYPE_RESERVED :return "Reserved" ; +default :return "Unknown E820 type" ; } }
As it's useful to have differentiation in output between a known-reserved E820 range and a totally unknown type range (firmware special or new feature).
The ones in e820_type_to_iomem_type() and e820_type_to_iores_desc() look OK but interesting nevertheless, and should probably be fixed this way:
arch/x86/kernel/e820.c +2 -0
@@ -984,6 +985,7 @@ static unsigned long __init e820_type_to_iomem_type(struct e820_entry *entry)case E820_TYPE_UNUSABLE :/* Fall-through: */ case E820_TYPE_PRAM :/* Fall-through: */ case E820_TYPE_PMEM :/* Fall-through: */ +case E820_TYPE_RESERVED :/* Fall-through: */ default :return IORESOURCE_MEM ; } }
@@ -998,6 +1000,7 @@ static unsigned long __init e820_type_to_iores_desc(struct e820_entry *entry)case E820_TYPE_RESERVED_KERN :/* Fall-through: */ case E820_TYPE_RAM :/* Fall-through: */ case E820_TYPE_UNUSABLE :/* Fall-through: */ +case E820_TYPE_RESERVED :/* Fall-through: */ default :return IORES_DESC_NONE ; } }
I think it's worth a mention that E820_TYPE_RESERVED is handled differently from E820_TYPE_RESERVED_KERN in these two functions: the reason is that E820_TYPE_RESERVED_KERN is really a special RAM area and probably somewhat of a misnomer - E820_TYPE_RAM_RESERVED might be better.
The one in do_mark_busy() is IMHO interesting as well:
arch/x86/kernel/e820.c +6 -1
@@ -998,7 +1000,7 @@ static unsigned long __init e820_type_to_iores_desc(struct e820_entry *entry) } } -static bool __init do_mark_busy (u32 type,struct resource *res) +static bool __init do_mark_busy (enum e820_type type,struct resource *res) {/* this is the legacy bios/dos rom-shadow + mmio region */ if (res->start < (1ULL <<20 ))
@@ -1017,6 +1020,11 @@ static bool __init do_mark_busy(u32 type, struct resource *res)case E820_TYPE_PRAM :case E820_TYPE_PMEM :return false; +case E820_TYPE_RESERVED_KERN : +case E820_TYPE_RAM : +case E820_TYPE_ACPI : +case E820_TYPE_NVS : +case E820_TYPE_UNUSABLE :default :return true; }
(this patch keeps/documents the status quo.)
As it raises the question of why E820_TYPE_RESERVED is handled differently from E820_TYPE_ACPI and E820_TYPE_NVS. Shouldn't E820_TYPE_RESERVED be marked busy as well, or do sometimes PCI devices hide there? Even if the code is correct this would merit a line of documentation as well, IMHO.
( There's also the -Wswitch-default warning which is not enabled by the kernel
build, and which even if enabled does not trigger for e820.o but it's useful as well. )
I.e. I think enum e820_type is a case where very explicit listing of all the values in switch() statements actively improves the code, almost unconditionally:
it resulted in a fix, three improvements in code quality and a couple of questions that might result in improved comments.
None of this is possible in such an active way with CPP #defines.
So if you think isolating the enum from the ABI interface would be an acceptable solution to the problem we could still use the enum - eat and have the cake and such?
Thanks,
Ingo
PATCH 1/1 x86/boot/e820: Separate the E820 ABI structures from the in-kernel structures
Quoted 6 lines · Ingo Molnar
Quoted 1 line
Use explicitly sized members only, please. No "enum".
Ok.
Would it be acceptable to use enum for the kernel internal representation (our
e820_tablestructures never actually comes directly, we construct it ourselves),
^-- from the firmware
Quoted 2 lines
and maintain the very explicitly sized ABI type for the boot protocol only (i.e.
uapi/asm/bootparam.h)?
I.e. my proposed solution would be to decouple struct e820_table (and thus struct e820_entry) by making them kernel internal and thus decoupling them from the boot protocol (struct boot_params) - and not expose the enum to UAPI at all, only the raw __u32/__u64 fields of the boot protocol.
We already have some pain in the code from the fact that the e820 table of the boot protocol is not actually the same as e820_table: table->nr_entries is at a different offset in struct boot_params.h. So struct e820_table is already a de facto artificial in-kernel construct and has been for a decade or so.
I.e. something like the patch below. (Lightly boot tested on a couple of systems.)
This actually makes things simpler and cleaner all around:
- Now boot_params is not modified anymore (previous we'd call e820__update_table() on the boot parameters structure itself!).
- The ugly low level __e820__update_table() is not used anymore (because all e820_table structures now have a standard layout) and can be eliminated in a future patch.
- Grepping for boot_e820_entry will now actually show all the very low level E820 code that directly interfaces with the BIOS or the bootloader. This is a plus.
- 'struct e820_entry' is now independent of the boot ABI. I boot tested the following experimental change:
|
| --- a/arch/x86/include/asm/e820/types.h
| +++ b/arch/x86/include/asm/e820/types.h
| @@ -44,10 +44,10 @@ enum e820_type {
| * (We pack it because there can be thousands of them on large systems.)
| */
| struct e820_entry {
| + enum e820_type type;
| u64 addr;
| u64 size;
| - enum e820_type type;
| -} __attribute__((packed));
| +};
|
| /*
| * The legacy E820 BIOS limits us to 128 (E820_MAX_ENTRIES_ZEROPAGE) nodes
| ... which changes both the layout and the size of e820_entry on 64-bit systems, and successfully boot-tested it - which is proof that the types are decoupled in practice as well.
I don't actually think we want to change the ordering and size right now, as distro kernels can have thousands of these entries and their memory efficiency matters, but it's nice to know that the decoupling appears to be complete. Maybe some future firmware interface requires a new field, which would now be possible.
- And of course this patch should also fix the problem you pointed out, the fragility of enum sizes in ABI data structures.
So ... would this be an acceptable approach? (Assuming it works on all systems, etc.)
Thanks,
Ingo
==================>
Quoted 1 line
From
c88a9c7e933dd665a47591ebd049a5046c7871c5Mon Sep 17 00:00:00 2001
From: Ingo Molnar <[email protected]>
Date: Sun, 29 Jan 2017 12:56:13 +0100
Subject: [PATCH] x86/boot/e820: Separate the E820 ABI structures from the in-kernel structures
Linus pointed out that relying on the compiler to pack structures with enums is fragile not just for the kernel, but for external tooling as well which might rely on our UAPI headers.
So separate the two from each other: introduce 'struct boot_e820_entry', which is the boot protocol entry format.
This actually simplifies the code, as e820__update_table() is now never called directly with boot protocol table entries - we can rely on append_e820_table() and do a e820__update_table() call afterwards.
( This will allow further simplifications of __e820__update_table(),
but that will be done in a separate patch. )
This change also has the side effect of not modifying the bootparams structure anymore - which might be useful for debugging. In theory we could even constify the boot_params structure - at least from the E820 code's point of view.
Remove the uapi/asm/e820/types.h file, as it's not used anymore - all kernel side E820 types are defined in asm/e820/types.h.
Reported-by Linus Torvalds <[email protected]>
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/boot/compressed/eboot.c | 16 +++++----- arch/x86/boot/compressed/kaslr.c | 2 +- arch/x86/boot/memory.c | 4 +-- arch/x86/include/asm/e820/types.h | 48 ++++++++++++++++++++++++++++- arch/x86/include/uapi/asm/bootparam.h | 18 +++++++++-- arch/x86/include/uapi/asm/e820/types.h | 55 ---------------------------------- arch/x86/kernel/e820.c | 20 ++++++------- 7 files changed, 83 insertions(+), 80 deletions(-)
arch/x86/boot/compressed/eboot.c +8 -8
@@ -900,7 +900,7 @@ static void add_e820ext(struct boot_params *params,unsigned long size; e820ext->type =SETUP_E820_EXT ; - e820ext->len = nr_entries *sizeof (struct e820_entry ); + e820ext->len = nr_entries *sizeof (struct boot_e820_entry ); e820ext->next =0 ; data = (struct setup_data *)(unsigned long )params->hdr.setup_data;
@@ -917,9 +917,9 @@ static void add_e820ext(struct boot_params *params,static efi_status_t setup_e820 (struct boot_params *params,struct setup_data *e820ext,u32 e820ext_size) { -struct e820_entry *e820_table = ¶ms->e820_table[0 ]; +struct boot_e820_entry *entry = params->e820_table;struct efi_info *efi = ¶ms->efi_info; -struct e820_entry *prev =NULL ; +struct boot_e820_entry *prev =NULL ;u32 nr_entries;u32 nr_desc;int i;
@@ -990,13 +990,13 @@ static efi_status_t setup_e820(struct boot_params *params,return EFI_BUFFER_TOO_SMALL ;/* boot_params map full, switch to e820 extended */ - e820_table = (struct e820_entry *)e820ext->data; + entry = (struct boot_e820_entry *)e820ext->data; } - e820_table->addr = d->phys_addr; - e820_table->size = d->num_pages <<PAGE_SHIFT ; - e820_table->type = e820_type; - prev = e820_table++; + entry->addr = d->phys_addr; + entry->size = d->num_pages <<PAGE_SHIFT ; + entry->type = e820_type; + prev = entry++; nr_entries++; }
arch/x86/boot/compressed/kaslr.c +1 -1
@@ -426,7 +426,7 @@ static unsigned long slots_fetch_random(void)return 0 ; } -static void process_e820_entry (struct e820_entry *entry, +static void process_e820_entry (struct boot_e820_entry *entry,unsigned long minimum,unsigned long image_size) {
arch/x86/boot/memory.c +2 -2
@@ -21,8 +21,8 @@ static int detect_memory_e820(void) {int count =0 ;struct biosregs ireg, oreg; -struct e820_entry *desc = boot_params.e820_table; -static struct e820_entry buf;/* static so it is zeroed */ +struct boot_e820_entry *desc = boot_params.e820_table; +static struct boot_e820_entry buf;/* static so it is zeroed */ initregs (&ireg); ireg.ax =0xe820 ;
arch/x86/include/asm/e820/types.h +47 -1
54 lines not on this page · raw message
arch/x86/include/uapi/asm/bootparam.h +16 -2
@@ -34,7 +34,6 @@#include <linux/screen_info.h> #include <linux/apm_bios.h> #include <linux/edd.h> -#include <uapi/asm/e820/types.h> #include <asm/ist.h> #include <video/edid.h>
@@ -111,6 +110,21 @@ struct efi_info {__u32 efi_memmap_hi; }; +/* +* This is the maximum number of entries in struct boot_params::e820_table +* (the zeropage), which is part of the x86 boot protocol ABI: +*/ +#define E820_MAX_ENTRIES_ZEROPAGE 128 + +/* +* The E820 memory region entry of the boot protocol ABI: +*/ +struct boot_e820_entry { +__u64 addr; +__u64 size; +__u32 type; +} __attribute__((packed)); +/* The so-called "zeropage" */ struct boot_params {struct screen_info screen_info;/* 0x000 */
@@ -152,7 +166,7 @@ struct boot_params {struct setup_header hdr;/* setup header */ /* 0x1f1 */ __u8 _pad7[0x290 -0x1f1 -sizeof (struct setup_header )];__u32 edd_mbr_sig_buffer[EDD_MBR_SIG_MAX ];/* 0x290 */ -struct e820_entry e820_table[E820_MAX_ENTRIES_ZEROPAGE ];/* 0x2d0 */ +struct boot_e820_entry e820_table[E820_MAX_ENTRIES_ZEROPAGE ];/* 0x2d0 */ __u8 _pad8[48 ];/* 0xcd0 */ struct edd_info eddbuf[EDDMAXNR ];/* 0xd00 */ __u8 _pad9[276 ];/* 0xeec */
arch/x86/include/uapi/asm/e820/types.h deleted +0 -55
55 lines not on this page · raw message
arch/x86/kernel/e820.c +9 -11
@@ -366,9 +366,9 @@ int __init e820__update_table(struct e820_table *table)return __e820__update_table (table->entries,ARRAY_SIZE (table->entries), &table->nr_entries); } -static int __init __append_e820_table (struct e820_entry *entries,u32 nr_entries) +static int __init __append_e820_table (struct boot_e820_entry *entries,u32 nr_entries) { -struct e820_entry *entry = entries; +struct boot_e820_entry *entry = entries;while (nr_entries) {u64 start = entry->addr;
@@ -397,7 +397,7 @@ static int __init __append_e820_table(struct e820_entry *entries, u32 nr_entries* will have given us a memory map that we can use to properly * set up memory. If we aren't, we'll fake a memory map. */ -static int __init append_e820_table (struct e820_entry *entries,u32 nr_entries) +static int __init append_e820_table (struct boot_e820_entry *entries,u32 nr_entries) {/* Only one memory region (or negative)? Ignore it */ if (nr_entries <2 )
@@ -668,12 +668,12 @@ __init void e820__reallocate_tables(void)void __init e820__memory_setup_extended (u64 phys_addr,u32 data_len) {int entries; -struct e820_entry *extmap; +struct boot_e820_entry *extmap;struct setup_data *sdata; sdata =early_memremap (phys_addr, data_len); entries = sdata->len /sizeof (*extmap); - extmap = (struct e820_entry *)(sdata->data); + extmap = (struct boot_e820_entry *)(sdata->data);__append_e820_table (extmap, entries);e820__update_table (e820_table);
@@ -1140,7 +1140,6 @@ void __init e820__reserve_resources_late(void)char *__init e820__memory_setup_default (void ) {char *who ="BIOS-e820" ; -u32 new_nr;/* * Try to copy the BIOS-supplied E820-map.
@@ -1148,10 +1147,6 @@ char *__init e820__memory_setup_default(void)* Otherwise fake a memory map; one section from 0k->640k, * the next section from 1mb->appropriate_mem_k */ - new_nr = boot_params.e820_entries; -__e820__update_table (boot_params.e820_table,ARRAY_SIZE (boot_params.e820_table), &new_nr); - boot_params.e820_entries = new_nr; -if (append_e820_table (boot_params.e820_table, boot_params.e820_entries) <0 ) {u64 mem_size;
@@ -1169,6 +1164,9 @@ char *__init e820__memory_setup_default(void)e820__range_add (HIGH_MEMORY , mem_size <<10 ,E820_TYPE_RAM ); } +/* We just appended a lot of ranges, sanitize the table: */ +e820__update_table (e820_table); +return who; }
@@ -1182,7 +1180,7 @@ void __init e820__memory_setup(void)char *who;/* This is a firmware interface ABI - make sure we don't break it: */ -BUILD_BUG_ON (sizeof (struct e820_entry ) !=20 ); +BUILD_BUG_ON (sizeof (struct boot_e820_entry ) !=20 ); who = x86_init.resources.memory_setup ();
Re: [PATCH 37/50] x86/boot/e820: Use 'enum e820_type' in 'struct e820_entry'
In reply to Ingo MolnarQuoted 5 lines · Ingo Molnar
Would it be acceptable to use enum for the kernel internal representation (our
e820_tablestructures never actually comes directly, we construct it ourselves), and maintain the very explicitly sized ABI type for the boot protocol only (i.e.uapi/asm/bootparam.h)?
I guess that would work, assuming that it doesn't cause unnecessary conversions.
Looking at the patch you sent out (assuming that's the complete deal), it looks reasonable.
Linus
PATCH 38/50 x86/boot/e820: Use 'enum e820_type' when handling the e820 region type
In reply to Ingo MolnarThe E820 region type is put into four different types (!) when used in function parameters or local variables:
unsigned type; int type; unsigned long current_type; u32 type;
Use 'enum e820_type' in all these cases instead.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 10 +++++----- arch/x86/kernel/e820.c | 22 +++++++++++----------- 2 files changed, 16 insertions(+), 16 deletions(-)
arch/x86/include/asm/e820/api.h +5 -5
@@ -8,12 +8,12 @@ extern struct e820_table *e820_table_firmware;extern unsigned long pci_mem_start; -extern int e820__mapped_any (u64 start,u64 end,unsigned type); -extern int e820__mapped_all (u64 start,u64 end,unsigned type); +extern int e820__mapped_any (u64 start,u64 end,enum e820_type type); +extern int e820__mapped_all (u64 start,u64 end,enum e820_type type); -extern void e820__range_add (u64 start,u64 size,int type); -extern u64 e820__range_update (u64 start,u64 size,unsigned old_type,unsigned new_type); -extern u64 e820__range_remove (u64 start,u64 size,unsigned old_type,int checktype); +extern void e820__range_add (u64 start,u64 size,enum e820_type type); +extern u64 e820__range_update (u64 start,u64 size,enum e820_type old_type,enum e820_type new_type); +extern u64 e820__range_remove (u64 start,u64 size,enum e820_type old_type,int checktype);extern void e820__print_table (char *who);extern int e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map);
arch/x86/kernel/e820.c +11 -11
@@ -68,7 +68,7 @@ EXPORT_SYMBOL(pci_mem_start);* This function checks if any part of the range <start,end> is mapped * with type. */ -int e820__mapped_any (u64 start,u64 end,unsigned type) +int e820__mapped_any (u64 start,u64 end,enum e820_type type) {int i;
@@ -91,7 +91,7 @@ EXPORT_SYMBOL_GPL(e820__mapped_any);* Note: this function only works correctly once the E820 table is sorted and * not-overlapping (at least for the range specified), which is the case normally. */ -int __init e820__mapped_all (u64 start,u64 end,unsigned type) +int __init e820__mapped_all (u64 start,u64 end,enum e820_type type) {int i;
@@ -125,7 +125,7 @@ int __init e820__mapped_all(u64 start, u64 end, unsigned type)/* * Add a memory region to the kernel E820 map. */ -static void __init __e820__range_add (struct e820_table *table,u64 start,u64 size,int type) +static void __init __e820__range_add (struct e820_table *table,u64 start,u64 size,enum e820_type type) {int x = table->nr_entries;
@@ -140,12 +140,12 @@ static void __init __e820__range_add(struct e820_table *table, u64 start, u64 si table->nr_entries++; } -void __init e820__range_add (u64 start,u64 size,int type) +void __init e820__range_add (u64 start,u64 size,enum e820_type type) {__e820__range_add (e820_table, start, size, type); } -static void __init e820_print_type (u32 type) +static void __init e820_print_type (enum e820_type type) {switch (type) {case E820_RAM :/* Fall through: */
@@ -265,7 +265,7 @@ int __init e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *pstatic struct change_member *change_point[2 *E820_X_MAX ]__initdata ;static struct e820_entry *overlap_list[E820_X_MAX ]__initdata ;static struct e820_entry new_bios[E820_X_MAX ]__initdata ; -unsigned long current_type, last_type; +enum e820_type current_type, last_type;unsigned long long last_addr;int chgidx;int overlap_entries;
@@ -407,7 +407,7 @@ static int __init append_e820_table(struct e820_entry *biosmap, int nr_map) }static u64 __init -__e820__range_update (struct e820_table *table,u64 start,u64 size,unsigned old_type,unsigned new_type) +__e820__range_update (struct e820_table *table,u64 start,u64 size,enum e820_type old_type,enum e820_type new_type) {u64 end;unsigned int i;
@@ -474,18 +474,18 @@ __e820__range_update(struct e820_table *table, u64 start, u64 size, unsigned oldreturn real_updated_size; } -u64 __init e820__range_update (u64 start,u64 size,unsigned old_type,unsigned new_type) +u64 __init e820__range_update (u64 start,u64 size,enum e820_type old_type,enum e820_type new_type) {return __e820__range_update (e820_table, start, size, old_type, new_type); } -static u64 __init e820__range_update_firmware (u64 start,u64 size,unsigned old_type,unsigned new_type) +static u64 __init e820__range_update_firmware (u64 start,u64 size,enum e820_type old_type,enum e820_type new_type) {return __e820__range_update (e820_table_firmware, start, size, old_type, new_type); }/* Remove a range of memory from the E820 table: */ -u64 __init e820__range_remove (u64 start,u64 size,unsigned old_type,int checktype) +u64 __init e820__range_remove (u64 start,u64 size,enum e820_type old_type,int checktype) {int i;u64 end;
@@ -768,7 +768,7 @@ u64 __init e820__memblock_alloc_reserved(u64 size, u64 align)/* * Find the highest page frame number we have available */ -static unsigned long __init e820_end_pfn (unsigned long limit_pfn,unsigned type) +static unsigned long __init e820_end_pfn (unsigned long limit_pfn,enum e820_type type) {int i;unsigned long last_pfn =0 ;
Signature · 1 line
2.7.4
PATCH 39/50 x86/boot/e820: Prefix the E820_* type names with "E820_TYPE_"
In reply to Ingo MolnarSo there's a number of constants that start with "E820" but which are not types - these create a confusing mixture when seen together with 'enum e820_type' values:
E820MAP E820NR E820_X_MAX E820MAX
To better differentiate the 'enum e820_type' values prefix them with E820_TYPE_.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/boot/compressed/eboot.c | 12 +++---- arch/x86/boot/compressed/kaslr.c | 2 +- arch/x86/include/asm/gart.h | 2 +- arch/x86/include/uapi/asm/e820/types.h | 16 ++++----- arch/x86/kernel/acpi/boot.c | 2 +- arch/x86/kernel/aperture_64.c | 4 +-- arch/x86/kernel/cpu/mtrr/cleanup.c | 2 +- arch/x86/kernel/crash.c | 10 +++--- arch/x86/kernel/e820.c | 104 ++++++++++++++++++++++++++--------------------------- arch/x86/kernel/early-quirks.c | 2 +- arch/x86/kernel/kexec-bzimage64.c | 2 +- arch/x86/kernel/setup.c | 20 +++++------ arch/x86/kernel/tboot.c | 8 ++--- arch/x86/mm/init.c | 2 +- arch/x86/mm/init_64.c | 12 +++---- arch/x86/pci/mmconfig-shared.c | 2 +- arch/x86/platform/efi/efi.c | 14 ++++---- arch/x86/platform/efi/quirks.c | 6 ++-- arch/x86/xen/setup.c | 22 ++++++------ tools/lguest/lguest.c | 2 +- 20 files changed, 123 insertions(+), 123 deletions(-)
arch/x86/boot/compressed/eboot.c +6 -6
@@ -944,15 +944,15 @@ static efi_status_t setup_e820(struct boot_params *params,case EFI_MEMORY_MAPPED_IO :case EFI_MEMORY_MAPPED_IO_PORT_SPACE :case EFI_PAL_CODE : - e820_type =E820_RESERVED ; + e820_type =E820_TYPE_RESERVED ;break ;case EFI_UNUSABLE_MEMORY : - e820_type =E820_UNUSABLE ; + e820_type =E820_TYPE_UNUSABLE ;break ;case EFI_ACPI_RECLAIM_MEMORY : - e820_type =E820_ACPI ; + e820_type =E820_TYPE_ACPI ;break ;case EFI_LOADER_CODE :
@@ -960,15 +960,15 @@ static efi_status_t setup_e820(struct boot_params *params,case EFI_BOOT_SERVICES_CODE :case EFI_BOOT_SERVICES_DATA :case EFI_CONVENTIONAL_MEMORY : - e820_type =E820_RAM ; + e820_type =E820_TYPE_RAM ;break ;case EFI_ACPI_MEMORY_NVS : - e820_type =E820_NVS ; + e820_type =E820_TYPE_NVS ;break ;case EFI_PERSISTENT_MEMORY : - e820_type =E820_PMEM ; + e820_type =E820_TYPE_PMEM ;break ;default :
arch/x86/boot/compressed/kaslr.c +1 -1
@@ -435,7 +435,7 @@ static void process_e820_entry(struct e820_entry *entry,unsigned long start_orig;/* Skip non-RAM entries. */ -if (entry->type !=E820_RAM ) +if (entry->type !=E820_TYPE_RAM )return ;/* On 32-bit, ignore entries entirely above our maximum. */
arch/x86/include/asm/gart.h +1 -1
@@ -97,7 +97,7 @@ static inline int aperture_valid(u64 aper_base, u32 aper_size, u32 min_size)printk (KERN_INFO "Aperture beyond 4GB. Ignoring.\n" );return 0 ; } -if (e820__mapped_any (aper_base, aper_base + aper_size,E820_RAM )) { +if (e820__mapped_any (aper_base, aper_base + aper_size,E820_TYPE_RAM )) {printk (KERN_INFO "Aperture pointing to e820 RAM. Ignoring.\n" );return 0 ; }
arch/x86/include/uapi/asm/e820/types.h +8 -8
@@ -7,12 +7,12 @@#ifndef __ASSEMBLY__enum e820_type { -E820_RAM =1 , -E820_RESERVED =2 , -E820_ACPI =3 , -E820_NVS =4 , -E820_UNUSABLE =5 , -E820_PMEM =7 , +E820_TYPE_RAM =1 , +E820_TYPE_RESERVED =2 , +E820_TYPE_ACPI =3 , +E820_TYPE_NVS =4 , +E820_TYPE_UNUSABLE =5 , +E820_TYPE_PMEM =7 ,/* * This is a non-standardized way to represent ADR or
@@ -25,7 +25,7 @@ enum e820_type {* type of memory, but newer versions switched to 12 as * 6 was assigned differently. Some time they will learn... ) */ - E820_PRAM = 12, + E820_TYPE_PRAM = 12,/* * Reserved RAM used by the kernel itself if
@@ -34,7 +34,7 @@ enum e820_type {* and so should not include any memory that the BIOS * might alter over the S3 transition: */ - E820_RESERVED_KERN = 128, + E820_TYPE_RESERVED_KERN = 128, };/*
arch/x86/kernel/acpi/boot.c +1 -1
@@ -1715,6 +1715,6 @@ int __acpi_release_global_lock(unsigned int *lock)void __init arch_reserve_mem_area (acpi_physical_address addr,size_t size) { -e820__range_add (addr, size,E820_ACPI ); +e820__range_add (addr, size,E820_TYPE_ACPI );e820__update_table_print (); }
arch/x86/kernel/aperture_64.c +2 -2
@@ -307,11 +307,11 @@ void __init early_gart_iommu_check(void)if (gart_fix_e820 && !fix && aper_enabled) {if (e820__mapped_any (aper_base, aper_base + aper_size, -E820_RAM )) { +E820_TYPE_RAM )) {/* reserve it, so we can reuse it in second kernel */ pr_info ("e820: reserve [mem %#010Lx-%#010Lx] for GART\n" , aper_base, aper_base + aper_size -1 ); -e820__range_add (aper_base, aper_size,E820_RESERVED ); +e820__range_add (aper_base, aper_size,E820_TYPE_RESERVED );e820__update_table_print (); } }
arch/x86/kernel/cpu/mtrr/cleanup.c +1 -1
@@ -860,7 +860,7 @@ real_trim_memory(unsigned long start_pfn, unsigned long limit_pfn) trim_size <<=PAGE_SHIFT ; trim_size -= trim_start; -return e820__range_update (trim_start, trim_size,E820_RAM ,E820_RESERVED ); +return e820__range_update (trim_start, trim_size,E820_TYPE_RAM ,E820_TYPE_RESERVED ); }/**
arch/x86/kernel/crash.c +5 -5
@@ -575,17 +575,17 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)/* Add first 640K segment */ ei.addr = image->arch.backup_src_start; ei.size = image->arch.backup_src_sz; - ei.type =E820_RAM ; + ei.type =E820_TYPE_RAM ;add_e820_entry (params, &ei);/* Add ACPI tables */ - cmd.type =E820_ACPI ; + cmd.type =E820_TYPE_ACPI ; flags =IORESOURCE_MEM |IORESOURCE_BUSY ;walk_iomem_res_desc (IORES_DESC_ACPI_TABLES , flags,0 ,-1 , &cmd, memmap_entry_callback);/* Add ACPI Non-volatile Storage */ - cmd.type =E820_NVS ; + cmd.type =E820_TYPE_NVS ;walk_iomem_res_desc (IORES_DESC_ACPI_NV_STORAGE , flags,0 ,-1 , &cmd, memmap_entry_callback);
@@ -593,7 +593,7 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)if (crashk_low_res.end) { ei.addr = crashk_low_res.start; ei.size = crashk_low_res.end - crashk_low_res.start +1 ; - ei.type =E820_RAM ; + ei.type =E820_TYPE_RAM ;add_e820_entry (params, &ei); }
@@ -610,7 +610,7 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)if (ei.size <PAGE_SIZE )continue ; ei.addr = cmem->ranges[i].start; - ei.type =E820_RAM ; + ei.type =E820_TYPE_RAM ;add_e820_entry (params, &ei); }
arch/x86/kernel/e820.c +52 -52
211 lines not on this page · raw message
arch/x86/kernel/early-quirks.c +1 -1
@@ -546,7 +546,7 @@ intel_graphics_stolen(int num, int slot, int func, &base, &end);/* Mark this space as reserved */ -e820__range_add (base, size,E820_RESERVED ); +e820__range_add (base, size,E820_TYPE_RESERVED );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }
arch/x86/kernel/kexec-bzimage64.c +1 -1
@@ -232,7 +232,7 @@ setup_boot_parameters(struct kimage *image, struct boot_params *params, nr_e820_entries = params->e820_entries;for (i =0 ; i < nr_e820_entries; i++) { -if (params->e820_table[i].type !=E820_RAM ) +if (params->e820_table[i].type !=E820_TYPE_RAM )continue ; start = params->e820_table[i].addr; end = params->e820_table[i].addr + params->e820_table[i].size -1 ;
arch/x86/kernel/setup.c +10 -10
@@ -119,7 +119,7 @@* max_low_pfn_mapped: highest direct mapped pfn under 4GB * max_pfn_mapped: highest direct mapped pfn over 4GB * -* The direct mapping only covers E820_RAM regions, so the ranges and gaps are +* The direct mapping only covers E820_TYPE_RAM regions, so the ranges and gaps are * represented by pfn_mapped */ unsigned long max_low_pfn_mapped;
@@ -731,14 +731,14 @@ static void __init trim_bios_range(void)* since some BIOSes are known to corrupt low memory. See the * Kconfig help text for X86_RESERVE_LOW. */ -e820__range_update (0 ,PAGE_SIZE ,E820_RAM ,E820_RESERVED ); +e820__range_update (0 ,PAGE_SIZE ,E820_TYPE_RAM ,E820_TYPE_RESERVED );/* * special case: Some BIOSen report the PC BIOS * area (640->1Mb) as ram even though it is not. * take them out. */ -e820__range_remove (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_RAM ,1 ); +e820__range_remove (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_TYPE_RAM ,1 );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); }
@@ -750,18 +750,18 @@ static void __init e820_add_kernel_range(void)u64 size =__pa_symbol (_end) - start;/* -* Complain if .text .data and .bss are not marked as E820_RAM and +* Complain if .text .data and .bss are not marked as E820_TYPE_RAM and * attempt to fix it by adding the range. We may have a confused BIOS, * or the user may have used memmap=exactmap or memmap=xxM$yyM to * exclude kernel range. If we really are running on top non-RAM, * we will crash later anyways. */ -if (e820__mapped_all (start, start + size,E820_RAM )) +if (e820__mapped_all (start, start + size,E820_TYPE_RAM ))return ; -pr_warn (".text .data .bss are not marked as E820_RAM!\n" ); -e820__range_remove (start, size,E820_RAM ,0 ); -e820__range_add (start, size,E820_RAM ); +pr_warn (".text .data .bss are not marked as E820_TYPE_RAM!\n" ); +e820__range_remove (start, size,E820_TYPE_RAM ,0 ); +e820__range_add (start, size,E820_TYPE_RAM ); }static unsigned reserve_low =CONFIG_X86_RESERVE_LOW <<10 ;
@@ -1031,8 +1031,8 @@ void __init setup_arch(char **cmdline_p)trim_bios_range ();#ifdef CONFIG_X86_32 if (ppro_with_ram_bug ()) { -e820__range_update (0x70000000ULL ,0x40000ULL ,E820_RAM , -E820_RESERVED ); +e820__range_update (0x70000000ULL ,0x40000ULL ,E820_TYPE_RAM , +E820_TYPE_RESERVED );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);printk (KERN_INFO "fixed physical RAM map:\n" );e820__print_table ("bad_ppro" );
arch/x86/kernel/tboot.c +4 -4
@@ -69,8 +69,8 @@ void __init tboot_probe(void)* set_fixmap(), to reduce chance of garbage value causing crash */ if (!e820__mapped_any (boot_params.tboot_addr, - boot_params.tboot_addr,E820_RESERVED )) { -pr_warning ("non-0 tboot_addr but it is not of type E820_RESERVED\n" ); + boot_params.tboot_addr,E820_TYPE_RESERVED )) { +pr_warning ("non-0 tboot_addr but it is not of type E820_TYPE_RESERVED\n" );return ; }
@@ -189,8 +189,8 @@ static int tboot_setup_sleep(void) tboot->num_mac_regions =0 ;for (i =0 ; i < e820_table->nr_entries; i++) { -if ((e820_table->entries[i].type !=E820_RAM ) - && (e820_table->entries[i].type !=E820_RESERVED_KERN )) +if ((e820_table->entries[i].type !=E820_TYPE_RAM ) + && (e820_table->entries[i].type !=E820_TYPE_RESERVED_KERN ))continue ;add_mac_region (e820_table->entries[i].addr, e820_table->entries[i].size);
arch/x86/mm/init.c +1 -1
@@ -430,7 +430,7 @@ unsigned long __ref init_memory_mapping(unsigned long start,/* * We need to iterate through the E820 memory map and create direct mappings -* for only E820_RAM and E820_KERN_RESERVED regions. We cannot simply +* for only E820_TYPE_RAM and E820_KERN_RESERVED regions. We cannot simply * create direct mappings for all pfns from [0 to max_low_pfn) and * [4GB to max_pfn) because of possible memory holes in high addresses * that cannot be marked as UC by fixed/variable range MTRRs.
arch/x86/mm/init_64.c +6 -6
@@ -338,9 +338,9 @@ phys_pte_init(pte_t *pte_page, unsigned long paddr, unsigned long paddr_end,if (paddr >= paddr_end) {if (!after_bootmem && !e820__mapped_any (paddr &PAGE_MASK , paddr_next, -E820_RAM ) && +E820_TYPE_RAM ) && !e820__mapped_any (paddr &PAGE_MASK , paddr_next, -E820_RESERVED_KERN )) +E820_TYPE_RESERVED_KERN ))set_pte (pte,__pte (0 ));continue ; }
@@ -393,9 +393,9 @@ phys_pmd_init(pmd_t *pmd_page, unsigned long paddr, unsigned long paddr_end,if (paddr >= paddr_end) {if (!after_bootmem && !e820__mapped_any (paddr &PMD_MASK , paddr_next, -E820_RAM ) && +E820_TYPE_RAM ) && !e820__mapped_any (paddr &PMD_MASK , paddr_next, -E820_RESERVED_KERN )) +E820_TYPE_RESERVED_KERN ))set_pmd (pmd,__pmd (0 ));continue ; }
@@ -479,9 +479,9 @@ phys_pud_init(pud_t *pud_page, unsigned long paddr, unsigned long paddr_end,if (paddr >= paddr_end) {if (!after_bootmem && !e820__mapped_any (paddr &PUD_MASK , paddr_next, -E820_RAM ) && +E820_TYPE_RAM ) && !e820__mapped_any (paddr &PUD_MASK , paddr_next, -E820_RESERVED_KERN )) +E820_TYPE_RESERVED_KERN ))set_pud (pud,__pud (0 ));continue ; }
arch/x86/pci/mmconfig-shared.c +1 -1
@@ -452,7 +452,7 @@ static int __ref is_mmconf_reserved(check_reserved_t is_reserved,int num_buses;char *method = with_e820 ?"E820" :"ACPI motherboard resources" ; -while (!is_reserved (addr, addr + size,E820_RESERVED )) { +while (!is_reserved (addr, addr + size,E820_TYPE_RESERVED )) { size >>=1 ;if (size < (16UL <<20 ))break ;
arch/x86/platform/efi/efi.c +7 -7
@@ -140,21 +140,21 @@ static void __init do_add_efi_memmap(void)case EFI_BOOT_SERVICES_DATA :case EFI_CONVENTIONAL_MEMORY :if (md->attribute &EFI_MEMORY_WB ) - e820_type =E820_RAM ; + e820_type =E820_TYPE_RAM ;else - e820_type =E820_RESERVED ; + e820_type =E820_TYPE_RESERVED ;break ;case EFI_ACPI_RECLAIM_MEMORY : - e820_type =E820_ACPI ; + e820_type =E820_TYPE_ACPI ;break ;case EFI_ACPI_MEMORY_NVS : - e820_type =E820_NVS ; + e820_type =E820_TYPE_NVS ;break ;case EFI_UNUSABLE_MEMORY : - e820_type =E820_UNUSABLE ; + e820_type =E820_TYPE_UNUSABLE ;break ;case EFI_PERSISTENT_MEMORY : - e820_type =E820_PMEM ; + e820_type =E820_TYPE_PMEM ;break ;default :/*
@@ -162,7 +162,7 @@ static void __init do_add_efi_memmap(void)* EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE */ - e820_type =E820_RESERVED ; + e820_type =E820_TYPE_RESERVED ;break ; }e820__range_add (start, size, e820_type);
arch/x86/platform/efi/quirks.c +3 -3
@@ -242,14 +242,14 @@ void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size)* else. We must only reserve (and then free) regions: * * - Not within any part of the kernel -* - Not the BIOS reserved area (E820_RESERVED, E820_NVS, etc) +* - Not the BIOS reserved area (E820_TYPE_RESERVED, E820_TYPE_NVS, etc) */ static bool can_free_region (u64 start,u64 size) {if (start + size >__pa_symbol (_text) && start <=__pa_symbol (_end))return false; -if (!e820__mapped_all (start, start+size,E820_RAM )) +if (!e820__mapped_all (start, start+size,E820_TYPE_RAM ))return false;return true;
@@ -282,7 +282,7 @@ void __init efi_reserve_boot_services(void)* A good example of a critical region that must not be * freed is page zero (first 4Kb of memory), which may * contain boot services code/data but is marked -* E820_RESERVED by trim_bios_range(). +* E820_TYPE_RESERVED by trim_bios_range(). */ if (!already_reserved) {memblock_reserve (start, size);
arch/x86/xen/setup.c +11 -11
@@ -206,7 +206,7 @@ static unsigned long __init xen_find_pfn_range(unsigned long *min_pfn)unsigned long s_pfn;unsigned long e_pfn; -if (entry->type !=E820_RAM ) +if (entry->type !=E820_TYPE_RAM )continue ; e_pfn =PFN_DOWN (entry->addr + entry->size);
@@ -473,11 +473,11 @@ static unsigned long __init xen_foreach_remap_area(unsigned long nr_pages,*/ for (i =0 ; i < xen_e820_table_entries; i++, entry++) {phys_addr_t end = entry->addr + entry->size; -if (entry->type ==E820_RAM || i == xen_e820_table_entries -1 ) { +if (entry->type ==E820_TYPE_RAM || i == xen_e820_table_entries -1 ) {unsigned long start_pfn =PFN_DOWN (start);unsigned long end_pfn =PFN_UP (end); -if (entry->type ==E820_RAM ) +if (entry->type ==E820_TYPE_RAM ) end_pfn =PFN_UP (entry->addr);if (start_pfn < end_pfn)
@@ -591,7 +591,7 @@ static void __init xen_align_and_add_e820_region(phys_addr_t start,phys_addr_t end = start + size;/* Align RAM regions to page boundaries. */ -if (type ==E820_RAM ) { +if (type ==E820_TYPE_RAM ) { start =PAGE_ALIGN (start); end &= ~((phys_addr_t )PAGE_SIZE -1 ); }
@@ -605,8 +605,8 @@ static void __init xen_ignore_unusable(void)unsigned int i;for (i =0 ; i < xen_e820_table_entries; i++, entry++) { -if (entry->type ==E820_UNUSABLE ) - entry->type =E820_RAM ; +if (entry->type ==E820_TYPE_UNUSABLE ) + entry->type =E820_TYPE_RAM ; } }
@@ -623,7 +623,7 @@ bool __init xen_is_e820_reserved(phys_addr_t start, phys_addr_t size) entry = xen_e820_table;for (mapcnt =0 ; mapcnt < xen_e820_table_entries; mapcnt++) { -if (entry->type ==E820_RAM && entry->addr <= start && +if (entry->type ==E820_TYPE_RAM && entry->addr <= start && (entry->addr + entry->size) >= end)return false;
@@ -648,7 +648,7 @@ phys_addr_t __init xen_find_free_area(phys_addr_t size)struct e820_entry *entry = xen_e820_table;for (mapcnt =0 ; mapcnt < xen_e820_table_entries; mapcnt++, entry++) { -if (entry->type !=E820_RAM || entry->size < size) +if (entry->type !=E820_TYPE_RAM || entry->size < size)continue ; start = entry->addr;for (addr = start; addr < start + size; addr +=PAGE_SIZE ) {
@@ -764,7 +764,7 @@ char * __init xen_memory_setup(void) xen_e820_table[0 ].size = mem_end;/* 8MB slack (to balance backend allocations). */ xen_e820_table[0 ].size +=8ULL <<20 ; - xen_e820_table[0 ].type =E820_RAM ; + xen_e820_table[0 ].type =E820_TYPE_RAM ; rc =0 ; }BUG_ON (rc);
@@ -819,7 +819,7 @@ char * __init xen_memory_setup(void) chunk_size = size; type = xen_e820_table[i].type; -if (type ==E820_RAM ) { +if (type ==E820_TYPE_RAM ) {if (addr < mem_end) { chunk_size =min (size, mem_end - addr); }else if (extra_pages) {
@@ -859,7 +859,7 @@ char * __init xen_memory_setup(void)* about in there. */ e820__range_add (ISA_START_ADDRESS ,ISA_END_ADDRESS -ISA_START_ADDRESS , -E820_RESERVED ); +E820_TYPE_RESERVED );e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries);
tools/lguest/lguest.c +1 -1
@@ -3339,7 +3339,7 @@ int main(int argc, char *argv[])* simple, single region. */ boot->e820_entries =1 ; - boot->e820_table[0 ] = ((struct e820_entry ) {0 , mem,E820_RAM }); + boot->e820_table[0 ] = ((struct e820_entry ) {0 , mem,E820_TYPE_RAM });/* * The boot header contains a command line pointer: we put the command * line after the boot header.
Signature · 1 line
2.7.4
PATCH 40/50 x86/boot/e820: Clean up the E820 table size define names
In reply to Ingo MolnarWe've got a number of defines related to the E820 table and its size:
E820MAP E820NR E820_X_MAX E820MAX
The first two denote byte offsets into the zeropage (struct boot_params), and can are not used in the kernel and can be removed.
The E820_*_MAX values have an inconsistent structure and it's unclear in any case what they mean. 'X' presuably goes for extended - but it's not very expressive altogether.
Change these over to:
E820_MAX_ENTRIES_ZEROPAGE E820_MAX_ENTRIES
... which are self-explanatory names.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/types.h | 18 ++++++------------ arch/x86/include/uapi/asm/bootparam.h | 2 +- arch/x86/include/uapi/asm/e820/types.h | 7 +++++-- arch/x86/kernel/crash.c | 2 +- arch/x86/kernel/e820.c | 8 ++++---- arch/x86/kernel/kexec-bzimage64.c | 6 +++--- arch/x86/mm/init.c | 6 +++--- arch/x86/mm/kasan_init_64.c | 4 ++-- arch/x86/xen/setup.c | 2 +- include/xen/page.h | 2 +- 10 files changed, 27 insertions(+), 30 deletions(-)
arch/x86/include/asm/e820/types.h +6 -12
@@ -4,12 +4,12 @@#include <uapi/asm/e820/types.h> /* -* The legacy E820 BIOS limits us to 128 (E820MAX) nodes due to the -* constrained space in the zeropage. +* The legacy E820 BIOS limits us to 128 (E820_MAX_ENTRIES_ZEROPAGE) nodes +* due to the constrained space in the zeropage. * * On large systems we can easily have thousands of nodes with RAM, * which cannot be fit into so few entries - so we have a mechanism -* to extend the e820 table size at build-time, via the E820_X_MAX +* to extend the e820 table size at build-time, via the E820_MAX_ENTRIES * define below. * * ( Those extra entries are enumerated via the EFI memory map, not
@@ -17,7 +17,7 @@* * Size our internal memory map tables to have room for these additional * entries, based on a heuristic calculation: up to three entries per -* NUMA node, plus E820MAX for some extra space. +* NUMA node, plus E820_MAX_ENTRIES_ZEROPAGE for some extra space. * * This allows for bootstrap/firmware quirks such as possible duplicate * E820 entries that might need room in the same arrays, prior to the
@@ -31,20 +31,14 @@#include <linux/numa.h> -#define E820_X_MAX (E820MAX + 3*MAX_NUMNODES) - -/* Our map: */ -#define E820MAP 0x2d0 - -/* Number of entries in E820MAP: */ -#define E820NR 0x1e8 +#define E820_MAX_ENTRIES (E820_MAX_ENTRIES_ZEROPAGE + 3*MAX_NUMNODES)/* * The whole array of E820 entries: */ struct e820_table {__u32 nr_entries; -struct e820_entry entries[E820_X_MAX ]; +struct e820_entry entries[E820_MAX_ENTRIES ]; };/*
arch/x86/include/uapi/asm/bootparam.h +1 -1
@@ -152,7 +152,7 @@ struct boot_params {struct setup_header hdr;/* setup header */ /* 0x1f1 */ __u8 _pad7[0x290 -0x1f1 -sizeof (struct setup_header )];__u32 edd_mbr_sig_buffer[EDD_MBR_SIG_MAX ];/* 0x290 */ -struct e820_entry e820_table[E820MAX ];/* 0x2d0 */ +struct e820_entry e820_table[E820_MAX_ENTRIES_ZEROPAGE ];/* 0x2d0 */ __u8 _pad8[48 ];/* 0xcd0 */ struct edd_info eddbuf[EDDMAXNR ];/* 0xd00 */ __u8 _pad9[276 ];/* 0xeec */
arch/x86/include/uapi/asm/e820/types.h +5 -2
@@ -1,8 +1,11 @@#ifndef _UAPI_ASM_E820_TYPES_H#define _UAPI_ASM_E820_TYPES_H -/* The maximum number of entries in E820MAP: */ -#define E820MAX 128 +/* +* This is the maximum number of entries in struct boot_params::e820_table (the zeropage), +* which is part of the x86 boot protocol ABI: +*/ +#define E820_MAX_ENTRIES_ZEROPAGE 128#ifndef __ASSEMBLY__
arch/x86/kernel/crash.c +1 -1
@@ -509,7 +509,7 @@ static int add_e820_entry(struct boot_params *params, struct e820_entry *entry)unsigned int nr_e820_entries; nr_e820_entries = params->e820_entries; -if (nr_e820_entries >=E820MAX ) +if (nr_e820_entries >=E820_MAX_ENTRIES_ZEROPAGE )return 1 ; memcpy(¶ms->e820_table[nr_e820_entries], entry,
arch/x86/kernel/e820.c +4 -4
@@ -261,10 +261,10 @@ static int __init cpcompare(const void *a, const void *b)int __init e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map) { -static struct change_member change_point_list[2 *E820_X_MAX ]__initdata ; -static struct change_member *change_point[2 *E820_X_MAX ]__initdata ; -static struct e820_entry *overlap_list[E820_X_MAX ]__initdata ; -static struct e820_entry new_bios[E820_X_MAX ]__initdata ; +static struct change_member change_point_list[2 *E820_MAX_ENTRIES ]__initdata ; +static struct change_member *change_point[2 *E820_MAX_ENTRIES ]__initdata ; +static struct e820_entry *overlap_list[E820_MAX_ENTRIES ]__initdata ; +static struct e820_entry new_bios[E820_MAX_ENTRIES ]__initdata ;enum e820_type current_type, last_type;unsigned long long last_addr;int chgidx;
arch/x86/kernel/kexec-bzimage64.c +3 -3
@@ -102,9 +102,9 @@ static int setup_e820_entries(struct boot_params *params) nr_e820_entries = e820_table_firmware->nr_entries; -/* TODO: Pass entries more than E820MAX in bootparams setup data */ -if (nr_e820_entries >E820MAX ) - nr_e820_entries =E820MAX ; +/* TODO: Pass entries more than E820_MAX_ENTRIES_ZEROPAGE in bootparams setup data */ +if (nr_e820_entries >E820_MAX_ENTRIES_ZEROPAGE ) + nr_e820_entries =E820_MAX_ENTRIES_ZEROPAGE ; params->e820_entries = nr_e820_entries;memcpy (¶ms->e820_table, &e820_table_firmware->entries, nr_e820_entries*sizeof (struct e820_entry ));
arch/x86/mm/init.c +3 -3
@@ -373,14 +373,14 @@ static int __meminit split_mem_range(struct map_range *mr, int nr_range,return nr_range; } -struct range pfn_mapped[E820_X_MAX ]; +struct range pfn_mapped[E820_MAX_ENTRIES ];int nr_pfn_mapped;static void add_pfn_range_mapped (unsigned long start_pfn,unsigned long end_pfn) { - nr_pfn_mapped =add_range_with_merge (pfn_mapped,E820_X_MAX , + nr_pfn_mapped =add_range_with_merge (pfn_mapped,E820_MAX_ENTRIES , nr_pfn_mapped, start_pfn, end_pfn); - nr_pfn_mapped =clean_sort_range (pfn_mapped,E820_X_MAX ); + nr_pfn_mapped =clean_sort_range (pfn_mapped,E820_MAX_ENTRIES ); max_pfn_mapped =max (max_pfn_mapped, end_pfn);
arch/x86/mm/kasan_init_64.c +2 -2
@@ -11,7 +11,7 @@#include <asm/sections.h> extern pgd_t early_level4_pgt[PTRS_PER_PGD ]; -extern struct range pfn_mapped[E820_X_MAX ]; +extern struct range pfn_mapped[E820_MAX_ENTRIES ];static int __init map_range (struct range *range) {
@@ -103,7 +103,7 @@ void __init kasan_init(void)kasan_populate_zero_shadow ((void *)KASAN_SHADOW_START ,kasan_mem_to_shadow ((void *)PAGE_OFFSET )); -for (i =0 ; i <E820_X_MAX ; i++) { +for (i =0 ; i <E820_MAX_ENTRIES ; i++) {if (pfn_mapped[i].end ==0 )break ;
arch/x86/xen/setup.c +1 -1
@@ -41,7 +41,7 @@ struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata;unsigned long xen_released_pages;/* E820 map used during setting up memory. */ -static struct e820_entry xen_e820_table[E820_X_MAX ]__initdata ; +static struct e820_entry xen_e820_table[E820_MAX_ENTRIES ]__initdata ;static u32 xen_e820_table_entries__initdata ;/*
include/xen/page.h +1 -1
@@ -38,7 +38,7 @@ struct xen_memory_region {unsigned long n_pfns; }; -#define XEN_EXTRA_MEM_MAX_REGIONS 128/* == E820MAX */ +#define XEN_EXTRA_MEM_MAX_REGIONS 128/* == E820_MAX_ENTRIES_ZEROPAGE */ extern __initdata struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS ];
Signature · 1 line
2.7.4
PATCH 41/50 x86/boot/e820: Clean up and standardize sizeof() uses
In reply to Ingo MolnarThere's various sizeof() uses in e820.c - standardize on the shortest and least error prone one, along the pattern of:
- memset(entry, 0, sizeof(struct e820_entry));
+ memset(entry, 0, sizeof(*entry));
... because with this pattern in most cases it's immediately clear that we have used the right type - and the pattern is robust against changing the type as well.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/kernel/e820.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
arch/x86/kernel/e820.c +6 -6
@@ -306,7 +306,7 @@ int __init e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *p chg_nr = chgidx;/* Sort change-point list by memory addresses (low -> high): */ -sort (change_point, chg_nr,sizeof *change_point, cpcompare,NULL ); +sort (change_point, chg_nr,sizeof (*change_point), cpcompare,NULL );/* Create a new BIOS memory map, removing overlaps: */ overlap_entries =0 ;/* Number of entries in the overlap table */
@@ -362,7 +362,7 @@ int __init e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *p new_nr = new_bios_entry;/* Copy new BIOS mapping into the original location: */ -memcpy (biosmap, new_bios, new_nr*sizeof (struct e820_entry )); +memcpy (biosmap, new_bios, new_nr*sizeof (*biosmap)); *pnr_map = new_nr;return 0 ;
@@ -513,7 +513,7 @@ u64 __init e820__range_remove(u64 start, u64 size, enum e820_type old_type, int/* Completely covered? */ if (entry->addr >= start && entry_end <= end) { real_removed_size += entry->size; -memset (entry,0 ,sizeof (struct e820_entry )); +memset (entry,0 ,sizeof (*entry));continue ; }
@@ -672,7 +672,7 @@ void __init e820__memory_setup_extended(u64 phys_addr, u32 data_len)struct setup_data *sdata; sdata =early_memremap (phys_addr, data_len); - entries = sdata->len /sizeof (struct e820_entry ); + entries = sdata->len /sizeof (*extmap); extmap = (struct e820_entry *)(sdata->data);__append_e820_table (extmap, entries);
@@ -932,7 +932,7 @@ void __init e820_reserve_setup_data(void) }e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); -memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table )); +memcpy (e820_table_firmware, e820_table,sizeof (*e820_table_firmware));printk (KERN_INFO "extended physical RAM map:\n" );e820__print_table ("reserve setup_data" ); }
@@ -1169,7 +1169,7 @@ void __init e820__memory_setup(void) who = x86_init.resources.memory_setup (); -memcpy (e820_table_firmware, e820_table,sizeof (struct e820_table )); +memcpy (e820_table_firmware, e820_table,sizeof (*e820_table_firmware));pr_info ("e820: BIOS-provided physical RAM map:\n" );e820__print_table (who);
Signature · 1 line
2.7.4
PATCH 42/50 xen, x86/boot/e820: Simplify Xen's xen_e820_table construct
In reply to Ingo MolnarThe Xen guest memory setup code has:
static struct e820_entry xen_e820_table[E820_MAX_ENTRIES] __initdata; static u32 xen_e820_table_entries __initdata;
... which is really a 'struct e820_table', open-coded.
Convert the Xen code over to use a single struct e820_table, as this will allow the simplification of the e820__update_table() API.
No intended change in functionality, but not runtime tested.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/xen/setup.c | 70 +++++++++++++++++++++++++++++++++------------------------------------- 1 file changed, 33 insertions(+), 37 deletions(-)
arch/x86/xen/setup.c +33 -37
@@ -41,8 +41,7 @@ struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata;unsigned long xen_released_pages;/* E820 map used during setting up memory. */ -static struct e820_entry xen_e820_table[E820_MAX_ENTRIES ]__initdata ; -static u32 xen_e820_table_entries__initdata ; +static struct e820_table xen_e820_table__initdata ;/* * Buffer used to remap identity mapped pages. We only need the virtual space.
@@ -198,11 +197,11 @@ void __init xen_inv_extra_mem(void)*/ static unsigned long __init xen_find_pfn_range (unsigned long *min_pfn) { -const struct e820_entry *entry = xen_e820_table; +const struct e820_entry *entry = xen_e820_table.entries;unsigned int i;unsigned long done =0 ; -for (i =0 ; i < xen_e820_table_entries; i++, entry++) { +for (i =0 ; i < xen_e820_table.nr_entries; i++, entry++) {unsigned long s_pfn;unsigned long e_pfn;
@@ -457,7 +456,7 @@ static unsigned long __init xen_foreach_remap_area(unsigned long nr_pages, {phys_addr_t start =0 ;unsigned long ret_val =0 ; -const struct e820_entry *entry = xen_e820_table; +const struct e820_entry *entry = xen_e820_table.entries;int i;/*
@@ -471,9 +470,9 @@ static unsigned long __init xen_foreach_remap_area(unsigned long nr_pages,* example) the DMI tables in a reserved region that begins on * a non-page boundary. */ -for (i =0 ; i < xen_e820_table_entries; i++, entry++) { +for (i =0 ; i < xen_e820_table.nr_entries; i++, entry++) {phys_addr_t end = entry->addr + entry->size; -if (entry->type ==E820_TYPE_RAM || i == xen_e820_table_entries -1 ) { +if (entry->type ==E820_TYPE_RAM || i == xen_e820_table.nr_entries -1 ) {unsigned long start_pfn =PFN_DOWN (start);unsigned long end_pfn =PFN_UP (end);
@@ -601,10 +600,10 @@ static void __init xen_align_and_add_e820_region(phys_addr_t start,static void __init xen_ignore_unusable (void ) { -struct e820_entry *entry = xen_e820_table; +struct e820_entry *entry = xen_e820_table.entries;unsigned int i; -for (i =0 ; i < xen_e820_table_entries; i++, entry++) { +for (i =0 ; i < xen_e820_table.nr_entries; i++, entry++) {if (entry->type ==E820_TYPE_UNUSABLE ) entry->type =E820_TYPE_RAM ; }
@@ -620,9 +619,9 @@ bool __init xen_is_e820_reserved(phys_addr_t start, phys_addr_t size)return false; end = start + size; - entry = xen_e820_table; + entry = xen_e820_table.entries; -for (mapcnt =0 ; mapcnt < xen_e820_table_entries; mapcnt++) { +for (mapcnt =0 ; mapcnt < xen_e820_table.nr_entries; mapcnt++) {if (entry->type ==E820_TYPE_RAM && entry->addr <= start && (entry->addr + entry->size) >= end)return false;
@@ -645,9 +644,9 @@ phys_addr_t __init xen_find_free_area(phys_addr_t size) {unsigned mapcnt;phys_addr_t addr, start; -struct e820_entry *entry = xen_e820_table; +struct e820_entry *entry = xen_e820_table.entries; -for (mapcnt =0 ; mapcnt < xen_e820_table_entries; mapcnt++, entry++) { +for (mapcnt =0 ; mapcnt < xen_e820_table.nr_entries; mapcnt++, entry++) {if (entry->type !=E820_TYPE_RAM || entry->size < size)continue ; start = entry->addr;
@@ -750,8 +749,8 @@ char * __init xen_memory_setup(void) max_pfn =min (max_pfn, xen_start_info->nr_pages); mem_end =PFN_PHYS (max_pfn); - memmap.nr_entries =ARRAY_SIZE (xen_e820_table); -set_xen_guest_handle (memmap.buffer, xen_e820_table); + memmap.nr_entries =ARRAY_SIZE (xen_e820_table.entries); +set_xen_guest_handle (memmap.buffer, xen_e820_table.entries); op =xen_initial_domain () ? XENMEM_machine_memory_map :
@@ -760,16 +759,16 @@ char * __init xen_memory_setup(void)if (rc == -ENOSYS ) {BUG_ON (xen_initial_domain ()); memmap.nr_entries =1 ; - xen_e820_table[0 ].addr =0ULL ; - xen_e820_table[0 ].size = mem_end; + xen_e820_table.entries[0 ].addr =0ULL ; + xen_e820_table.entries[0 ].size = mem_end;/* 8MB slack (to balance backend allocations). */ - xen_e820_table[0 ].size +=8ULL <<20 ; - xen_e820_table[0 ].type =E820_TYPE_RAM ; + xen_e820_table.entries[0 ].size +=8ULL <<20 ; + xen_e820_table.entries[0 ].type =E820_TYPE_RAM ; rc =0 ; }BUG_ON (rc);BUG_ON (memmap.nr_entries ==0 ); - xen_e820_table_entries = memmap.nr_entries; + xen_e820_table.nr_entries = memmap.nr_entries;/* * Xen won't allow a 1:1 mapping to be created to UNUSABLE
@@ -783,8 +782,7 @@ char * __init xen_memory_setup(void)xen_ignore_unusable ();/* Make sure the Xen-supplied memory map is well-ordered. */ -e820__update_table (xen_e820_table,ARRAY_SIZE (xen_e820_table), - &xen_e820_table_entries); +e820__update_table (xen_e820_table.entries,ARRAY_SIZE (xen_e820_table.entries), &xen_e820_table.nr_entries); max_pages =xen_get_max_pages ();
@@ -811,13 +809,13 @@ char * __init xen_memory_setup(void) extra_pages =min3 (EXTRA_MEM_RATIO *min (max_pfn,PFN_DOWN (MAXMEM )), extra_pages, max_pages - max_pfn); i =0 ; - addr = xen_e820_table[0 ].addr; - size = xen_e820_table[0 ].size; -while (i < xen_e820_table_entries) { + addr = xen_e820_table.entries[0 ].addr; + size = xen_e820_table.entries[0 ].size; +while (i < xen_e820_table.nr_entries) {bool discard = false; chunk_size = size; - type = xen_e820_table[i].type; + type = xen_e820_table.entries[i].type;if (type ==E820_TYPE_RAM ) {if (addr < mem_end) {
@@ -840,9 +838,9 @@ char * __init xen_memory_setup(void) size -= chunk_size;if (size ==0 ) { i++; -if (i < xen_e820_table_entries) { - addr = xen_e820_table[i].addr; - size = xen_e820_table[i].size; +if (i < xen_e820_table.nr_entries) { + addr = xen_e820_table.entries[i].addr; + size = xen_e820_table.entries[i].size; } } }
@@ -923,21 +921,19 @@ char * __init xen_auto_xlated_memory_setup(void)int i;int rc; - memmap.nr_entries =ARRAY_SIZE (xen_e820_table); -set_xen_guest_handle (memmap.buffer, xen_e820_table); + memmap.nr_entries =ARRAY_SIZE (xen_e820_table.entries); +set_xen_guest_handle (memmap.buffer, xen_e820_table.entries); rc =HYPERVISOR_memory_op (XENMEM_memory_map, &memmap);if (rc <0 )panic ("No memory map (%d)\n" , rc); - xen_e820_table_entries = memmap.nr_entries; + xen_e820_table.nr_entries = memmap.nr_entries; -e820__update_table (xen_e820_table,ARRAY_SIZE (xen_e820_table), - &xen_e820_table_entries); +e820__update_table (xen_e820_table.entries,ARRAY_SIZE (xen_e820_table.entries), &xen_e820_table.nr_entries); -for (i =0 ; i < xen_e820_table_entries; i++) -e820__range_add (xen_e820_table[i].addr, xen_e820_table[i].size, - xen_e820_table[i].type); +for (i =0 ; i < xen_e820_table.nr_entries; i++) +e820__range_add (xen_e820_table.entries[i].addr, xen_e820_table.entries[i].size, xen_e820_table.entries[i].type);/* Remove p2m info, it is not needed. */ xen_start_info->mfn_list =0 ;
Signature · 1 line
2.7.4
PATCH 43/50 x86/boot/e820: Simplify the e820__update_table() interface
In reply to Ingo MolnarThe e820__update_table() parameters are pretty complex:
arch/x86/include/asm/e820/api.h:extern int e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *pnr_map);
But 90% of the usage is trivial:
arch/x86/kernel/e820.c: if (e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries)) arch/x86/kernel/e820.c: e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries); arch/x86/kernel/e820.c: e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries); arch/x86/kernel/e820.c: if (e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries) < 0) arch/x86/kernel/e820.c: e820__update_table(boot_params.e820_table, ARRAY_SIZE(boot_params.e820_table), &new_nr); arch/x86/kernel/early-quirks.c: e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries); arch/x86/kernel/setup.c: e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries); arch/x86/kernel/setup.c: e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries); arch/x86/platform/efi/efi.c: e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries); arch/x86/xen/setup.c: e820__update_table(xen_e820_table.entries, ARRAY_SIZE(xen_e820_table.entries), arch/x86/xen/setup.c: e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries); arch/x86/xen/setup.c: e820__update_table(xen_e820_table.entries, ARRAY_SIZE(xen_e820_table.entries),
as it only uses an exiting struct e820_table's entries array, its size and its current number of entries as input and output arguments.
Only one use is non-trivial:
arch/x86/kernel/e820.c: e820__update_table(boot_params.e820_table, ARRAY_SIZE(boot_params.e820_table), &new_nr);
... which call updates the E820 table in the zeropage in-situ, and the layout there does not match that of 'struct e820_table' (in particular nr_entries is at a different offset, hardcoded by the boot protocol).
Simplify all this by introducing a low level __e820__update_table() API that the zeropage update call can use, and simplifying the main e820__update_table() call signature down to:
int e820__update_table(struct e820_table *table);
This visibly simplifies all the call sites:
arch/x86/include/asm/e820/api.h:extern int e820__update_table(struct e820_table *table); arch/x86/include/asm/e820/types.h: * call to e820__update_table() to remove duplicates. The allowance arch/x86/kernel/e820.c: * The return value from e820__update_table() is zero if it arch/x86/kernel/e820.c:int __init e820__update_table(struct e820_table *table) arch/x86/kernel/e820.c: if (e820__update_table(e820_table)) arch/x86/kernel/e820.c: e820__update_table(e820_table_firmware); arch/x86/kernel/e820.c: e820__update_table(e820_table); arch/x86/kernel/e820.c: e820__update_table(e820_table); arch/x86/kernel/e820.c: if (e820__update_table(e820_table) < 0) arch/x86/kernel/early-quirks.c: e820__update_table(e820_table); arch/x86/kernel/setup.c: e820__update_table(e820_table); arch/x86/kernel/setup.c: e820__update_table(e820_table); arch/x86/platform/efi/efi.c: e820__update_table(e820_table); arch/x86/xen/setup.c: e820__update_table(&xen_e820_table); arch/x86/xen/setup.c: e820__update_table(e820_table); arch/x86/xen/setup.c: e820__update_table(&xen_e820_table);
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/e820.c | 19 ++++++++++++------- arch/x86/kernel/early-quirks.c | 2 +- arch/x86/kernel/setup.c | 4 ++-- arch/x86/platform/efi/efi.c | 2 +- arch/x86/xen/setup.c | 9 ++++----- 6 files changed, 21 insertions(+), 17 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -16,7 +16,7 @@ extern u64 e820__range_update(u64 start, u64 size, enum e820_type old_type, enuextern u64 e820__range_remove (u64 start,u64 size,enum e820_type old_type,int checktype);extern void e820__print_table (char *who); -extern int e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map); +extern int e820__update_table (struct e820_table *table);extern void e820__update_table_print (void );extern unsigned long e820_end_of_ram_pfn (void );
arch/x86/kernel/e820.c +12 -7
@@ -259,7 +259,7 @@ static int __init cpcompare(const void *a, const void *b)return (ap->addr != ap->pbios->addr) - (bp->addr != bp->pbios->addr); } -int __init e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map) +static int __init __e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map) {static struct change_member change_point_list[2 *E820_MAX_ENTRIES ]__initdata ;static struct change_member *change_point[2 *E820_MAX_ENTRIES ]__initdata ;
@@ -368,6 +368,11 @@ int __init e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *preturn 0 ; } +int __init e820__update_table (struct e820_table *table) +{ +return __e820__update_table (table->entries,ARRAY_SIZE (table->entries), &table->nr_entries); +} +static int __init __append_e820_table (struct e820_entry *biosmap,int nr_map) {while (nr_map) {
@@ -548,7 +553,7 @@ u64 __init e820__range_remove(u64 start, u64 size, enum e820_type old_type, intvoid __init e820__update_table_print (void ) { -if (e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries)) +if (e820__update_table (e820_table))return ;pr_info ("e820: modified physical RAM map:\n" );
@@ -557,7 +562,7 @@ void __init e820__update_table_print(void)static void __init e820__update_table_firmware (void ) { -e820__update_table (e820_table_firmware->entries,ARRAY_SIZE (e820_table_firmware->entries), &e820_table_firmware->nr_entries); +e820__update_table (e820_table_firmware); }#define MAX_GAP_END 0x100000000ull
@@ -676,7 +681,7 @@ void __init e820__memory_setup_extended(u64 phys_addr, u32 data_len) extmap = (struct e820_entry *)(sdata->data);__append_e820_table (extmap, entries); -e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table);early_memunmap (sdata, data_len);pr_info ("e820: extended physical RAM map:\n" );
@@ -931,7 +936,7 @@ void __init e820_reserve_setup_data(void)early_memunmap (data,sizeof (*data)); } -e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table);memcpy (e820_table_firmware, e820_table,sizeof (*e820_table_firmware));printk (KERN_INFO "extended physical RAM map:\n" );e820__print_table ("reserve setup_data" );
@@ -945,7 +950,7 @@ void __init e820_reserve_setup_data(void)void __init e820__finish_early_params (void ) {if (userdef) { -if (e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries) <0 ) +if (e820__update_table (e820_table) <0 )early_panic ("Invalid user supplied memory map" );pr_info ("e820: user-defined physical RAM map:\n" );
@@ -1132,7 +1137,7 @@ char *__init e820__memory_setup_default(void)* the next section from 1mb->appropriate_mem_k */ new_nr = boot_params.e820_entries; -e820__update_table (boot_params.e820_table,ARRAY_SIZE (boot_params.e820_table), &new_nr); +__e820__update_table (boot_params.e820_table,ARRAY_SIZE (boot_params.e820_table), &new_nr); boot_params.e820_entries = new_nr;if (append_e820_table (boot_params.e820_table, boot_params.e820_entries) <0 ) {
arch/x86/kernel/early-quirks.c +1 -1
@@ -547,7 +547,7 @@ intel_graphics_stolen(int num, int slot, int func,/* Mark this space as reserved */ e820__range_add (base, size,E820_TYPE_RESERVED ); -e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table); }static void __init intel_graphics_quirks (int num,int slot,int func)
arch/x86/kernel/setup.c +2 -2
@@ -740,7 +740,7 @@ static void __init trim_bios_range(void)*/ e820__range_remove (BIOS_BEGIN ,BIOS_END -BIOS_BEGIN ,E820_TYPE_RAM ,1 ); -e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table); }/* called before trim_bios_range() to spare extra sanitize */
@@ -1033,7 +1033,7 @@ void __init setup_arch(char **cmdline_p)if (ppro_with_ram_bug ()) {e820__range_update (0x70000000ULL ,0x40000ULL ,E820_TYPE_RAM ,E820_TYPE_RESERVED ); -e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table);printk (KERN_INFO "fixed physical RAM map:\n" );e820__print_table ("bad_ppro" ); }
arch/x86/platform/efi/efi.c +1 -1
@@ -167,7 +167,7 @@ static void __init do_add_efi_memmap(void) }e820__range_add (start, size, e820_type); } -e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table); }int __init efi_memblock_x86_reserve_range (void )
arch/x86/xen/setup.c +4 -5
@@ -782,7 +782,7 @@ char * __init xen_memory_setup(void)xen_ignore_unusable ();/* Make sure the Xen-supplied memory map is well-ordered. */ -e820__update_table (xen_e820_table.entries,ARRAY_SIZE (xen_e820_table.entries), &xen_e820_table.nr_entries); +e820__update_table (&xen_e820_table); max_pages =xen_get_max_pages ();
@@ -856,10 +856,9 @@ char * __init xen_memory_setup(void)* reserve ISA memory anyway because too many things poke * about in there. */ -e820__range_add (ISA_START_ADDRESS ,ISA_END_ADDRESS -ISA_START_ADDRESS , -E820_TYPE_RESERVED ); +e820__range_add (ISA_START_ADDRESS ,ISA_END_ADDRESS -ISA_START_ADDRESS ,E820_TYPE_RESERVED ); -e820__update_table (e820_table->entries,ARRAY_SIZE (e820_table->entries), &e820_table->nr_entries); +e820__update_table (e820_table);/* * Check whether the kernel itself conflicts with the target E820 map.
@@ -930,7 +929,7 @@ char * __init xen_auto_xlated_memory_setup(void) xen_e820_table.nr_entries = memmap.nr_entries; -e820__update_table (xen_e820_table.entries,ARRAY_SIZE (xen_e820_table.entries), &xen_e820_table.nr_entries); +e820__update_table (&xen_e820_table);for (i =0 ; i < xen_e820_table.nr_entries; i++)e820__range_add (xen_e820_table.entries[i].addr, xen_e820_table.entries[i].size, xen_e820_table.entries[i].type);
Signature · 1 line
2.7.4
PATCH 44/50 x86/boot/e820: Clean up __e820__update_table() et al
In reply to Ingo MolnarThe __e820__update_table() function has various weirdly named variables, such as 'pbios', 'biosmap' and 'pnr_map' which are pretty confusing and actively misleading at times.
This weird naming found its way into other functions as well, such as __append_e820_table() and append_e820_table().
Standardize the naming to make it all much easier to read:
biosmap -> entries
pbios -> entry
nr_map -> nr_entries
pnr_map -> nr_entries
...Also clean up the types used: entry indices routinely mixed u32 and int, standardize on u32 thoughout.
Update the comments as well, while at it.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/kernel/e820.c | 120 +++++++++++++++++++++++++++++++++++---------------------------------- 1 file changed, 61 insertions(+), 59 deletions(-)
arch/x86/kernel/e820.c +61 -59
@@ -175,23 +175,23 @@ void __init e820__print_table(char *who) }/* -* Sanitize the BIOS E820 map. +* Sanitize an E820 map. * -* Some E820 responses include overlapping entries. The following +* Some E820 layouts include overlapping entries. The following * replaces the original E820 map with a new one, removing overlaps, * and resolving conflicting memory types in favor of highest * numbered type. * -* The input parameter biosmap points to an array of 'struct -* e820_entry' which on entry has elements in the range [0, *pnr_map) -* valid, and which has space for up to max_nr_map entries. +* The input parameter 'entries' points to an array of 'struct +* e820_entry' which on entry has elements in the range [0, *nr_entries) +* valid, and which has space for up to max_nr_entries entries. * On return, the resulting sanitized E820 map entries will be in -* overwritten in the same location, starting at biosmap. +* overwritten in the same location, starting at 'entries'. * -* The integer pointed to by pnr_map must be valid on entry (the -* current number of valid entries located at biosmap). If the -* sanitizing succeeds the *pnr_map will be updated with the new -* number of valid entries (something no more than max_nr_map). +* The integer pointed to by nr_entries must be valid on entry (the +* current number of valid entries located at 'entries'). If the +* sanitizing succeeds the *nr_entries will be updated with the new +* number of valid entries (something no more than max_nr_entries). * * The return value from e820__update_table() is zero if it * successfully 'sanitized' the map entries passed in, and is -1
@@ -236,8 +236,8 @@ void __init e820__print_table(char *who)* ______________________4_ */ struct change_member { -/* Pointer to the original BIOS entry: */ -struct e820_entry *pbios; +/* Pointer to the original entry: */ +struct e820_entry *entry;/* Address for this change point: */ unsigned long long addr; };
@@ -256,33 +256,33 @@ static int __init cpcompare(const void *a, const void *b)if (ap->addr != bp->addr)return ap->addr > bp->addr ?1 :-1 ; -return (ap->addr != ap->pbios->addr) - (bp->addr != bp->pbios->addr); +return (ap->addr != ap->entry->addr) - (bp->addr != bp->entry->addr); } -static int __init __e820__update_table (struct e820_entry *biosmap,int max_nr_map,u32 *pnr_map) +static int __init __e820__update_table (struct e820_entry *entries,u32 max_nr_entries,u32 *nr_entries) {static struct change_member change_point_list[2 *E820_MAX_ENTRIES ]__initdata ;static struct change_member *change_point[2 *E820_MAX_ENTRIES ]__initdata ;static struct e820_entry *overlap_list[E820_MAX_ENTRIES ]__initdata ; -static struct e820_entry new_bios[E820_MAX_ENTRIES ]__initdata ; +static struct e820_entry new_entries[E820_MAX_ENTRIES ]__initdata ;enum e820_type current_type, last_type;unsigned long long last_addr; -int chgidx; -int overlap_entries; -int new_bios_entry; -int old_nr, new_nr, chg_nr; -int i; +u32 chgidx; +u32 overlap_entries; +u32 new_nr_entries; +u32 old_nr, new_nr, chg_nr; +u32 i;/* If there's only one memory region, don't bother: */ -if (*pnr_map <2 ) +if (*nr_entries <2 )return -1 ; - old_nr = *pnr_map; -BUG_ON (old_nr > max_nr_map); + old_nr = *nr_entries; +BUG_ON (old_nr > max_nr_entries); -/* Bail out if we find any unreasonable addresses in the BIOS map: */ +/* Bail out if we find any unreasonable addresses in the map: */ for (i =0 ; i < old_nr; i++) { -if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr) +if (entries[i].addr + entries[i].size < entries[i].addr)return -1 ; }
@@ -296,11 +296,11 @@ static int __init __e820__update_table(struct e820_entry *biosmap, int max_nr_ma*/ chgidx =0 ;for (i =0 ; i < old_nr; i++) { -if (biosmap[i].size !=0 ) { - change_point[chgidx]->addr = biosmap[i].addr; - change_point[chgidx++]->pbios = &biosmap[i]; - change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size; - change_point[chgidx++]->pbios = &biosmap[i]; +if (entries[i].size !=0 ) { + change_point[chgidx]->addr = entries[i].addr; + change_point[chgidx++]->entry = &entries[i]; + change_point[chgidx]->addr = entries[i].addr + entries[i].size; + change_point[chgidx++]->entry = &entries[i]; } } chg_nr = chgidx;
@@ -308,22 +308,22 @@ static int __init __e820__update_table(struct e820_entry *biosmap, int max_nr_ma/* Sort change-point list by memory addresses (low -> high): */ sort (change_point, chg_nr,sizeof (*change_point), cpcompare,NULL ); -/* Create a new BIOS memory map, removing overlaps: */ +/* Create a new memory map, removing overlaps: */ overlap_entries =0 ;/* Number of entries in the overlap table */ - new_bios_entry =0 ;/* Index for creating new bios map entries */ + new_nr_entries =0 ;/* Index for creating new map entries */ last_type =0 ;/* Start with undefined memory type */ last_addr =0 ;/* Start with 0 as last starting address */ -/* Loop through change-points, determining effect on the new BIOS map: */ +/* Loop through change-points, determining effect on the new map: */ for (chgidx =0 ; chgidx < chg_nr; chgidx++) { -/* Keep track of all overlapping BIOS entries */ -if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr) { +/* Keep track of all overlapping entries */ +if (change_point[chgidx]->addr == change_point[chgidx]->entry->addr) {/* Add map entry to overlap list (> 1 entry implies an overlap) */ - overlap_list[overlap_entries++] = change_point[chgidx]->pbios; + overlap_list[overlap_entries++] = change_point[chgidx]->entry; }else {/* Remove entry from list (order independent, so swap with last): */ for (i =0 ; i < overlap_entries; i++) { -if (overlap_list[i] == change_point[chgidx]->pbios) +if (overlap_list[i] == change_point[chgidx]->entry) overlap_list[i] = overlap_list[overlap_entries-1 ]; } overlap_entries--;
@@ -339,31 +339,31 @@ static int __init __e820__update_table(struct e820_entry *biosmap, int max_nr_ma current_type = overlap_list[i]->type; } -/* Continue building up new BIOS map based on this information: */ +/* Continue building up new map based on this information: */ if (current_type != last_type || current_type ==E820_TYPE_PRAM ) {if (last_type !=0 ) { - new_bios[new_bios_entry].size = change_point[chgidx]->addr - last_addr; + new_entries[new_nr_entries].size = change_point[chgidx]->addr - last_addr;/* Move forward only if the new size was non-zero: */ -if (new_bios[new_bios_entry].size !=0 ) -/* No more space left for new BIOS entries? */ -if (++new_bios_entry >= max_nr_map) +if (new_entries[new_nr_entries].size !=0 ) +/* No more space left for new entries? */ +if (++new_nr_entries >= max_nr_entries)break ; }if (current_type !=0 ) { - new_bios[new_bios_entry].addr = change_point[chgidx]->addr; - new_bios[new_bios_entry].type = current_type; + new_entries[new_nr_entries].addr = change_point[chgidx]->addr; + new_entries[new_nr_entries].type = current_type; last_addr = change_point[chgidx]->addr; } last_type = current_type; } } -/* Retain count for new BIOS entries: */ - new_nr = new_bios_entry; +/* Retain count for the new entries: */ + new_nr = new_nr_entries; -/* Copy new BIOS mapping into the original location: */ -memcpy (biosmap, new_bios, new_nr*sizeof (*biosmap)); - *pnr_map = new_nr; +/* Copy the new entries into the original location: */ +memcpy (entries, new_entries, new_nr*sizeof (*entries)); + *nr_entries = new_nr;return 0 ; }
@@ -373,13 +373,15 @@ int __init e820__update_table(struct e820_table *table)return __e820__update_table (table->entries,ARRAY_SIZE (table->entries), &table->nr_entries); } -static int __init __append_e820_table (struct e820_entry *biosmap,int nr_map) +static int __init __append_e820_table (struct e820_entry *entries,u32 nr_entries) { -while (nr_map) { -u64 start = biosmap->addr; -u64 size = biosmap->size; +struct e820_entry *entry = entries; + +while (nr_entries) { +u64 start = entry->addr; +u64 size = entry->size;u64 end = start + size -1 ; -u32 type = biosmap->type; +u32 type = entry->type;/* Ignore the entry on 64-bit overflow: */ if (start > end &&likely (size))
@@ -387,8 +389,8 @@ static int __init __append_e820_table(struct e820_entry *biosmap, int nr_map)e820__range_add (start, size, type); - biosmap++; - nr_map--; + entry++; + nr_entries--; }return 0 ; }
@@ -402,13 +404,13 @@ static int __init __append_e820_table(struct e820_entry *biosmap, int nr_map)* will have given us a memory map that we can use to properly * set up memory. If we aren't, we'll fake a memory map. */ -static int __init append_e820_table (struct e820_entry *biosmap,int nr_map) +static int __init append_e820_table (struct e820_entry *entries,u32 nr_entries) {/* Only one memory region (or negative)? Ignore it */ -if (nr_map <2 ) +if (nr_entries <2 )return -1 ; -return __append_e820_table (biosmap, nr_map); +return __append_e820_table (entries, nr_entries); } static u64 __init
Signature · 1 line
2.7.4
PATCH 45/50 x86/boot/e820: Document e820__reserve_setup_data()
In reply to Ingo MolnarAlso clean it up a bit.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 4 ++-- arch/x86/kernel/e820.c | 11 +++++++++-- arch/x86/kernel/setup.c | 3 +-- 3 files changed, 12 insertions(+), 6 deletions(-)
arch/x86/include/asm/e820/api.h +2 -2
@@ -22,10 +22,10 @@ extern void e820__update_table_print(void);extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void ); -extern u64 e820__memblock_alloc_reserved (u64 sizet,u64 align); +extern u64 e820__memblock_alloc_reserved (u64 size,u64 align);extern void e820__memblock_setup (void ); -extern void e820_reserve_setup_data (void ); +extern void e820__reserve_setup_data (void );extern void e820__finish_early_params (void );extern void e820_reserve_resources (void );extern void e820_reserve_resources_late (void );
arch/x86/kernel/e820.c +9 -2
@@ -922,7 +922,12 @@ static int __init parse_memmap_opt(char *str) }early_param ("memmap" , parse_memmap_opt); -void __init e820_reserve_setup_data (void ) +/* +* Reserve all entries from the bootloader's extensible data nodes list, +* because if present we are going to use it later on to fetch e820 +* entries from it: +*/ +void __init e820__reserve_setup_data (void ) {struct setup_data *data;u64 pa_data;
@@ -939,8 +944,10 @@ void __init e820_reserve_setup_data(void) }e820__update_table (e820_table); +memcpy (e820_table_firmware, e820_table,sizeof (*e820_table_firmware)); -printk (KERN_INFO "extended physical RAM map:\n" ); + +pr_info ("extended physical RAM map:\n" );e820__print_table ("reserve setup_data" ); }
arch/x86/kernel/setup.c +1 -2
@@ -1003,8 +1003,7 @@ void __init setup_arch(char **cmdline_p)early_dump_pci_devices ();#endif -/* update the e820_table_firmware too */ -e820_reserve_setup_data (); +e820__reserve_setup_data ();e820__finish_early_params ();if (efi_enabled (EFI_BOOT ))
Signature · 1 line
2.7.4
PATCH 46/50 x86/boot/e820: Use bool in query APIs
In reply to Ingo MolnarChange e820__mapped_any() and e820__mapped_all()'s return type and e820__range_remove()'s check_type parameter to bool.
Propagate it into arch/x86/pci/mmconfig-shared.c as this change affects a function signature there too.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 6 +++--- arch/x86/kernel/e820.c | 10 +++++----- arch/x86/pci/mmconfig-shared.c | 14 +++++++------- 3 files changed, 15 insertions(+), 15 deletions(-)
arch/x86/include/asm/e820/api.h +3 -3
@@ -8,12 +8,12 @@ extern struct e820_table *e820_table_firmware;extern unsigned long pci_mem_start; -extern int e820__mapped_any (u64 start,u64 end,enum e820_type type); -extern int e820__mapped_all (u64 start,u64 end,enum e820_type type); +extern bool e820__mapped_any (u64 start,u64 end,enum e820_type type); +extern bool e820__mapped_all (u64 start,u64 end,enum e820_type type);extern void e820__range_add (u64 start,u64 size,enum e820_type type);extern u64 e820__range_update (u64 start,u64 size,enum e820_type old_type,enum e820_type new_type); -extern u64 e820__range_remove (u64 start,u64 size,enum e820_type old_type,int checktype); +extern u64 e820__range_remove (u64 start,u64 size,enum e820_type old_type,bool check_type);extern void e820__print_table (char *who);extern int e820__update_table (struct e820_table *table);
arch/x86/kernel/e820.c +5 -5
@@ -68,7 +68,7 @@ EXPORT_SYMBOL(pci_mem_start);* This function checks if any part of the range <start,end> is mapped * with type. */ -int e820__mapped_any (u64 start,u64 end,enum e820_type type) +bool e820__mapped_any (u64 start,u64 end,enum e820_type type) {int i;
@@ -91,7 +91,7 @@ EXPORT_SYMBOL_GPL(e820__mapped_any);* Note: this function only works correctly once the E820 table is sorted and * not-overlapping (at least for the range specified), which is the case normally. */ -int __init e820__mapped_all (u64 start,u64 end,enum e820_type type) +bool __init e820__mapped_all (u64 start,u64 end,enum e820_type type) {int i;
@@ -492,7 +492,7 @@ static u64 __init e820__range_update_firmware(u64 start, u64 size, enum e820_typ }/* Remove a range of memory from the E820 table: */ -u64 __init e820__range_remove (u64 start,u64 size,enum e820_type old_type,int checktype) +u64 __init e820__range_remove (u64 start,u64 size,enum e820_type old_type,bool check_type) {int i;u64 end;
@@ -503,7 +503,7 @@ u64 __init e820__range_remove(u64 start, u64 size, enum e820_type old_type, int end = start + size;pr_debug ("e820: remove [mem %#010Lx-%#010Lx] " , start, end -1 ); -if (checktype) +if (check_type)e820_print_type (old_type);pr_cont ("\n" );
@@ -512,7 +512,7 @@ u64 __init e820__range_remove(u64 start, u64 size, enum e820_type old_type, intu64 final_start, final_end;u64 entry_end; -if (checktype && entry->type != old_type) +if (check_type && entry->type != old_type)continue ; entry_end = entry->addr + entry->size;
arch/x86/pci/mmconfig-shared.c +7 -7
@@ -423,7 +423,7 @@ static acpi_status find_mboard_resource(acpi_handle handle, u32 lvl,return AE_OK ; } -static int is_acpi_reserved (u64 start,u64 end,unsigned not_used) +static bool is_acpi_reserved (u64 start,u64 end,unsigned not_used) {struct resource mcfg_res;
@@ -440,11 +440,11 @@ static int is_acpi_reserved(u64 start, u64 end, unsigned not_used)return mcfg_res.flags; } -typedef int (*check_reserved_t )(u64 start,u64 end,unsigned type); +typedef bool (*check_reserved_t )(u64 start,u64 end,unsigned type); -static int __ref is_mmconf_reserved (check_reserved_t is_reserved, -struct pci_mmcfg_region *cfg, -struct device *dev,int with_e820) +static bool __ref is_mmconf_reserved (check_reserved_t is_reserved, +struct pci_mmcfg_region *cfg, +struct device *dev,int with_e820) {u64 addr = cfg->res.start;u64 size =resource_size (&cfg->res);
@@ -494,8 +494,8 @@ static int __ref is_mmconf_reserved(check_reserved_t is_reserved,return 1 ; } -static int __ref pci_mmcfg_check_reserved (struct device *dev, -struct pci_mmcfg_region *cfg,int early) +static bool __ref +pci_mmcfg_check_reserved (struct device *dev,struct pci_mmcfg_region *cfg,int early) {if (!early && !acpi_disabled) {if (is_mmconf_reserved (is_acpi_reserved, cfg, dev,0 ))
Signature · 1 line
2.7.4
PATCH 47/50 x86/boot/e820: Rename e820_reserve_resources*() to e820__reserve_resources*()
In reply to Ingo MolnarAlso do some minor cleanups.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 4 ++-- arch/x86/kernel/apic/apic.c | 2 +- arch/x86/kernel/e820.c | 16 +++++++++------- arch/x86/kernel/setup.c | 2 +- arch/x86/pci/i386.c | 2 +- 5 files changed, 14 insertions(+), 12 deletions(-)
arch/x86/include/asm/e820/api.h +2 -2
@@ -27,8 +27,8 @@ extern void e820__memblock_setup(void);extern void e820__reserve_setup_data (void );extern void e820__finish_early_params (void ); -extern void e820_reserve_resources (void ); -extern void e820_reserve_resources_late (void ); +extern void e820__reserve_resources (void ); +extern void e820__reserve_resources_late (void );extern void e820__memory_setup (void );extern void e820__memory_setup_extended (u64 phys_addr,u32 data_len);
arch/x86/kernel/apic/apic.c +1 -1
@@ -2647,7 +2647,7 @@ static int __init lapic_insert_resource(void) }/* -* need call insert after e820_reserve_resources() +* need call insert after e820__reserve_resources() * that is using request_resource */ late_initcall (lapic_insert_resource);
arch/x86/kernel/e820.c +9 -7
@@ -629,7 +629,7 @@ __init void e820__setup_pci_gap(void) }/* -* e820_reserve_resources_late protect stolen RAM already +* e820__reserve_resources_late() protects stolen RAM already: */ pci_mem_start = gapstart;
@@ -1035,7 +1035,7 @@ static bool __init do_mark_busy(u32 type, struct resource *res)static struct resource __initdata *e820_res; -void __init e820_reserve_resources (void ) +void __init e820__reserve_resources (void ) {int i;struct resource *res;
@@ -1059,9 +1059,9 @@ void __init e820_reserve_resources(void) res->desc =e820_type_to_iores_desc (entry);/* -* don't register the region that could be conflicted with -* pci device BAR resource and insert them later in -* pcibios_resource_survey() +* Don't register the region that could be conflicted with +* PCI device BAR resources and insert them later in +* pcibios_resource_survey(): */ if (do_mark_busy (entry->type, res)) { res->flags |=IORESOURCE_BUSY ;
@@ -1077,7 +1077,9 @@ void __init e820_reserve_resources(void) } } -/* How much should we pad RAM ending depending on where it is? */ +/* +* How much should we pad the end of RAM, depending on where it is? +*/ static unsigned long __init ram_alignment (resource_size_t pos) {unsigned long mb = pos >>20 ;
@@ -1096,7 +1098,7 @@ static unsigned long __init ram_alignment(resource_size_t pos)#define MAX_RESOURCE_SIZE ((resource_size_t)-1) -void __init e820_reserve_resources_late (void ) +void __init e820__reserve_resources_late (void ) {int i;struct resource *res;
arch/x86/kernel/setup.c +1 -1
@@ -1235,7 +1235,7 @@ void __init setup_arch(char **cmdline_p)kvm_guest_init (); -e820_reserve_resources (); +e820__reserve_resources ();e820_mark_nosave_regions (max_low_pfn); x86_init.resources.reserve_resources ();
arch/x86/pci/i386.c +1 -1
@@ -398,7 +398,7 @@ void __init pcibios_resource_survey(void)list_for_each_entry (bus, &pci_root_buses, node)pcibios_allocate_resources (bus,1 ); -e820_reserve_resources_late (); +e820__reserve_resources_late ();/* * Insert the IO APIC resources after PCI initialization has * occurred to handle IO APICS that are mapped in on a BAR in
Signature · 1 line
2.7.4
PATCH 48/50 x86/boot/e820: Rename e820_mark_nosave_regions() to e820__register_nosave_regions()
In reply to Ingo MolnarThis function is a minor misnomer: it is talking about 'marking' regions as nosave - while the hibernation API is called register_nosave_region() and the e820_mark_nosave_regions() is a wrapper around that functionality.
So name it to be in line with the API it is derived from.
( Rename e820_mark_nvs_memory() to e820__register_nvs_regions(), for similar
reasons. )
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 2 +- arch/x86/kernel/e820.c | 10 +++++----- arch/x86/kernel/setup.c | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-)
arch/x86/include/asm/e820/api.h +1 -1
@@ -36,7 +36,7 @@ extern char *e820__memory_setup_default(void);extern void e820__setup_pci_gap (void );extern void e820_reallocate_tables (void ); -extern void e820_mark_nosave_regions (unsigned long limit_pfn); +extern void e820__register_nosave_regions (unsigned long limit_pfn);/* * Returns true iff the specified range [start,end) is completely contained inside
arch/x86/kernel/e820.c +5 -5
@@ -690,15 +690,15 @@ void __init e820__memory_setup_extended(u64 phys_addr, u32 data_len)e820__print_table ("extended" ); } -/** +/* * Find the ranges of physical addresses that do not correspond to -* E820 RAM areas and mark the corresponding pages as 'nosave' for +* E820 RAM areas and register the corresponding pages as 'nosave' for * hibernation (32-bit) or software suspend and suspend to RAM (64-bit). * * This function requires the E820 map to be sorted and without any * overlapping entries. */ -void __init e820_mark_nosave_regions (unsigned long limit_pfn) +void __init e820__register_nosave_regions (unsigned long limit_pfn) {int i;unsigned long pfn =0 ;
@@ -724,7 +724,7 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn)* Register ACPI NVS memory regions, so that we can save/restore them during * hibernation and the subsequent resume: */ -static int __init e820_mark_nvs_memory (void ) +static int __init e820__register_nvs_regions (void ) {int i;
@@ -737,7 +737,7 @@ static int __init e820_mark_nvs_memory(void) return 0; } -core_initcall (e820_mark_nvs_memory); +core_initcall (e820__register_nvs_regions);#endif /*
arch/x86/kernel/setup.c +1 -1
@@ -1236,7 +1236,7 @@ void __init setup_arch(char **cmdline_p)kvm_guest_init ();e820__reserve_resources (); -e820_mark_nosave_regions (max_low_pfn); +e820__register_nosave_regions (max_low_pfn); x86_init.resources.reserve_resources ();
Signature · 1 line
2.7.4
PATCH 49/50 x86/boot/e820: Remove unnecessary #include's
In reply to Ingo MolnarA number of headers were included into e820.c unnecessarily - remove them.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/kernel/e820.c | 7 ------- 1 file changed, 7 deletions(-)
arch/x86/kernel/e820.c +0 -7
@@ -8,13 +8,8 @@* quirks and other tweaks, and feeds that into the generic Linux memory * allocation code routines via a platform independent interface (memblock, etc.). */ -#include <linux/kernel.h> -#include <linux/types.h> -#include <linux/init.h> #include <linux/crash_dump.h> -#include <linux/export.h> #include <linux/bootmem.h> -#include <linux/pfn.h> #include <linux/suspend.h> #include <linux/acpi.h> #include <linux/firmware-map.h>
@@ -22,9 +17,7 @@#include <linux/sort.h> #include <asm/e820/api.h> -#include <asm/proto.h> #include <asm/setup.h> -#include <asm/cpufeature.h> /* * We organize the E820 table into two main data structures:
Signature · 1 line
2.7.4
PATCH 50/50 x86/boot/e820: Rename the remaining E820 APIs to the e820__*() prefix
In reply to Ingo MolnarThree more renames left:
e820_end_of_ram_pfn() => e820__end_of_ram_pfn() e820_end_of_low_ram_pfn() => e820__end_of_low_ram_pfn() e820_reallocate_tables() => e820__reallocate_tables()
After this all E820 API calls are prefixed with "e820__", making it much easier to grep for E820 functionality in the kernel.
No change in functionality.
Cc Alex Thorlton <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Brian Gerst <[email protected]>
Cc Dan Williams <[email protected]>
Cc Denys Vlasenko <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Huang, Ying <[email protected]>
Cc Josh Poimboeuf <[email protected]>
Cc Juergen Gross <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul Jackson <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Rafael J. Wysocki <[email protected]>
Cc Tejun Heo <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Wei Yang <[email protected]>
Cc Yinghai Lu <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- arch/x86/include/asm/e820/api.h | 6 +++--- arch/x86/kernel/e820.c | 8 ++++---- arch/x86/kernel/setup.c | 6 +++--- arch/x86/mm/init.c | 2 +- 4 files changed, 11 insertions(+), 11 deletions(-)
arch/x86/include/asm/e820/api.h +3 -3
@@ -19,8 +19,8 @@ extern void e820__print_table(char *who);extern int e820__update_table (struct e820_table *table);extern void e820__update_table_print (void ); -extern unsigned long e820_end_of_ram_pfn (void ); -extern unsigned long e820_end_of_low_ram_pfn (void ); +extern unsigned long e820__end_of_ram_pfn (void ); +extern unsigned long e820__end_of_low_ram_pfn (void );extern u64 e820__memblock_alloc_reserved (u64 size,u64 align);extern void e820__memblock_setup (void );
@@ -35,7 +35,7 @@ extern void e820__memory_setup_extended(u64 phys_addr, u32 data_len);extern char *e820__memory_setup_default (void );extern void e820__setup_pci_gap (void ); -extern void e820_reallocate_tables (void ); +extern void e820__reallocate_tables (void );extern void e820__register_nosave_regions (unsigned long limit_pfn);/*
arch/x86/kernel/e820.c +4 -4
@@ -641,7 +641,7 @@ __init void e820__setup_pci_gap(void)* All functions which modify them are __init functions, which won't exist * after free_initmem(). */ -__init void e820_reallocate_tables (void ) +__init void e820__reallocate_tables (void ) {struct e820_table *n;int size;
@@ -803,12 +803,12 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn, enum e820_typereturn last_pfn; } -unsigned long __init e820_end_of_ram_pfn (void ) +unsigned long __init e820__end_of_ram_pfn (void ) {return e820_end_pfn (MAX_ARCH_PFN ,E820_TYPE_RAM ); } -unsigned long __init e820_end_of_low_ram_pfn (void ) +unsigned long __init e820__end_of_low_ram_pfn (void ) {return e820_end_pfn (1UL << (32 -PAGE_SHIFT ),E820_TYPE_RAM ); }
@@ -867,7 +867,7 @@ static int __init parse_memmap_one(char *p)* the real memory size before the original memory map is * reset. */ - saved_max_pfn =e820_end_of_ram_pfn (); + saved_max_pfn =e820__end_of_ram_pfn ();#endif e820_table->nr_entries =0 ; userdef =1 ;
arch/x86/kernel/setup.c +3 -3
@@ -1044,12 +1044,12 @@ void __init setup_arch(char **cmdline_p)* partially used pages are not usable - thus * we are rounding upwards: */ - max_pfn =e820_end_of_ram_pfn (); + max_pfn =e820__end_of_ram_pfn ();/* update e820 for memory not covered by WB MTRRs */ mtrr_bp_init ();if (mtrr_trim_uncached_memory (max_pfn)) - max_pfn =e820_end_of_ram_pfn (); + max_pfn =e820__end_of_ram_pfn (); max_possible_pfn = max_pfn;
@@ -1068,7 +1068,7 @@ void __init setup_arch(char **cmdline_p)/* How many end-of-memory variables you have, grandma! */ /* need this before calling reserve_initrd */ if (max_pfn > (1UL <<(32 -PAGE_SHIFT ))) - max_low_pfn =e820_end_of_low_ram_pfn (); + max_low_pfn =e820__end_of_low_ram_pfn ();else max_low_pfn = max_pfn;
arch/x86/mm/init.c +1 -1
@@ -701,7 +701,7 @@ void free_init_pages(char *what, unsigned long begin, unsigned long end)void __ref free_initmem (void ) { -e820_reallocate_tables (); +e820__reallocate_tables (); free_init_pages("unused kernel", (unsigned long)(&__init_begin),
Signature · 1 line
2.7.4