~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/include/asm/efi.h

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 #ifndef _ASM_X86_EFI_H
  3 #define _ASM_X86_EFI_H
  4 
  5 #include <asm/fpu/api.h>
  6 #include <asm/pgtable.h>
  7 #include <asm/processor-flags.h>
  8 #include <asm/tlb.h>
  9 #include <asm/nospec-branch.h>
 10 #include <asm/mmu_context.h>
 11 #include <linux/build_bug.h>
 12 
 13 /*
 14  * We map the EFI regions needed for runtime services non-contiguously,
 15  * with preserved alignment on virtual addresses starting from -4G down
 16  * for a total max space of 64G. This way, we provide for stable runtime
 17  * services addresses across kernels so that a kexec'd kernel can still
 18  * use them.
 19  *
 20  * This is the main reason why we're doing stable VA mappings for RT
 21  * services.
 22  *
 23  * SGI UV1 machines are known to be incompatible with this scheme, so we
 24  * provide an opt-out for these machines via a DMI quirk that sets the
 25  * attribute below.
 26  */
 27 #define EFI_UV1_MEMMAP         EFI_ARCH_1
 28 
 29 static inline bool efi_have_uv1_memmap(void)
 30 {
 31         return IS_ENABLED(CONFIG_X86_UV) && efi_enabled(EFI_UV1_MEMMAP);
 32 }
 33 
 34 #define EFI32_LOADER_SIGNATURE  "EL32"
 35 #define EFI64_LOADER_SIGNATURE  "EL64"
 36 
 37 #define MAX_CMDLINE_ADDRESS     UINT_MAX
 38 
 39 #define ARCH_EFI_IRQ_FLAGS_MASK X86_EFLAGS_IF
 40 
 41 /*
 42  * The EFI services are called through variadic functions in many cases. These
 43  * functions are implemented in assembler and support only a fixed number of
 44  * arguments. The macros below allows us to check at build time that we don't
 45  * try to call them with too many arguments.
 46  *
 47  * __efi_nargs() will return the number of arguments if it is 7 or less, and
 48  * cause a BUILD_BUG otherwise. The limitations of the C preprocessor make it
 49  * impossible to calculate the exact number of arguments beyond some
 50  * pre-defined limit. The maximum number of arguments currently supported by
 51  * any of the thunks is 7, so this is good enough for now and can be extended
 52  * in the obvious way if we ever need more.
 53  */
 54 
 55 #define __efi_nargs(...) __efi_nargs_(__VA_ARGS__)
 56 #define __efi_nargs_(...) __efi_nargs__(0, ##__VA_ARGS__,       \
 57         __efi_arg_sentinel(7), __efi_arg_sentinel(6),           \
 58         __efi_arg_sentinel(5), __efi_arg_sentinel(4),           \
 59         __efi_arg_sentinel(3), __efi_arg_sentinel(2),           \
 60         __efi_arg_sentinel(1), __efi_arg_sentinel(0))
 61 #define __efi_nargs__(_0, _1, _2, _3, _4, _5, _6, _7, n, ...)   \
 62         __take_second_arg(n,                                    \
 63                 ({ BUILD_BUG_ON_MSG(1, "__efi_nargs limit exceeded"); 8; }))
 64 #define __efi_arg_sentinel(n) , n
 65 
 66 /*
 67  * __efi_nargs_check(f, n, ...) will cause a BUILD_BUG if the ellipsis
 68  * represents more than n arguments.
 69  */
 70 
 71 #define __efi_nargs_check(f, n, ...)                                    \
 72         __efi_nargs_check_(f, __efi_nargs(__VA_ARGS__), n)
 73 #define __efi_nargs_check_(f, p, n) __efi_nargs_check__(f, p, n)
 74 #define __efi_nargs_check__(f, p, n) ({                                 \
 75         BUILD_BUG_ON_MSG(                                               \
 76                 (p) > (n),                                              \
 77                 #f " called with too many arguments (" #p ">" #n ")");  \
 78 })
 79 
 80 #ifdef CONFIG_X86_32
 81 #define arch_efi_call_virt_setup()                                      \
 82 ({                                                                      \
 83         kernel_fpu_begin();                                             \
 84         firmware_restrict_branch_speculation_start();                   \
 85 })
 86 
 87 #define arch_efi_call_virt_teardown()                                   \
 88 ({                                                                      \
 89         firmware_restrict_branch_speculation_end();                     \
 90         kernel_fpu_end();                                               \
 91 })
 92 
 93 
 94 #define arch_efi_call_virt(p, f, args...)       p->f(args)
 95 
 96 #define efi_ioremap(addr, size, type, attr)     ioremap_cache(addr, size)
 97 
 98 #else /* !CONFIG_X86_32 */
 99 
