Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef LINUX_KEXEC_H
3#define LINUX_KEXEC_H
4
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)
14#define IND_FLAGS (IND_DESTINATION | IND_INDIRECTION | IND_DONE | IND_SOURCE)
15
16#if !defined(__ASSEMBLY__)
17
18#include <linux/crash_core.h>
19#include <asm/io.h>
20#include <linux/range.h>
21
22#include <uapi/linux/kexec.h>
23#include <linux/verification.h>
24
25/* Location of a reserved region to hold the crash kernel.
26 */
27extern struct resource crashk_res;
28extern struct resource crashk_low_res;
29extern note_buf_t __percpu *crash_notes;
30
31#ifdef CONFIG_KEXEC_CORE
32#include <linux/list.h>
33#include <linux/compat.h>
34#include <linux/ioport.h>
35#include <linux/module.h>
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
52#ifndef KEXEC_CONTROL_MEMORY_GFP
53#define KEXEC_CONTROL_MEMORY_GFP (GFP_KERNEL | __GFP_NORETRY)
54#endif
55
56#ifndef KEXEC_CONTROL_PAGE_SIZE
57#error KEXEC_CONTROL_PAGE_SIZE not defined
58#endif
59
60#ifndef KEXEC_ARCH
61#error KEXEC_ARCH not defined
62#endif
63
64#ifndef KEXEC_CRASH_CONTROL_MEMORY_LIMIT
65#define KEXEC_CRASH_CONTROL_MEMORY_LIMIT KEXEC_CONTROL_MEMORY_LIMIT
66#endif
67
68#ifndef KEXEC_CRASH_MEM_ALIGN
69#define KEXEC_CRASH_MEM_ALIGN PAGE_SIZE
70#endif
71
72#define KEXEC_CORE_NOTE_NAME CRASH_CORE_NOTE_NAME
73
74/*
75 * This structure is used to hold the arguments that are used when loading
76 * kernel binaries.
77 */
78
79typedef unsigned long kimage_entry_t;
80
81struct kexec_segment {
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 };
94 size_t bufsz;
95 unsigned long mem;
96 size_t memsz;
97};
98
99#ifdef CONFIG_COMPAT
100struct 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
108#ifdef CONFIG_KEXEC_FILE
109struct purgatory_info {
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 */
119 Elf_Shdr *sechdrs;
120 /*
121 * Temporary, modifiable buffer for stripped purgatory used for
122 * relocation. This memory can be freed post image load.
123 */
124 void *purgatory_buf;
125};
126
127struct kimage;
128
129typedef int (kexec_probe_t)(const char *kernel_buf, unsigned long kernel_size);
130typedef 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);
134typedef int (kexec_cleanup_t)(void *loader_data);
135
136#ifdef CONFIG_KEXEC_SIG
137typedef int (kexec_verify_sig_t)(const char *kernel_buf,
138 unsigned long kernel_len);
139#endif
140
141struct kexec_file_ops {
142 kexec_probe_t *probe;
143 kexec_load_t *load;
144 kexec_cleanup_t *cleanup;
145#ifdef CONFIG_KEXEC_SIG
146 kexec_verify_sig_t *verify_sig;
147#endif
148};
149
150extern const struct kexec_file_ops * const kexec_file_loaders[];
151
152int kexec_image_probe_default(struct kimage *image, void *buf,
153 unsigned long buf_len);
154int kexec_image_post_load_cleanup_default(struct kimage *image);
155
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
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 */
176struct kexec_buf {
177 struct kimage *image;
178 void *buffer;
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
188int kexec_load_purgatory(struct kimage *image, struct kexec_buf *kbuf);
189int kexec_purgatory_get_set_symbol(struct kimage *image, const char *name,
190 void *buf, unsigned int size,
191 bool get_value);
192void *kexec_purgatory_get_symbol_addr(struct kimage *image, const char *name);
193void *kexec_image_load_default(struct kimage *image);
194
195#ifndef arch_kexec_kernel_image_probe
196static inline int
197arch_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
204static 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
211static inline void *arch_kexec_kernel_image_load(struct kimage *image)
212{
213 return kexec_image_load_default(image);
214}
215#endif
216
217#ifdef CONFIG_KEXEC_SIG
218#ifdef CONFIG_SIGNED_PE_FILE_VERIFICATION
219int kexec_kernel_verify_pe_sig(const char *kernel, unsigned long kernel_len);
220#endif
221#endif
222
223extern int kexec_add_buffer(struct kexec_buf *kbuf);
224int kexec_locate_mem_hole(struct kexec_buf *kbuf);
225
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 */
235static inline int arch_kexec_locate_mem_hole(struct kexec_buf *kbuf)
236{
237 return kexec_locate_mem_hole(kbuf);
238}
239#endif
240
241/* Alignment required for elf header segment */
242#define ELF_CORE_HEADER_ALIGN 4096
243
244struct crash_mem {
245 unsigned int max_nr_ranges;
246 unsigned int nr_ranges;
247 struct range ranges[];
248};
249
250extern int crash_exclude_mem_range(struct crash_mem *mem,
251 unsigned long long mstart,
252 unsigned long long mend);
253extern int crash_prepare_elf64_headers(struct crash_mem *mem, int need_kernel_map,
254 void **addr, unsigned long *sz);
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 */
266static inline int
267arch_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 */
285static inline int
286arch_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
293#endif /* CONFIG_KEXEC_FILE */
294
295#ifdef CONFIG_KEXEC_ELF
296struct 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;
305};
306
307int kexec_build_elf_info(const char *buf, size_t len, struct elfhdr *ehdr,
308 struct kexec_elf_info *elf_info);
309
310int 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
315void kexec_free_elf_info(struct kexec_elf_info *elf_info);
316int kexec_elf_probe(const char *buf, unsigned long len);
317#endif
318struct kimage {
319 kimage_entry_t head;
320 kimage_entry_t *entry;
321 kimage_entry_t *last_entry;
322
323 unsigned long start;
324 struct page *control_code_page;
325 struct page *swap_page;
326 void *vmcoreinfo_data_copy; /* locates in the crash memory */
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;
333 struct list_head unusable_pages;
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
342 unsigned int preserve_context : 1;
343 /* If set, we are using file mode kexec syscall */
344 unsigned int file_mode:1;
345
346#ifdef ARCH_HAS_KIMAGE_ARCH
347 struct kimage_arch arch;
348#endif
349
350#ifdef CONFIG_KEXEC_FILE
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 */
362 const struct kexec_file_ops *fops;
363
364 /* Image loader handling the kernel can store a pointer here */
365 void *image_loader_data;
366
367 /* Information for loading purgatory */
368 struct purgatory_info purgatory_info;
369#endif
370
371#ifdef CONFIG_IMA_KEXEC
372 /* Virtual address of IMA measurement buffer for kexec syscall */
373 void *ima_buffer;
374
375 phys_addr_t ima_buffer_addr;
376 size_t ima_buffer_size;
377#endif
378
379 /* Core ELF header buffer */
380 void *elf_headers;
381 unsigned long elf_headers_sz;
382 unsigned long elf_load_addr;
383};
384
385/* kexec interface functions */
386extern void machine_kexec(struct kimage *image);
387extern int machine_kexec_prepare(struct kimage *image);
388extern void machine_kexec_cleanup(struct kimage *image);
389extern int kernel_kexec(void);
390extern struct page *kimage_alloc_control_pages(struct kimage *image,
391 unsigned int order);
392
393#ifndef machine_kexec_post_load
394static inline int machine_kexec_post_load(struct kimage *image) { return 0; }
395#endif
396
397extern void __crash_kexec(struct pt_regs *);
398extern void crash_kexec(struct pt_regs *);
399int kexec_should_crash(struct task_struct *);
400int kexec_crash_loaded(void);
401void crash_save_cpu(struct pt_regs *regs, int cpu);
402extern int kimage_crash_copy_vmcoreinfo(struct kimage *image);
403
404extern struct kimage *kexec_image;
405extern struct kimage *kexec_crash_image;
406
407bool kexec_load_permitted(int kexec_image_type);
408
409#ifndef kexec_flush_icache_page
410#define kexec_flush_icache_page(page)
411#endif
412
413/* List of defined/legal kexec flags */
414#ifndef CONFIG_KEXEC_JUMP
415#define KEXEC_FLAGS KEXEC_ON_CRASH
416#else
417#define KEXEC_FLAGS (KEXEC_ON_CRASH | KEXEC_PRESERVE_CONTEXT)
418#endif
419
420/* List of defined/legal kexec file flags */
421#define KEXEC_FILE_FLAGS (KEXEC_FILE_UNLOAD | KEXEC_FILE_ON_CRASH | \
422 KEXEC_FILE_NO_INITRAMFS)
423
424/* flag to track if kexec reboot is in progress */
425extern bool kexec_in_progress;
426
427int crash_shrink_memory(unsigned long new_size);
428ssize_t crash_get_memory_size(void);
429
430#ifndef arch_kexec_protect_crashkres
431/*
432 * Protection mechanism for crashkernel reserved memory after
433 * the kdump kernel is loaded.
434 *
435 * Provide an empty default implementation here -- architecture
436 * code may override this
437 */
438static inline void arch_kexec_protect_crashkres(void) { }
439#endif
440
441#ifndef arch_kexec_unprotect_crashkres
442static inline void arch_kexec_unprotect_crashkres(void) { }
443#endif
444
445#ifndef page_to_boot_pfn
446static inline unsigned long page_to_boot_pfn(struct page *page)
447{
448 return page_to_pfn(page);
449}
450#endif
451
452#ifndef boot_pfn_to_page
453static inline struct page *boot_pfn_to_page(unsigned long boot_pfn)
454{
455 return pfn_to_page(boot_pfn);
456}
457#endif
458
459#ifndef phys_to_boot_phys
460static inline unsigned long phys_to_boot_phys(phys_addr_t phys)
461{
462 return phys;
463}
464#endif
465
466#ifndef boot_phys_to_phys
467static inline phys_addr_t boot_phys_to_phys(unsigned long boot_phys)
468{
469 return boot_phys;
470}
471#endif
472
473#ifndef crash_free_reserved_phys_range
474static inline void crash_free_reserved_phys_range(unsigned long begin, unsigned long end)
475{
476 unsigned long addr;
477
478 for (addr = begin; addr < end; addr += PAGE_SIZE)
479 free_reserved_page(boot_pfn_to_page(addr >> PAGE_SHIFT));
480}
481#endif
482
483static inline unsigned long virt_to_boot_phys(void *addr)
484{
485 return phys_to_boot_phys(__pa((unsigned long)addr));
486}
487
488static inline void *boot_phys_to_virt(unsigned long entry)
489{
490 return phys_to_virt(boot_phys_to_phys(entry));
491}
492
493#ifndef arch_kexec_post_alloc_pages
494static inline int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gfp_t gfp) { return 0; }
495#endif
496
497#ifndef arch_kexec_pre_free_pages
498static inline void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages) { }
499#endif
500
501#else /* !CONFIG_KEXEC_CORE */
502struct pt_regs;
503struct task_struct;
504static inline void __crash_kexec(struct pt_regs *regs) { }
505static inline void crash_kexec(struct pt_regs *regs) { }
506static inline int kexec_should_crash(struct task_struct *p) { return 0; }
507static inline int kexec_crash_loaded(void) { return 0; }
508#define kexec_in_progress false
509#endif /* CONFIG_KEXEC_CORE */
510
511#ifdef CONFIG_KEXEC_SIG
512void set_kexec_sig_enforced(void);
513#else
514static inline void set_kexec_sig_enforced(void) {}
515#endif
516
517#endif /* !defined(__ASSEBMLY__) */
518
519#endif /* LINUX_KEXEC_H */