Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
dc009d92 EB |
2 | #ifndef LINUX_KEXEC_H |
3 | #define LINUX_KEXEC_H | |
4 | ||
cf2df639 GL |
5 | #define IND_DESTINATION_BIT 0 |
6 | #define IND_INDIRECTION_BIT 1 | |
7 | #define IND_DONE_BIT 2 | |
8 | #define IND_SOURCE_BIT 3 | |
9 | ||
10 | #define IND_DESTINATION (1 << IND_DESTINATION_BIT) | |
11 | #define IND_INDIRECTION (1 << IND_INDIRECTION_BIT) | |
12 | #define IND_DONE (1 << IND_DONE_BIT) | |
13 | #define IND_SOURCE (1 << IND_SOURCE_BIT) | |
b28c2ee8 | 14 | #define IND_FLAGS (IND_DESTINATION | IND_INDIRECTION | IND_DONE | IND_SOURCE) |
cf2df639 GL |
15 | |
16 | #if !defined(__ASSEMBLY__) | |
17 | ||
692f66f2 | 18 | #include <linux/crash_core.h> |
43546d86 | 19 | #include <asm/io.h> |
cade589f | 20 | #include <linux/range.h> |
43546d86 | 21 | |
607ca46e | 22 | #include <uapi/linux/kexec.h> |
c903dae8 | 23 | #include <linux/verification.h> |
29a5c67e | 24 | |
f05fa109 JZ |
25 | /* Location of a reserved region to hold the crash kernel. |
26 | */ | |
27 | extern struct resource crashk_res; | |
28 | extern struct resource crashk_low_res; | |
29 | extern note_buf_t __percpu *crash_notes; | |
30 | ||
2965faa5 | 31 | #ifdef CONFIG_KEXEC_CORE |
dc009d92 | 32 | #include <linux/list.h> |
dc009d92 | 33 | #include <linux/compat.h> |
9c15e852 | 34 | #include <linux/ioport.h> |
12db5562 | 35 | #include <linux/module.h> |
dc009d92 EB |
36 | #include <asm/kexec.h> |
37 | ||
38 | /* Verify architecture specific macros are defined */ | |
39 | ||
40 | #ifndef KEXEC_SOURCE_MEMORY_LIMIT | |
41 | #error KEXEC_SOURCE_MEMORY_LIMIT not defined | |
42 | #endif | |
43 | ||
44 | #ifndef KEXEC_DESTINATION_MEMORY_LIMIT | |
45 | #error KEXEC_DESTINATION_MEMORY_LIMIT not defined | |
46 | #endif | |
47 | ||
48 | #ifndef KEXEC_CONTROL_MEMORY_LIMIT | |
49 | #error KEXEC_CONTROL_MEMORY_LIMIT not defined | |
50 | #endif | |
51 | ||
7e01b5ac | 52 | #ifndef KEXEC_CONTROL_MEMORY_GFP |
dc5cccac | 53 | #define KEXEC_CONTROL_MEMORY_GFP (GFP_KERNEL | __GFP_NORETRY) |
7e01b5ac MS |
54 | #endif |
55 | ||
163f6876 HY |
56 | #ifndef KEXEC_CONTROL_PAGE_SIZE |
57 | #error KEXEC_CONTROL_PAGE_SIZE not defined | |
dc009d92 EB |
58 | #endif |
59 | ||
60 | #ifndef KEXEC_ARCH | |
61 | #error KEXEC_ARCH not defined | |
62 | #endif | |
63 | ||
3d214fae MH |
64 | #ifndef KEXEC_CRASH_CONTROL_MEMORY_LIMIT |
65 | #define KEXEC_CRASH_CONTROL_MEMORY_LIMIT KEXEC_CONTROL_MEMORY_LIMIT | |
66 | #endif | |
67 | ||
558df720 MH |
68 | #ifndef KEXEC_CRASH_MEM_ALIGN |
69 | #define KEXEC_CRASH_MEM_ALIGN PAGE_SIZE | |
70 | #endif | |
71 | ||
692f66f2 HB |
72 | #define KEXEC_CORE_NOTE_NAME CRASH_CORE_NOTE_NAME |
73 | ||
dc009d92 EB |
74 | /* |
75 | * This structure is used to hold the arguments that are used when loading | |
76 | * kernel binaries. | |
77 | */ | |
78 | ||
79 | typedef unsigned long kimage_entry_t; | |
dc009d92 | 80 | |
dc009d92 | 81 | struct kexec_segment { |
815d5704 VG |
82 | /* |
83 | * This pointer can point to user memory if kexec_load() system | |
84 | * call is used or will point to kernel memory if | |
85 | * kexec_file_load() system call is used. | |
86 | * | |
87 | * Use ->buf when expecting to deal with user memory and use ->kbuf | |
88 | * when expecting to deal with kernel memory. | |
89 | */ | |
90 | union { | |
91 | void __user *buf; | |
92 | void *kbuf; | |
93 | }; | |
dc009d92 | 94 | size_t bufsz; |
29a5c67e | 95 | unsigned long mem; |
dc009d92 EB |
96 | size_t memsz; |
97 | }; | |
98 | ||
99 | #ifdef CONFIG_COMPAT | |
100 | struct compat_kexec_segment { | |
101 | compat_uptr_t buf; | |
102 | compat_size_t bufsz; | |
103 | compat_ulong_t mem; /* User space sees this as a (void *) ... */ | |
104 | compat_size_t memsz; | |
105 | }; | |
106 | #endif | |
107 | ||
978e30c9 | 108 | #ifdef CONFIG_KEXEC_FILE |
12db5562 | 109 | struct purgatory_info { |
65c225d3 PR |
110 | /* |
111 | * Pointer to elf header at the beginning of kexec_purgatory. | |
112 | * Note: kexec_purgatory is read only | |
113 | */ | |
114 | const Elf_Ehdr *ehdr; | |
115 | /* | |
116 | * Temporary, modifiable buffer for sechdrs used for relocation. | |
117 | * This memory can be freed post image load. | |
118 | */ | |
12db5562 VG |
119 | Elf_Shdr *sechdrs; |
120 | /* | |
65c225d3 PR |
121 | * Temporary, modifiable buffer for stripped purgatory used for |
122 | * relocation. This memory can be freed post image load. | |
12db5562 VG |
123 | */ |
124 | void *purgatory_buf; | |
12db5562 VG |
125 | }; |
126 | ||
ee6ebeda PR |
127 | struct kimage; |
128 | ||
978e30c9 XP |
129 | typedef int (kexec_probe_t)(const char *kernel_buf, unsigned long kernel_size); |
130 | typedef void *(kexec_load_t)(struct kimage *image, char *kernel_buf, | |
131 | unsigned long kernel_len, char *initrd, | |
132 | unsigned long initrd_len, char *cmdline, | |
133 | unsigned long cmdline_len); | |
134 | typedef int (kexec_cleanup_t)(void *loader_data); | |
135 | ||
99d5cadf | 136 | #ifdef CONFIG_KEXEC_SIG |
978e30c9 XP |
137 | typedef int (kexec_verify_sig_t)(const char *kernel_buf, |
138 | unsigned long kernel_len); | |
139 | #endif | |
140 | ||
141 | struct kexec_file_ops { | |
142 | kexec_probe_t *probe; | |
143 | kexec_load_t *load; | |
144 | kexec_cleanup_t *cleanup; | |
99d5cadf | 145 | #ifdef CONFIG_KEXEC_SIG |
978e30c9 XP |
146 | kexec_verify_sig_t *verify_sig; |
147 | #endif | |
148 | }; | |
60fe3910 | 149 | |
9ec4ecef AT |
150 | extern const struct kexec_file_ops * const kexec_file_loaders[]; |
151 | ||
152 | int kexec_image_probe_default(struct kimage *image, void *buf, | |
153 | unsigned long buf_len); | |
92a98a2b | 154 | int kexec_image_post_load_cleanup_default(struct kimage *image); |
9ec4ecef | 155 | |
b6664ba4 AT |
156 | /* |
157 | * If kexec_buf.mem is set to this value, kexec_locate_mem_hole() | |
158 | * will try to allocate free memory. Arch may overwrite it. | |
159 | */ | |
160 | #ifndef KEXEC_BUF_MEM_UNKNOWN | |
161 | #define KEXEC_BUF_MEM_UNKNOWN 0 | |
162 | #endif | |
163 | ||
60fe3910 TJB |
164 | /** |
165 | * struct kexec_buf - parameters for finding a place for a buffer in memory | |
166 | * @image: kexec image in which memory to search. | |
167 | * @buffer: Contents which will be copied to the allocated memory. | |
168 | * @bufsz: Size of @buffer. | |
169 | * @mem: On return will have address of the buffer in memory. | |
170 | * @memsz: Size for the buffer in memory. | |
171 | * @buf_align: Minimum alignment needed. | |
172 | * @buf_min: The buffer can't be placed below this address. | |
173 | * @buf_max: The buffer can't be placed above this address. | |
174 | * @top_down: Allocate from top of memory. | |
175 | */ | |
176 | struct kexec_buf { | |
177 | struct kimage *image; | |
ec2b9bfa | 178 | void *buffer; |
60fe3910 TJB |
179 | unsigned long bufsz; |
180 | unsigned long mem; | |
181 | unsigned long memsz; | |
182 | unsigned long buf_align; | |
183 | unsigned long buf_min; | |
184 | unsigned long buf_max; | |
185 | bool top_down; | |
186 | }; | |
187 | ||
3be3f61d PR |
188 | int kexec_load_purgatory(struct kimage *image, struct kexec_buf *kbuf); |
189 | int kexec_purgatory_get_set_symbol(struct kimage *image, const char *name, | |
190 | void *buf, unsigned int size, | |
191 | bool get_value); | |
192 | void *kexec_purgatory_get_symbol_addr(struct kimage *image, const char *name); | |
65d9a9a6 NR |
193 | void *kexec_image_load_default(struct kimage *image); |
194 | ||
195 | #ifndef arch_kexec_kernel_image_probe | |
196 | static inline int | |
197 | arch_kexec_kernel_image_probe(struct kimage *image, void *buf, unsigned long buf_len) | |
198 | { | |
199 | return kexec_image_probe_default(image, buf, buf_len); | |
200 | } | |
201 | #endif | |
202 | ||
203 | #ifndef arch_kimage_file_post_load_cleanup | |
204 | static inline int arch_kimage_file_post_load_cleanup(struct kimage *image) | |
205 | { | |
206 | return kexec_image_post_load_cleanup_default(image); | |
207 | } | |
208 | #endif | |
209 | ||
210 | #ifndef arch_kexec_kernel_image_load | |
211 | static inline void *arch_kexec_kernel_image_load(struct kimage *image) | |
212 | { | |
213 | return kexec_image_load_default(image); | |
214 | } | |
215 | #endif | |
3be3f61d | 216 | |
c903dae8 CX |
217 | #ifdef CONFIG_KEXEC_SIG |
218 | #ifdef CONFIG_SIGNED_PE_FILE_VERIFICATION | |
219 | int kexec_kernel_verify_pe_sig(const char *kernel, unsigned long kernel_len); | |
220 | #endif | |
221 | #endif | |
222 | ||
ec2b9bfa | 223 | extern int kexec_add_buffer(struct kexec_buf *kbuf); |
e2e806f9 | 224 | int kexec_locate_mem_hole(struct kexec_buf *kbuf); |
babac4a8 | 225 | |
65d9a9a6 NR |
226 | #ifndef arch_kexec_locate_mem_hole |
227 | /** | |
228 | * arch_kexec_locate_mem_hole - Find free memory to place the segments. | |
229 | * @kbuf: Parameters for the memory search. | |
230 | * | |
231 | * On success, kbuf->mem will have the start address of the memory region found. | |
232 | * | |
233 | * Return: 0 on success, negative errno on error. | |
234 | */ | |
235 | static inline int arch_kexec_locate_mem_hole(struct kexec_buf *kbuf) | |
236 | { | |
237 | return kexec_locate_mem_hole(kbuf); | |
238 | } | |
239 | #endif | |
240 | ||
babac4a8 AT |
241 | /* Alignment required for elf header segment */ |
242 | #define ELF_CORE_HEADER_ALIGN 4096 | |
243 | ||
babac4a8 AT |
244 | struct crash_mem { |
245 | unsigned int max_nr_ranges; | |
246 | unsigned int nr_ranges; | |
cade589f | 247 | struct range ranges[]; |
babac4a8 AT |
248 | }; |
249 | ||
250 | extern int crash_exclude_mem_range(struct crash_mem *mem, | |
251 | unsigned long long mstart, | |
252 | unsigned long long mend); | |
4853f68d | 253 | extern int crash_prepare_elf64_headers(struct crash_mem *mem, int need_kernel_map, |
babac4a8 | 254 | void **addr, unsigned long *sz); |
3e35142e NR |
255 | |
256 | #ifndef arch_kexec_apply_relocations_add | |
257 | /* | |
258 | * arch_kexec_apply_relocations_add - apply relocations of type RELA | |
259 | * @pi: Purgatory to be relocated. | |
260 | * @section: Section relocations applying to. | |
261 | * @relsec: Section containing RELAs. | |
262 | * @symtab: Corresponding symtab. | |
263 | * | |
264 | * Return: 0 on success, negative errno on error. | |
265 | */ | |
266 | static inline int | |
267 | arch_kexec_apply_relocations_add(struct purgatory_info *pi, Elf_Shdr *section, | |
268 | const Elf_Shdr *relsec, const Elf_Shdr *symtab) | |
269 | { | |
270 | pr_err("RELA relocation unsupported.\n"); | |
271 | return -ENOEXEC; | |
272 | } | |
273 | #endif | |
274 | ||
275 | #ifndef arch_kexec_apply_relocations | |
276 | /* | |
277 | * arch_kexec_apply_relocations - apply relocations of type REL | |
278 | * @pi: Purgatory to be relocated. | |
279 | * @section: Section relocations applying to. | |
280 | * @relsec: Section containing RELs. | |
281 | * @symtab: Corresponding symtab. | |
282 | * | |
283 | * Return: 0 on success, negative errno on error. | |
284 | */ | |
285 | static inline int | |
286 | arch_kexec_apply_relocations(struct purgatory_info *pi, Elf_Shdr *section, | |
287 | const Elf_Shdr *relsec, const Elf_Shdr *symtab) | |
288 | { | |
289 | pr_err("REL relocation unsupported.\n"); | |
290 | return -ENOEXEC; | |
291 | } | |
292 | #endif | |
60fe3910 | 293 | #endif /* CONFIG_KEXEC_FILE */ |
978e30c9 | 294 | |
175fca3b SS |
295 | #ifdef CONFIG_KEXEC_ELF |
296 | struct kexec_elf_info { | |
297 | /* | |
298 | * Where the ELF binary contents are kept. | |
299 | * Memory managed by the user of the struct. | |
300 | */ | |
301 | const char *buffer; | |
302 | ||
303 | const struct elfhdr *ehdr; | |
304 | const struct elf_phdr *proghdrs; | |
175fca3b SS |
305 | }; |
306 | ||
307 | int kexec_build_elf_info(const char *buf, size_t len, struct elfhdr *ehdr, | |
308 | struct kexec_elf_info *elf_info); | |
309 | ||
310 | int kexec_elf_load(struct kimage *image, struct elfhdr *ehdr, | |
311 | struct kexec_elf_info *elf_info, | |
312 | struct kexec_buf *kbuf, | |
313 | unsigned long *lowest_load_addr); | |
314 | ||
315 | void kexec_free_elf_info(struct kexec_elf_info *elf_info); | |
316 | int kexec_elf_probe(const char *buf, unsigned long len); | |
317 | #endif | |
dc009d92 EB |
318 | struct kimage { |
319 | kimage_entry_t head; | |
320 | kimage_entry_t *entry; | |
321 | kimage_entry_t *last_entry; | |
322 | ||
dc009d92 EB |
323 | unsigned long start; |
324 | struct page *control_code_page; | |
3ab83521 | 325 | struct page *swap_page; |
1229384f | 326 | void *vmcoreinfo_data_copy; /* locates in the crash memory */ |
dc009d92 EB |
327 | |
328 | unsigned long nr_segments; | |
329 | struct kexec_segment segment[KEXEC_SEGMENT_MAX]; | |
330 | ||
331 | struct list_head control_pages; | |
332 | struct list_head dest_pages; | |
7d3e2bca | 333 | struct list_head unusable_pages; |
dc009d92 EB |
334 | |
335 | /* Address of next control page to allocate for crash kernels. */ | |
336 | unsigned long control_page; | |
337 | ||
338 | /* Flags to indicate special processing */ | |
339 | unsigned int type : 1; | |
340 | #define KEXEC_TYPE_DEFAULT 0 | |
341 | #define KEXEC_TYPE_CRASH 1 | |
3ab83521 | 342 | unsigned int preserve_context : 1; |
cb105258 VG |
343 | /* If set, we are using file mode kexec syscall */ |
344 | unsigned int file_mode:1; | |
92be3d6b HY |
345 | |
346 | #ifdef ARCH_HAS_KIMAGE_ARCH | |
347 | struct kimage_arch arch; | |
348 | #endif | |
cb105258 | 349 | |
978e30c9 | 350 | #ifdef CONFIG_KEXEC_FILE |
cb105258 VG |
351 | /* Additional fields for file based kexec syscall */ |
352 | void *kernel_buf; | |
353 | unsigned long kernel_buf_len; | |
354 | ||
355 | void *initrd_buf; | |
356 | unsigned long initrd_buf_len; | |
357 | ||
358 | char *cmdline_buf; | |
359 | unsigned long cmdline_buf_len; | |
360 | ||
361 | /* File operations provided by image loader */ | |
9ec4ecef | 362 | const struct kexec_file_ops *fops; |
cb105258 VG |
363 | |
364 | /* Image loader handling the kernel can store a pointer here */ | |
365 | void *image_loader_data; | |
12db5562 VG |
366 | |
367 | /* Information for loading purgatory */ | |
368 | struct purgatory_info purgatory_info; | |
978e30c9 | 369 | #endif |
f31e3386 LR |
370 | |
371 | #ifdef CONFIG_IMA_KEXEC | |
372 | /* Virtual address of IMA measurement buffer for kexec syscall */ | |
373 | void *ima_buffer; | |
0c605158 LR |
374 | |
375 | phys_addr_t ima_buffer_addr; | |
376 | size_t ima_buffer_size; | |
f31e3386 | 377 | #endif |
9336a5f6 LR |
378 | |
379 | /* Core ELF header buffer */ | |
380 | void *elf_headers; | |
381 | unsigned long elf_headers_sz; | |
382 | unsigned long elf_load_addr; | |
cb105258 | 383 | }; |
dc009d92 EB |
384 | |
385 | /* kexec interface functions */ | |
3ab83521 | 386 | extern void machine_kexec(struct kimage *image); |
dc009d92 EB |
387 | extern int machine_kexec_prepare(struct kimage *image); |
388 | extern void machine_kexec_cleanup(struct kimage *image); | |
3ab83521 | 389 | extern int kernel_kexec(void); |
72414d3f MS |
390 | extern struct page *kimage_alloc_control_pages(struct kimage *image, |
391 | unsigned int order); | |
0738eceb NR |
392 | |
393 | #ifndef machine_kexec_post_load | |
394 | static inline int machine_kexec_post_load(struct kimage *image) { return 0; } | |
395 | #endif | |
2596b6ae | 396 | |
7bbee5ca | 397 | extern void __crash_kexec(struct pt_regs *); |
6e274d14 AN |
398 | extern void crash_kexec(struct pt_regs *); |
399 | int kexec_should_crash(struct task_struct *); | |
21db79e8 | 400 | int kexec_crash_loaded(void); |
85916f81 | 401 | void crash_save_cpu(struct pt_regs *regs, int cpu); |
1229384f | 402 | extern int kimage_crash_copy_vmcoreinfo(struct kimage *image); |
fd59d231 | 403 | |
dc009d92 | 404 | extern struct kimage *kexec_image; |
c330dda9 | 405 | extern struct kimage *kexec_crash_image; |
7984754b | 406 | extern int kexec_load_disabled; |
dc009d92 | 407 | |
a7956113 ZN |
408 | #ifndef kexec_flush_icache_page |
409 | #define kexec_flush_icache_page(page) | |
410 | #endif | |
411 | ||
3ab83521 HY |
412 | /* List of defined/legal kexec flags */ |
413 | #ifndef CONFIG_KEXEC_JUMP | |
414 | #define KEXEC_FLAGS KEXEC_ON_CRASH | |
415 | #else | |
416 | #define KEXEC_FLAGS (KEXEC_ON_CRASH | KEXEC_PRESERVE_CONTEXT) | |
417 | #endif | |
dc009d92 | 418 | |
cb105258 VG |
419 | /* List of defined/legal kexec file flags */ |
420 | #define KEXEC_FILE_FLAGS (KEXEC_FILE_UNLOAD | KEXEC_FILE_ON_CRASH | \ | |
421 | KEXEC_FILE_NO_INITRAMFS) | |
422 | ||
4fc9bbf9 KA |
423 | /* flag to track if kexec reboot is in progress */ |
424 | extern bool kexec_in_progress; | |
425 | ||
06a7f711 | 426 | int crash_shrink_memory(unsigned long new_size); |
7bb5da0d | 427 | ssize_t crash_get_memory_size(void); |
a7956113 | 428 | |
0738eceb NR |
429 | #ifndef arch_kexec_protect_crashkres |
430 | /* | |
431 | * Protection mechanism for crashkernel reserved memory after | |
432 | * the kdump kernel is loaded. | |
433 | * | |
434 | * Provide an empty default implementation here -- architecture | |
435 | * code may override this | |
436 | */ | |
437 | static inline void arch_kexec_protect_crashkres(void) { } | |
438 | #endif | |
439 | ||
440 | #ifndef arch_kexec_unprotect_crashkres | |
441 | static inline void arch_kexec_unprotect_crashkres(void) { } | |
442 | #endif | |
a43cac0d | 443 | |
43546d86 RK |
444 | #ifndef page_to_boot_pfn |
445 | static inline unsigned long page_to_boot_pfn(struct page *page) | |
446 | { | |
447 | return page_to_pfn(page); | |
448 | } | |
449 | #endif | |
450 | ||
451 | #ifndef boot_pfn_to_page | |
452 | static inline struct page *boot_pfn_to_page(unsigned long boot_pfn) | |
453 | { | |
454 | return pfn_to_page(boot_pfn); | |
455 | } | |
456 | #endif | |
457 | ||
458 | #ifndef phys_to_boot_phys | |
459 | static inline unsigned long phys_to_boot_phys(phys_addr_t phys) | |
460 | { | |
461 | return phys; | |
462 | } | |
463 | #endif | |
464 | ||
465 | #ifndef boot_phys_to_phys | |
466 | static inline phys_addr_t boot_phys_to_phys(unsigned long boot_phys) | |
467 | { | |
468 | return boot_phys; | |
469 | } | |
470 | #endif | |
471 | ||
0738eceb NR |
472 | #ifndef crash_free_reserved_phys_range |
473 | static inline void crash_free_reserved_phys_range(unsigned long begin, unsigned long end) | |
474 | { | |
475 | unsigned long addr; | |
476 | ||
477 | for (addr = begin; addr < end; addr += PAGE_SIZE) | |
478 | free_reserved_page(boot_pfn_to_page(addr >> PAGE_SHIFT)); | |
479 | } | |
480 | #endif | |
481 | ||
43546d86 RK |
482 | static inline unsigned long virt_to_boot_phys(void *addr) |
483 | { | |
484 | return phys_to_boot_phys(__pa((unsigned long)addr)); | |
485 | } | |
486 | ||
487 | static inline void *boot_phys_to_virt(unsigned long entry) | |
488 | { | |
489 | return phys_to_virt(boot_phys_to_phys(entry)); | |
490 | } | |
491 | ||
bba4ed01 TL |
492 | #ifndef arch_kexec_post_alloc_pages |
493 | static inline int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gfp_t gfp) { return 0; } | |
494 | #endif | |
495 | ||
496 | #ifndef arch_kexec_pre_free_pages | |
497 | static inline void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages) { } | |
498 | #endif | |
499 | ||
2965faa5 | 500 | #else /* !CONFIG_KEXEC_CORE */ |
6e274d14 AN |
501 | struct pt_regs; |
502 | struct task_struct; | |
7bbee5ca | 503 | static inline void __crash_kexec(struct pt_regs *regs) { } |
6e274d14 AN |
504 | static inline void crash_kexec(struct pt_regs *regs) { } |
505 | static inline int kexec_should_crash(struct task_struct *p) { return 0; } | |
21db79e8 | 506 | static inline int kexec_crash_loaded(void) { return 0; } |
2b94ed24 | 507 | #define kexec_in_progress false |
2965faa5 | 508 | #endif /* CONFIG_KEXEC_CORE */ |
cf2df639 | 509 | |
af16df54 CX |
510 | #ifdef CONFIG_KEXEC_SIG |
511 | void set_kexec_sig_enforced(void); | |
512 | #else | |
513 | static inline void set_kexec_sig_enforced(void) {} | |
514 | #endif | |
515 | ||
cf2df639 GL |
516 | #endif /* !defined(__ASSEBMLY__) */ |
517 | ||
dc009d92 | 518 | #endif /* LINUX_KEXEC_H */ |