100 #define EFI_LOADER_SIGNATURE    "EL64"
101 
102 extern asmlinkage u64 __efi_call(void *fp, ...);
103 
104 #define efi_call(...) ({                                                \
105         __efi_nargs_check(efi_call, 7, __VA_ARGS__);                    \
106         __efi_call(__VA_ARGS__);                                        \
107 })
108 
109 /*
110  * struct efi_scratch - Scratch space used while switching to/from efi_mm
111  * @phys_stack: stack used during EFI Mixed Mode
112  * @prev_mm:    store/restore stolen mm_struct while switching to/from efi_mm
113  */
114 struct efi_scratch {
115         u64                     phys_stack;
116         struct mm_struct        *prev_mm;
117 } __packed;
118 
119 #define arch_efi_call_virt_setup()                                      \
120 ({                                                                      \
121         efi_sync_low_kernel_mappings();                                 \
122         kernel_fpu_begin();                                             \
123         firmware_restrict_branch_speculation_start();                   \
124                                                                         \
125         if (!efi_have_uv1_memmap())                                     \
126                 efi_switch_mm(&efi_mm);                                 \
127 })
128 
129 #define arch_efi_call_virt(p, f, args...)                               \
130         efi_call((void *)p->f, args)                                    \
131 
132 #define arch_efi_call_virt_teardown()                                   \
133 ({                                                                      \
134         if (!efi_have_uv1_memmap())                                     \
135                 efi_switch_mm(efi_scratch.prev_mm);                     \
136                                                                         \
137         firmware_restrict_branch_speculation_end();                     \
138         kernel_fpu_end();                                               \
139 })
140 
141 extern void __iomem *__init efi_ioremap(unsigned long addr, unsigned long size,
142                                         u32 type, u64 attribute);
143 
144 #ifdef CONFIG_KASAN
145 /*
146  * CONFIG_KASAN may redefine memset to __memset.  __memset function is present
147  * only in kernel binary.  Since the EFI stub linked into a separate binary it
148  * doesn't have __memset().  So we should use standard memset from
149  * arch/x86/boot/compressed/string.c.  The same applies to memcpy and memmove.
150  */
151 #undef memcpy
152 #undef memset
153 #undef memmove
154 #endif
155 
156 #endif /* CONFIG_X86_32 */
157 
158 extern struct efi_scratch efi_scratch;
159 extern void __init efi_set_executable(efi_memory_desc_t *md, bool executable);
160 extern int __init efi_memblock_x86_reserve_range(void);
161 extern void __init efi_print_memmap(void);
162 extern void __init efi_memory_uc(u64 addr, unsigned long size);
163 extern void __init efi_map_region(efi_memory_desc_t *md);
164 extern void __init efi_map_region_fixed(efi_memory_desc_t *md);
165 extern void efi_sync_low_kernel_mappings(void);
166 extern int __init efi_alloc_page_tables(void);
167 extern int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages);
168 extern void __init old_map_region(efi_memory_desc_t *md);
169 extern void __init runtime_code_page_mkexec(void);
170 extern void __init efi_runtime_update_mappings(void);
171 extern void __init efi_dump_pagetable(void);
172 extern void __init efi_apply_memmap_quirks(void);
173 extern int __init efi_reuse_config(u64 tables, int nr_tables);
174 extern void efi_delete_dummy_variable(void);
175 extern void efi_switch_mm(struct mm_struct *mm);
176 extern void efi_recover_from_page_fault(unsigned long phys_addr);
177 extern void efi_free_boot_services(void);
178 extern pgd_t * __init efi_uv1_memmap_phys_prolog(void);
179 extern void __init efi_uv1_memmap_phys_epilog(pgd_t *save_pgd);
180 
181 struct efi_setup_data {
182         u64 fw_vendor;
183         u64 runtime;
184         u64 tables;
185         u64 smbios;
186         u64 reserved[8];
187 };
188 
189 extern u64 efi_setup;
190 
191 #ifdef CONFIG_EFI
192 extern efi_status_t __efi64_thunk(u32, ...);
193 
194 #define efi64_thunk(...) ({                                             \
195         __efi_nargs_check(efi64_thunk, 6, __VA_ARGS__);                 \
196         __efi64_thunk(__VA_ARGS__);                                     \
197 })
198 
199 static inline bool efi_is_mixed(void)
200 {
201         if (!IS_ENABLED(CONFIG_EFI_MIXED))
202                 return false;
203         return IS_ENABLED(CONFIG_X86_64) && !efi_enabled(EFI_64BIT);
204 }
205 
206 static inline bool efi_runtime_supported(void)
207 {
208         if (IS_ENABLED(CONFIG_X86_64) == efi_enabled(EFI_64BIT))
209                 return true;
210 
211         return IS_ENABLED(CONFIG_EFI_MIXED);
212 }
213 
214 extern void parse_efi_setup(u64 phys_addr, u32 data_len);
215 
216 extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt);
217 
218 extern void efi_thunk_runtime_setup(void);
219 efi_status_t efi_set_virtual_address_map(unsigned long memory_map_size,
220                                          unsigned long descriptor_size,
221                                          u32 descriptor_version,
222                                          efi_memory_desc_t *virtual_map);
223 
224 /* arch specific definitions used by the stub code */
225 
226 __attribute_const__ bool efi_is_64bit(void);
227 
228 static inline bool efi_is_native(void)
229 {
230         if (!IS_ENABLED(CONFIG_X86_64))
231                 return true;
232         if (!IS_ENABLED(CONFIG_EFI_MIXED))
233                 return true;
234         return efi_is_64bit();
235 }
236 
237 #define efi_mixed_mode_cast(attr)                                       \
238         __builtin_choose_expr(                                          \
239                 __builtin_types_compatible_p(u32, __typeof__(attr)),    \
240                         (unsigned long)(attr), (attr))
241 
242 #define efi_table_attr(inst, attr)                                      \
243         (efi_is_native()                                                \
244                 ? inst->attr                                            \
245                 : (__typeof__(inst->attr))                              \
246                         efi_mixed_mode_cast(inst->mixed_mode.attr))
247 
248 /*
249  * The following macros allow translating arguments if necessary from native to
250  * mixed mode. The use case for this is to initialize the upper 32 bits of
251  * output parameters, and where the 32-bit method requires a 64-bit argument,
252  * which must be split up into two arguments to be thunked properly.
253  *
254  * As examples, the AllocatePool boot service returns the address of the
255  * allocation, but it will not set the high 32 bits of the address. To ensure
256  * that the full 64-bit address is initialized, we zero-init the address before
257  * calling the thunk.
258  *
259  * The FreePages boot service takes a 64-bit physical address even in 32-bit
260  * mode. For the thunk to work correctly, a native 64-bit call of
261  *      free_pages(addr, size)
262  * must be translated to
263  *      efi64_thunk(free_pages, addr & U32_MAX, addr >> 32, size)
264  * so that the two 32-bit halves of addr get pushed onto the stack separately.
265  */
266 
267 static inline void *efi64_zero_upper(void *p)
268 {
269         ((u32 *)p)[1] = 0;
270         return p;
271 }
272 
273 #define __efi64_argmap_free_pages(addr, size)                           \
274         ((addr), 0, (size))
275 
276 #define __efi64_argmap_get_memory_map(mm_size, mm, key, size, ver)      \
277         ((mm_size), (mm), efi64_zero_upper(key), efi64_zero_upper(size), (ver))
278 
279 #define __efi64_argmap_allocate_pool(type, size, buffer)                \
280         ((type), (size), efi64_zero_upper(buffer))
281 
282 #define __efi64_argmap_handle_protocol(handle, protocol, interface)     \
283         ((handle), (protocol), efi64_zero_upper(interface))
284 
285 #define __efi64_argmap_locate_protocol(protocol, reg, interface)        \
286         ((protocol), (reg), efi64_zero_upper(interface))
287 
288 /* PCI I/O */
289 #define __efi64_argmap_get_location(protocol, seg, bus, dev, func)      \
290         ((protocol), efi64_zero_upper(seg), efi64_zero_upper(bus),      \
291          efi64_zero_upper(dev), efi64_zero_upper(func))
292 
293 /*
294  * The macros below handle the plumbing for the argument mapping. To add a
295  * mapping for a specific EFI method, simply define a macro
296  * __efi64_argmap_<method name>, following the examples above.
297  */
298 
299 #define __efi64_thunk_map(inst, func, ...)                              \
300         efi64_thunk(inst->mixed_mode.func,                              \
301                 __efi64_argmap(__efi64_argmap_ ## func(__VA_ARGS__),    \
302                                (__VA_ARGS__)))
303 
304 #define __efi64_argmap(mapped, args)                                    \
305         __PASTE(__efi64_argmap__, __efi_nargs(__efi_eat mapped))(mapped, args)
306 #define __efi64_argmap__0(mapped, args) __efi_eval mapped
307 #define __efi64_argmap__1(mapped, args) __efi_eval args
308 
309 #define __efi_eat(...)
310 #define __efi_eval(...) __VA_ARGS__
311 
312 /* The three macros below handle dispatching via the thunk if needed */
313 
314 #define efi_call_proto(inst, func, ...)                                 \
315         (efi_is_native()                                                \
316                 ? inst->func(inst, ##__VA_ARGS__)                       \
317                 : __efi64_thunk_map(inst, func, inst, ##__VA_ARGS__))
318 
319 #define efi_bs_call(func, ...)                                          \
320         (efi_is_native()                                                \
321                 ? efi_system_table()->boottime->func(__VA_ARGS__)       \
322                 : __efi64_thunk_map(efi_table_attr(efi_system_table(),  \
323                                 boottime), func, __VA_ARGS__))
324 
325 #define efi_rt_call(func, ...)                                          \
326         (efi_is_native()                                                \
327                 ? efi_system_table()->runtime->func(__VA_ARGS__)        \
328                 : __efi64_thunk_map(efi_table_attr(efi_system_table(),  \
329                                 runtime), func, __VA_ARGS__))
330 
331 extern bool efi_reboot_required(void);
332 extern bool efi_is_table_address(unsigned long phys_addr);
333 
334 extern void efi_find_mirror(void);
335 extern void efi_reserve_boot_services(void);
336 #else
337 static inline void parse_efi_setup(u64 phys_addr, u32 data_len) {}
338 static inline bool efi_reboot_required(void)
339 {
340         return false;
341 }
342 static inline  bool efi_is_table_address(unsigned long phys_addr)
343 {
344         return false;
345 }
346 static inline void efi_find_mirror(void)
347 {
348 }
349 static inline void efi_reserve_boot_services(void)
350 {
351 }
352 #endif /* CONFIG_EFI */
353 
354 #ifdef CONFIG_EFI_FAKE_MEMMAP
355 extern void __init efi_fake_memmap_early(void);
356 #else
357 static inline void efi_fake_memmap_early(void)
358 {
359 }
360 #endif
361 
362 #endif /* _ASM_X86_EFI_H */
363 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp