enable docker ppp

hc

2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87

 kernel/arch/x86/kernel/crash.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * Architecture specific (i386/x86_64) functions for kexec based crash dumps.
3
4
  *
..
..
@@ -23,6 +24,7 @@
23
24
 #include <linux/export.h>
24
25
 #include <linux/slab.h>
25
26
 #include <linux/vmalloc.h>
27
+#include <linux/memblock.h>
26
28
 
27
29
 #include <asm/processor.h>
28
30
 #include <asm/hardirq.h>
..
..
@@ -37,6 +39,8 @@
37
39
 #include <asm/reboot.h>
38
40
 #include <asm/virtext.h>
39
41
 #include <asm/intel_pt.h>
42
+#include <asm/crash.h>
43
+#include <asm/cmdline.h>
40
44
 
41
45
 /* Used while preparing memory map entries for second kernel */
42
46
 struct crash_memmap_data {
..
..
@@ -54,7 +58,6 @@
54
58
  */
55
59
 crash_vmclear_fn __rcu *crash_vmclear_loaded_vmcss = NULL;
56
60
 EXPORT_SYMBOL_GPL(crash_vmclear_loaded_vmcss);
57
-unsigned long crash_zero_bytes;
58
61
 
59
62
 static inline void cpu_crash_vmclear_loaded_vmcss(void)
60
63
 {
..
..
@@ -67,18 +70,23 @@
67
70
 	rcu_read_unlock();
68
71
 }
69
72
 
73
+/*
74
+ * When the crashkernel option is specified, only use the low
75
+ * 1M for the real mode trampoline.
76
+ */
77
+void __init crash_reserve_low_1M(void)
78
+{
79
+	if (cmdline_find_option(boot_command_line, "crashkernel", NULL, 0) < 0)
80
+		return;
81
+
82
+	memblock_reserve(0, 1<<20);
83
+	pr_info("Reserving the low 1M of memory for crashkernel\n");
84
+}
85
+
70
86
 #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC)
71
87
 
72
88
 static void kdump_nmi_callback(int cpu, struct pt_regs *regs)
73
89
 {
74
-#ifdef CONFIG_X86_32
75
-	struct pt_regs fixed_regs;
76
-
77
-	if (!user_mode(regs)) {
78
-		crash_fixup_ss_esp(&fixed_regs, regs);
79
-		regs = &fixed_regs;
80
-	}
81
-#endif
82
90
 	crash_save_cpu(regs, cpu);
83
91
 
84
92
 	/*
..
..
@@ -179,6 +187,7 @@
179
187
 }
180
188
 
181
189
 #ifdef CONFIG_KEXEC_FILE
190
+
182
191
 static int get_nr_ram_ranges_callback(struct resource *res, void *arg)
183
192
 {
184
193
 	unsigned int *nr_ranges = arg;
..
..
@@ -193,8 +202,7 @@
193
202
 	unsigned int nr_ranges = 0;
194
203
 	struct crash_mem *cmem;
195
204
 
196
-	walk_system_ram_res(0, -1, &nr_ranges,
197
-				get_nr_ram_ranges_callback);
205
+	walk_system_ram_res(0, -1, &nr_ranges, get_nr_ram_ranges_callback);
198
206
 	if (!nr_ranges)
199
207
 		return NULL;
200
208
 
..
..
@@ -203,8 +211,7 @@
203
211
 	 * another range split. So add extra two slots here.
204
212
 	 */
205
213
 	nr_ranges += 2;
206
-	cmem = vzalloc(sizeof(struct crash_mem) +
207
-			sizeof(struct crash_mem_range) * nr_ranges);
214
+	cmem = vzalloc(struct_size(cmem, ranges, nr_ranges));
208
215
 	if (!cmem)
209
216
 		return NULL;
210
217
 
..
..
@@ -222,17 +229,19 @@
222
229
 {
223
230
 	int ret = 0;
224
231
 
232
+	/* Exclude the low 1M because it is always reserved */
233
+	ret = crash_exclude_mem_range(cmem, 0, (1<<20)-1);
234
+	if (ret)
235
+		return ret;
236
+
225
237
 	/* Exclude crashkernel region */
226
238
 	ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end);
227
239
 	if (ret)
228
240
 		return ret;
229
241
 
230
-	if (crashk_low_res.end) {
242
+	if (crashk_low_res.end)
231
243
 		ret = crash_exclude_mem_range(cmem, crashk_low_res.start,
232
-							crashk_low_res.end);
233
-		if (ret)
234
-			return ret;
235
-	}
244
+					      crashk_low_res.end);
236
245
 
237
246
 	return ret;
238
247
 }
..
..
@@ -253,16 +262,13 @@
253
262
 					unsigned long *sz)
254
263
 {
255
264
 	struct crash_mem *cmem;
256
-	Elf64_Ehdr *ehdr;
257
-	Elf64_Phdr *phdr;
258
-	int ret, i;
265
+	int ret;
259
266
 
260
267
 	cmem = fill_up_crash_elf_data();
261
268
 	if (!cmem)
262
269
 		return -ENOMEM;
263
270
 
264
-	ret = walk_system_ram_res(0, -1, cmem,
265
-				prepare_elf64_ram_headers_callback);
271
+	ret = walk_system_ram_res(0, -1, cmem, prepare_elf64_ram_headers_callback);
266
272
 	if (ret)
267
273
 		goto out;
268
274
 
..
..
@@ -272,24 +278,8 @@
272
278
 		goto out;
273
279
 
274
280
 	/* By default prepare 64bit headers */
275
-	ret =  crash_prepare_elf64_headers(cmem,
276
-				IS_ENABLED(CONFIG_X86_64), addr, sz);
277
-	if (ret)
278
-		goto out;
281
+	ret =  crash_prepare_elf64_headers(cmem, IS_ENABLED(CONFIG_X86_64), addr, sz);
279
282
 
280
-	/*
281
-	 * If a range matches backup region, adjust offset to backup
282
-	 * segment.
283
-	 */
284
-	ehdr = (Elf64_Ehdr *)*addr;
285
-	phdr = (Elf64_Phdr *)(ehdr + 1);
286
-	for (i = 0; i < ehdr->e_phnum; phdr++, i++)
287
-		if (phdr->p_type == PT_LOAD &&
288
-				phdr->p_paddr == image->arch.backup_src_start &&
289
-				phdr->p_memsz == image->arch.backup_src_sz) {
290
-			phdr->p_offset = image->arch.backup_load_addr;
291
-			break;
292
-		}
293
283
 out:
294
284
 	vfree(cmem);
295
285
 	return ret;
..
..
@@ -303,8 +293,7 @@
303
293
 	if (nr_e820_entries >= E820_MAX_ENTRIES_ZEROPAGE)
304
294
 		return 1;
305
295
 
306
-	memcpy(&params->e820_table[nr_e820_entries], entry,
307
-			sizeof(struct e820_entry));
296
+	memcpy(&params->e820_table[nr_e820_entries], entry, sizeof(struct e820_entry));
308
297
 	params->e820_entries++;
309
298
 	return 0;
310
299
 }
..
..
@@ -328,18 +317,10 @@
328
317
 				 unsigned long long mend)
329
318
 {
330
319
 	unsigned long start, end;
331
-	int ret = 0;
332
320
 
333
321
 	cmem->ranges[0].start = mstart;
334
322
 	cmem->ranges[0].end = mend;
335
323
 	cmem->nr_ranges = 1;
336
-
337
-	/* Exclude Backup region */
338
-	start = image->arch.backup_load_addr;
339
-	end = start + image->arch.backup_src_sz - 1;
340
-	ret = crash_exclude_mem_range(cmem, start, end);
341
-	if (ret)
342
-		return ret;
343
324
 
344
325
 	/* Exclude elf header region */
345
326
 	start = image->arch.elf_load_addr;
..
..
@@ -363,34 +344,39 @@
363
344
 	memset(&cmd, 0, sizeof(struct crash_memmap_data));
364
345
 	cmd.params = params;
365
346
 
366
-	/* Add first 640K segment */
367
-	ei.addr = image->arch.backup_src_start;
368
-	ei.size = image->arch.backup_src_sz;
369
-	ei.type = E820_TYPE_RAM;
370
-	add_e820_entry(params, &ei);
347
+	/* Add the low 1M */
348
+	cmd.type = E820_TYPE_RAM;
349
+	flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
350
+	walk_iomem_res_desc(IORES_DESC_NONE, flags, 0, (1<<20)-1, &cmd,
351
+			    memmap_entry_callback);
371
352
 
372
353
 	/* Add ACPI tables */
373
354
 	cmd.type = E820_TYPE_ACPI;
374
355
 	flags = IORESOURCE_MEM | IORESOURCE_BUSY;
375
356
 	walk_iomem_res_desc(IORES_DESC_ACPI_TABLES, flags, 0, -1, &cmd,
376
-		       memmap_entry_callback);
357
+			    memmap_entry_callback);
377
358
 
378
359
 	/* Add ACPI Non-volatile Storage */
379
360
 	cmd.type = E820_TYPE_NVS;
380
361
 	walk_iomem_res_desc(IORES_DESC_ACPI_NV_STORAGE, flags, 0, -1, &cmd,
381
-			memmap_entry_callback);
362
+			    memmap_entry_callback);
363
+
364
+	/* Add e820 reserved ranges */
365
+	cmd.type = E820_TYPE_RESERVED;
366
+	flags = IORESOURCE_MEM;
367
+	walk_iomem_res_desc(IORES_DESC_RESERVED, flags, 0, -1, &cmd,
368
+			    memmap_entry_callback);
382
369
 
383
370
 	/* Add crashk_low_res region */
384
371
 	if (crashk_low_res.end) {
385
372
 		ei.addr = crashk_low_res.start;
386
-		ei.size = crashk_low_res.end - crashk_low_res.start + 1;
373
+		ei.size = resource_size(&crashk_low_res);
387
374
 		ei.type = E820_TYPE_RAM;
388
375
 		add_e820_entry(params, &ei);
389
376
 	}
390
377
 
391
378
 	/* Exclude some ranges from crashk_res and add rest to memmap */
392
-	ret = memmap_exclude_ranges(image, cmem, crashk_res.start,
393
-						crashk_res.end);
379
+	ret = memmap_exclude_ranges(image, cmem, crashk_res.start, crashk_res.end);
394
380
 	if (ret)
395
381
 		goto out;
396
382
 
..
..
@@ -410,54 +396,11 @@
410
396
 	return ret;
411
397
 }
412
398
 
413
-static int determine_backup_region(struct resource *res, void *arg)
414
-{
415
-	struct kimage *image = arg;
416
-
417
-	image->arch.backup_src_start = res->start;
418
-	image->arch.backup_src_sz = resource_size(res);
419
-
420
-	/* Expecting only one range for backup region */
421
-	return 1;
422
-}
423
-
424
399
 int crash_load_segments(struct kimage *image)
425
400
 {
426
401
 	int ret;
427
402
 	struct kexec_buf kbuf = { .image = image, .buf_min = 0,
428
403
 				  .buf_max = ULONG_MAX, .top_down = false };
429
-
430
-	/*
431
-	 * Determine and load a segment for backup area. First 640K RAM
432
-	 * region is backup source
433
-	 */
434
-
435
-	ret = walk_system_ram_res(KEXEC_BACKUP_SRC_START, KEXEC_BACKUP_SRC_END,
436
-				image, determine_backup_region);
437
-
438
-	/* Zero or postive return values are ok */
439
-	if (ret < 0)
440
-		return ret;
441
-
442
-	/* Add backup segment. */
443
-	if (image->arch.backup_src_sz) {
444
-		kbuf.buffer = &crash_zero_bytes;
445
-		kbuf.bufsz = sizeof(crash_zero_bytes);
446
-		kbuf.memsz = image->arch.backup_src_sz;
447
-		kbuf.buf_align = PAGE_SIZE;
448
-		/*
449
-		 * Ideally there is no source for backup segment. This is
450
-		 * copied in purgatory after crash. Just add a zero filled
451
-		 * segment for now to make sure checksum logic works fine.
452
-		 */
453
-		ret = kexec_add_buffer(&kbuf);
454
-		if (ret)
455
-			return ret;
456
-		image->arch.backup_load_addr = kbuf.mem;
457
-		pr_debug("Loaded backup region at 0x%lx backup_start=0x%lx memsz=0x%lx\n",
458
-			 image->arch.backup_load_addr,
459
-			 image->arch.backup_src_start, kbuf.memsz);
460
-	}
461
404
 
462
405
 	/* Prepare elf headers and add a segment */
463
406
 	ret = prepare_elf_headers(image, &kbuf.buffer, &kbuf.bufsz);
..
..
@@ -469,6 +412,7 @@
469
412
 
470
413
 	kbuf.memsz = kbuf.bufsz;
471
414
 	kbuf.buf_align = ELF_CORE_HEADER_ALIGN;
415
+	kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;
472
416
 	ret = kexec_add_buffer(&kbuf);
473
417
 	if (ret) {
474
418
 		vfree((void *)image->arch.elf_headers);