Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'powerpc-6.9-2' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux
Pull more powerpc updates from Michael Ellerman:
- Handle errors in mark_rodata_ro() and mark_initmem_nx()
- Make struct crash_mem available without CONFIG_CRASH_DUMP
Thanks to Christophe Leroy and Hari Bathini.
* tag 'powerpc-6.9-2' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux:
powerpc/kdump: Split KEXEC_CORE and CRASH_DUMP dependency
powerpc/kexec: split CONFIG_KEXEC_FILE and CONFIG_CRASH_DUMP
kexec/kdump: make struct crash_mem available without CONFIG_CRASH_DUMP
powerpc: Handle error in mark_rodata_ro() and mark_initmem_nx()
+274
-231
+1
-8
arch/powerpc/Kconfig
+1
-8
arch/powerpc/Kconfig
···
607
607
config ARCH_SUPPORTS_KEXEC
608
608
def_bool PPC_BOOK3S || PPC_E500 || (44x && !SMP)
609
609
610
-
config ARCH_SELECTS_KEXEC
611
-
def_bool y
612
-
depends on KEXEC
613
-
select CRASH_DUMP
614
-
615
610
config ARCH_SUPPORTS_KEXEC_FILE
616
611
def_bool PPC64
617
612
···
617
622
def_bool y
618
623
depends on KEXEC_FILE
619
624
select KEXEC_ELF
620
-
select CRASH_DUMP
621
625
select HAVE_IMA_KEXEC if IMA
622
626
623
627
config PPC64_BIG_ENDIAN_ELF_ABI_V2
···
688
694
689
695
config FA_DUMP
690
696
bool "Firmware-assisted dump"
691
-
depends on PPC64 && (PPC_RTAS || PPC_POWERNV)
692
-
select CRASH_DUMP
697
+
depends on CRASH_DUMP && PPC64 && (PPC_RTAS || PPC_POWERNV)
693
698
help
694
699
A robust mechanism to get reliable kernel crash dump with
695
700
assistance from firmware. This approach does not use kexec,
+49
-49
arch/powerpc/include/asm/kexec.h
+49
-49
arch/powerpc/include/asm/kexec.h
···
55
55
typedef void (*crash_shutdown_t)(void);
56
56
57
57
#ifdef CONFIG_KEXEC_CORE
58
-
59
-
/*
60
-
* This function is responsible for capturing register states if coming
61
-
* via panic or invoking dump using sysrq-trigger.
62
-
*/
63
-
static inline void crash_setup_regs(struct pt_regs *newregs,
64
-
struct pt_regs *oldregs)
65
-
{
66
-
if (oldregs)
67
-
memcpy(newregs, oldregs, sizeof(*newregs));
68
-
else
69
-
ppc_save_regs(newregs);
70
-
}
58
+
struct kimage;
59
+
struct pt_regs;
71
60
72
61
extern void kexec_smp_wait(void); /* get and clear naca physid, wait for
73
62
master to copy new code to 0 */
74
-
extern int crashing_cpu;
75
-
extern void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *));
76
-
extern void crash_ipi_callback(struct pt_regs *);
77
-
extern int crash_wake_offline;
78
-
79
-
struct kimage;
80
-
struct pt_regs;
81
63
extern void default_machine_kexec(struct kimage *image);
82
-
extern void default_machine_crash_shutdown(struct pt_regs *regs);
83
-
extern int crash_shutdown_register(crash_shutdown_t handler);
84
-
extern int crash_shutdown_unregister(crash_shutdown_t handler);
85
-
86
-
extern void crash_kexec_prepare(void);
87
-
extern void crash_kexec_secondary(struct pt_regs *regs);
88
-
int __init overlaps_crashkernel(unsigned long start, unsigned long size);
89
-
extern void reserve_crashkernel(void);
90
64
extern void machine_kexec_mask_interrupts(void);
91
-
92
-
static inline bool kdump_in_progress(void)
93
-
{
94
-
return crashing_cpu >= 0;
95
-
}
96
65
97
66
void relocate_new_kernel(unsigned long indirection_page, unsigned long reboot_code_buffer,
98
67
unsigned long start_address) __noreturn;
99
-
100
68
void kexec_copy_flush(struct kimage *image);
101
-
102
-
#if defined(CONFIG_CRASH_DUMP)
103
-
bool is_kdump_kernel(void);
104
-
#define is_kdump_kernel is_kdump_kernel
105
-
#if defined(CONFIG_PPC_RTAS)
106
-
void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
107
-
#define crash_free_reserved_phys_range crash_free_reserved_phys_range
108
-
#endif /* CONFIG_PPC_RTAS */
109
-
#endif /* CONFIG_CRASH_DUMP */
110
69
111
70
#ifdef CONFIG_KEXEC_FILE
112
71
extern const struct kexec_file_ops kexec_elf64_ops;
···
111
152
112
153
#endif /* CONFIG_KEXEC_FILE */
113
154
114
-
#else /* !CONFIG_KEXEC_CORE */
115
-
static inline void crash_kexec_secondary(struct pt_regs *regs) { }
155
+
#endif /* CONFIG_KEXEC_CORE */
116
156
117
-
static inline int overlaps_crashkernel(unsigned long start, unsigned long size)
157
+
#ifdef CONFIG_CRASH_RESERVE
158
+
int __init overlaps_crashkernel(unsigned long start, unsigned long size);
159
+
extern void reserve_crashkernel(void);
160
+
#else
161
+
static inline void reserve_crashkernel(void) {}
162
+
static inline int overlaps_crashkernel(unsigned long start, unsigned long size) { return 0; }
163
+
#endif
164
+
165
+
#if defined(CONFIG_CRASH_DUMP)
166
+
/*
167
+
* This function is responsible for capturing register states if coming
168
+
* via panic or invoking dump using sysrq-trigger.
169
+
*/
170
+
static inline void crash_setup_regs(struct pt_regs *newregs,
171
+
struct pt_regs *oldregs)
118
172
{
119
-
return 0;
173
+
if (oldregs)
174
+
memcpy(newregs, oldregs, sizeof(*newregs));
175
+
else
176
+
ppc_save_regs(newregs);
120
177
}
121
178
122
-
static inline void reserve_crashkernel(void) { ; }
179
+
extern int crashing_cpu;
180
+
extern void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *));
181
+
extern void crash_ipi_callback(struct pt_regs *regs);
182
+
extern int crash_wake_offline;
183
+
184
+
extern int crash_shutdown_register(crash_shutdown_t handler);
185
+
extern int crash_shutdown_unregister(crash_shutdown_t handler);
186
+
extern void default_machine_crash_shutdown(struct pt_regs *regs);
187
+
188
+
extern void crash_kexec_prepare(void);
189
+
extern void crash_kexec_secondary(struct pt_regs *regs);
190
+
191
+
static inline bool kdump_in_progress(void)
192
+
{
193
+
return crashing_cpu >= 0;
194
+
}
195
+
196
+
bool is_kdump_kernel(void);
197
+
#define is_kdump_kernel is_kdump_kernel
198
+
#if defined(CONFIG_PPC_RTAS)
199
+
void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
200
+
#define crash_free_reserved_phys_range crash_free_reserved_phys_range
201
+
#endif /* CONFIG_PPC_RTAS */
202
+
203
+
#else /* !CONFIG_CRASH_DUMP */
204
+
static inline void crash_kexec_secondary(struct pt_regs *regs) { }
123
205
124
206
static inline int crash_shutdown_register(crash_shutdown_t handler)
125
207
{
···
183
183
{
184
184
}
185
185
186
-
#endif /* CONFIG_KEXEC_CORE */
186
+
#endif /* CONFIG_CRASH_DUMP */
187
187
188
188
#ifdef CONFIG_PPC_BOOK3S_64
189
189
#include <asm/book3s/64/kexec.h>
+1
-1
arch/powerpc/kernel/prom.c
+1
-1
arch/powerpc/kernel/prom.c
+1
-1
arch/powerpc/kernel/setup-common.c
+1
-1
arch/powerpc/kernel/setup-common.c
+2
-2
arch/powerpc/kernel/smp.c
+2
-2
arch/powerpc/kernel/smp.c
···
588
588
}
589
589
#endif
590
590
591
-
#ifdef CONFIG_KEXEC_CORE
591
+
#ifdef CONFIG_CRASH_DUMP
592
592
void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
593
593
{
594
594
int cpu;
···
631
631
632
632
stopped = true;
633
633
634
-
#ifdef CONFIG_KEXEC_CORE
634
+
#ifdef CONFIG_CRASH_DUMP
635
635
if (kexec_crash_image) {
636
636
crash_kexec_prepare();
637
637
return;
+2
-1
arch/powerpc/kexec/Makefile
+2
-1
arch/powerpc/kexec/Makefile
···
3
3
# Makefile for the linux kernel.
4
4
#
5
5
6
-
obj-y += core.o crash.o core_$(BITS).o
6
+
obj-y += core.o core_$(BITS).o
7
7
8
8
obj-$(CONFIG_PPC32) += relocate_32.o
9
9
10
10
obj-$(CONFIG_KEXEC_FILE) += file_load.o ranges.o file_load_$(BITS).o elf_$(BITS).o
11
11
obj-$(CONFIG_VMCORE_INFO) += vmcore_info.o
12
+
obj-$(CONFIG_CRASH_DUMP) += crash.o
12
13
13
14
# Disable GCOV, KCOV & sanitizers in odd or sensitive code
14
15
GCOV_PROFILE_core_$(BITS).o := n
+4
arch/powerpc/kexec/core.c
+4
arch/powerpc/kexec/core.c
···
44
44
}
45
45
}
46
46
47
+
#ifdef CONFIG_CRASH_DUMP
47
48
void machine_crash_shutdown(struct pt_regs *regs)
48
49
{
49
50
default_machine_crash_shutdown(regs);
50
51
}
52
+
#endif
51
53
52
54
void machine_kexec_cleanup(struct kimage *image)
53
55
{
···
79
77
for(;;);
80
78
}
81
79
80
+
#ifdef CONFIG_CRASH_RESERVE
82
81
void __init reserve_crashkernel(void)
83
82
{
84
83
unsigned long long crash_size, crash_base, total_mem_sz;
···
254
251
return 0;
255
252
}
256
253
late_initcall(kexec_setup);
254
+
#endif /* CONFIG_CRASH_RESERVE */
+2
-2
arch/powerpc/kexec/elf_64.c
+2
-2
arch/powerpc/kexec/elf_64.c
···
47
47
if (ret)
48
48
return ERR_PTR(ret);
49
49
50
-
if (image->type == KEXEC_TYPE_CRASH) {
50
+
if (IS_ENABLED(CONFIG_CRASH_DUMP) && image->type == KEXEC_TYPE_CRASH) {
51
51
/* min & max buffer values for kdump case */
52
52
kbuf.buf_min = pbuf.buf_min = crashk_res.start;
53
53
kbuf.buf_max = pbuf.buf_max =
···
70
70
kexec_dprintk("Loaded purgatory at 0x%lx\n", pbuf.mem);
71
71
72
72
/* Load additional segments needed for panic kernel */
73
-
if (image->type == KEXEC_TYPE_CRASH) {
73
+
if (IS_ENABLED(CONFIG_CRASH_DUMP) && image->type == KEXEC_TYPE_CRASH) {
74
74
ret = load_crashdump_segments_ppc64(image, &kbuf);
75
75
if (ret) {
76
76
pr_err("Failed to load kdump kernel segments\n");
+140
-129
arch/powerpc/kexec/file_load_64.c
+140
-129
arch/powerpc/kexec/file_load_64.c
···
97
97
}
98
98
99
99
/**
100
-
* get_usable_memory_ranges - Get usable memory ranges. This list includes
101
-
* regions like crashkernel, opal/rtas & tce-table,
102
-
* that kdump kernel could use.
103
-
* @mem_ranges: Range list to add the memory ranges to.
104
-
*
105
-
* Returns 0 on success, negative errno on error.
106
-
*/
107
-
static int get_usable_memory_ranges(struct crash_mem **mem_ranges)
108
-
{
109
-
int ret;
110
-
111
-
/*
112
-
* Early boot failure observed on guests when low memory (first memory
113
-
* block?) is not added to usable memory. So, add [0, crashk_res.end]
114
-
* instead of [crashk_res.start, crashk_res.end] to workaround it.
115
-
* Also, crashed kernel's memory must be added to reserve map to
116
-
* avoid kdump kernel from using it.
117
-
*/
118
-
ret = add_mem_range(mem_ranges, 0, crashk_res.end + 1);
119
-
if (ret)
120
-
goto out;
121
-
122
-
ret = add_rtas_mem_range(mem_ranges);
123
-
if (ret)
124
-
goto out;
125
-
126
-
ret = add_opal_mem_range(mem_ranges);
127
-
if (ret)
128
-
goto out;
129
-
130
-
ret = add_tce_mem_ranges(mem_ranges);
131
-
out:
132
-
if (ret)
133
-
pr_err("Failed to setup usable memory ranges\n");
134
-
return ret;
135
-
}
136
-
137
-
/**
138
-
* get_crash_memory_ranges - Get crash memory ranges. This list includes
139
-
* first/crashing kernel's memory regions that
140
-
* would be exported via an elfcore.
141
-
* @mem_ranges: Range list to add the memory ranges to.
142
-
*
143
-
* Returns 0 on success, negative errno on error.
144
-
*/
145
-
static int get_crash_memory_ranges(struct crash_mem **mem_ranges)
146
-
{
147
-
phys_addr_t base, end;
148
-
struct crash_mem *tmem;
149
-
u64 i;
150
-
int ret;
151
-
152
-
for_each_mem_range(i, &base, &end) {
153
-
u64 size = end - base;
154
-
155
-
/* Skip backup memory region, which needs a separate entry */
156
-
if (base == BACKUP_SRC_START) {
157
-
if (size > BACKUP_SRC_SIZE) {
158
-
base = BACKUP_SRC_END + 1;
159
-
size -= BACKUP_SRC_SIZE;
160
-
} else
161
-
continue;
162
-
}
163
-
164
-
ret = add_mem_range(mem_ranges, base, size);
165
-
if (ret)
166
-
goto out;
167
-
168
-
/* Try merging adjacent ranges before reallocation attempt */
169
-
if ((*mem_ranges)->nr_ranges == (*mem_ranges)->max_nr_ranges)
170
-
sort_memory_ranges(*mem_ranges, true);
171
-
}
172
-
173
-
/* Reallocate memory ranges if there is no space to split ranges */
174
-
tmem = *mem_ranges;
175
-
if (tmem && (tmem->nr_ranges == tmem->max_nr_ranges)) {
176
-
tmem = realloc_mem_ranges(mem_ranges);
177
-
if (!tmem)
178
-
goto out;
179
-
}
180
-
181
-
/* Exclude crashkernel region */
182
-
ret = crash_exclude_mem_range(tmem, crashk_res.start, crashk_res.end);
183
-
if (ret)
184
-
goto out;
185
-
186
-
/*
187
-
* FIXME: For now, stay in parity with kexec-tools but if RTAS/OPAL
188
-
* regions are exported to save their context at the time of
189
-
* crash, they should actually be backed up just like the
190
-
* first 64K bytes of memory.
191
-
*/
192
-
ret = add_rtas_mem_range(mem_ranges);
193
-
if (ret)
194
-
goto out;
195
-
196
-
ret = add_opal_mem_range(mem_ranges);
197
-
if (ret)
198
-
goto out;
199
-
200
-
/* create a separate program header for the backup region */
201
-
ret = add_mem_range(mem_ranges, BACKUP_SRC_START, BACKUP_SRC_SIZE);
202
-
if (ret)
203
-
goto out;
204
-
205
-
sort_memory_ranges(*mem_ranges, false);
206
-
out:
207
-
if (ret)
208
-
pr_err("Failed to setup crash memory ranges\n");
209
-
return ret;
210
-
}
211
-
212
-
/**
213
100
* get_reserved_memory_ranges - Get reserve memory ranges. This list includes
214
101
* memory regions that should be added to the
215
102
* memory reserve map to ensure the region is
···
318
431
tmax = buf_max;
319
432
ret = __locate_mem_hole_bottom_up(kbuf, tmin, tmax);
320
433
}
434
+
return ret;
435
+
}
436
+
437
+
#ifdef CONFIG_CRASH_DUMP
438
+
/**
439
+
* get_usable_memory_ranges - Get usable memory ranges. This list includes
440
+
* regions like crashkernel, opal/rtas & tce-table,
441
+
* that kdump kernel could use.
442
+
* @mem_ranges: Range list to add the memory ranges to.
443
+
*
444
+
* Returns 0 on success, negative errno on error.
445
+
*/
446
+
static int get_usable_memory_ranges(struct crash_mem **mem_ranges)
447
+
{
448
+
int ret;
449
+
450
+
/*
451
+
* Early boot failure observed on guests when low memory (first memory
452
+
* block?) is not added to usable memory. So, add [0, crashk_res.end]
453
+
* instead of [crashk_res.start, crashk_res.end] to workaround it.
454
+
* Also, crashed kernel's memory must be added to reserve map to
455
+
* avoid kdump kernel from using it.
456
+
*/
457
+
ret = add_mem_range(mem_ranges, 0, crashk_res.end + 1);
458
+
if (ret)
459
+
goto out;
460
+
461
+
ret = add_rtas_mem_range(mem_ranges);
462
+
if (ret)
463
+
goto out;
464
+
465
+
ret = add_opal_mem_range(mem_ranges);
466
+
if (ret)
467
+
goto out;
468
+
469
+
ret = add_tce_mem_ranges(mem_ranges);
470
+
out:
471
+
if (ret)
472
+
pr_err("Failed to setup usable memory ranges\n");
473
+
return ret;
474
+
}
475
+
476
+
/**
477
+
* get_crash_memory_ranges - Get crash memory ranges. This list includes
478
+
* first/crashing kernel's memory regions that
479
+
* would be exported via an elfcore.
480
+
* @mem_ranges: Range list to add the memory ranges to.
481
+
*
482
+
* Returns 0 on success, negative errno on error.
483
+
*/
484
+
static int get_crash_memory_ranges(struct crash_mem **mem_ranges)
485
+
{
486
+
phys_addr_t base, end;
487
+
struct crash_mem *tmem;
488
+
u64 i;
489
+
int ret;
490
+
491
+
for_each_mem_range(i, &base, &end) {
492
+
u64 size = end - base;
493
+
494
+
/* Skip backup memory region, which needs a separate entry */
495
+
if (base == BACKUP_SRC_START) {
496
+
if (size > BACKUP_SRC_SIZE) {
497
+
base = BACKUP_SRC_END + 1;
498
+
size -= BACKUP_SRC_SIZE;
499
+
} else
500
+
continue;
501
+
}
502
+
503
+
ret = add_mem_range(mem_ranges, base, size);
504
+
if (ret)
505
+
goto out;
506
+
507
+
/* Try merging adjacent ranges before reallocation attempt */
508
+
if ((*mem_ranges)->nr_ranges == (*mem_ranges)->max_nr_ranges)
509
+
sort_memory_ranges(*mem_ranges, true);
510
+
}
511
+
512
+
/* Reallocate memory ranges if there is no space to split ranges */
513
+
tmem = *mem_ranges;
514
+
if (tmem && (tmem->nr_ranges == tmem->max_nr_ranges)) {
515
+
tmem = realloc_mem_ranges(mem_ranges);
516
+
if (!tmem)
517
+
goto out;
518
+
}
519
+
520
+
/* Exclude crashkernel region */
521
+
ret = crash_exclude_mem_range(tmem, crashk_res.start, crashk_res.end);
522
+
if (ret)
523
+
goto out;
524
+
525
+
/*
526
+
* FIXME: For now, stay in parity with kexec-tools but if RTAS/OPAL
527
+
* regions are exported to save their context at the time of
528
+
* crash, they should actually be backed up just like the
529
+
* first 64K bytes of memory.
530
+
*/
531
+
ret = add_rtas_mem_range(mem_ranges);
532
+
if (ret)
533
+
goto out;
534
+
535
+
ret = add_opal_mem_range(mem_ranges);
536
+
if (ret)
537
+
goto out;
538
+
539
+
/* create a separate program header for the backup region */
540
+
ret = add_mem_range(mem_ranges, BACKUP_SRC_START, BACKUP_SRC_SIZE);
541
+
if (ret)
542
+
goto out;
543
+
544
+
sort_memory_ranges(*mem_ranges, false);
545
+
out:
546
+
if (ret)
547
+
pr_err("Failed to setup crash memory ranges\n");
321
548
return ret;
322
549
}
323
550
···
864
863
865
864
return 0;
866
865
}
866
+
#endif
867
867
868
868
/**
869
869
* setup_purgatory_ppc64 - initialize PPC64 specific purgatory's global
···
974
972
return size;
975
973
}
976
974
977
-
/**
978
-
* kexec_extra_fdt_size_ppc64 - Return the estimated additional size needed to
979
-
* setup FDT for kexec/kdump kernel.
980
-
* @image: kexec image being loaded.
981
-
*
982
-
* Returns the estimated extra size needed for kexec/kdump kernel FDT.
983
-
*/
984
-
unsigned int kexec_extra_fdt_size_ppc64(struct kimage *image)
975
+
static unsigned int kdump_extra_fdt_size_ppc64(struct kimage *image)
985
976
{
986
977
unsigned int cpu_nodes, extra_size = 0;
987
978
struct device_node *dn;
988
979
u64 usm_entries;
989
980
990
-
// Budget some space for the password blob. There's already extra space
991
-
// for the key name
992
-
if (plpks_is_available())
993
-
extra_size += (unsigned int)plpks_get_passwordlen();
994
-
995
-
if (image->type != KEXEC_TYPE_CRASH)
996
-
return extra_size;
981
+
if (!IS_ENABLED(CONFIG_CRASH_DUMP) || image->type != KEXEC_TYPE_CRASH)
982
+
return 0;
997
983
998
984
/*
999
985
* For kdump kernel, account for linux,usable-memory and
···
1007
1017
extra_size += (cpu_nodes - boot_cpu_node_count) * cpu_node_size();
1008
1018
1009
1019
return extra_size;
1020
+
}
1021
+
1022
+
/**
1023
+
* kexec_extra_fdt_size_ppc64 - Return the estimated additional size needed to
1024
+
* setup FDT for kexec/kdump kernel.
1025
+
* @image: kexec image being loaded.
1026
+
*
1027
+
* Returns the estimated extra size needed for kexec/kdump kernel FDT.
1028
+
*/
1029
+
unsigned int kexec_extra_fdt_size_ppc64(struct kimage *image)
1030
+
{
1031
+
unsigned int extra_size = 0;
1032
+
1033
+
// Budget some space for the password blob. There's already extra space
1034
+
// for the key name
1035
+
if (plpks_is_available())
1036
+
extra_size += (unsigned int)plpks_get_passwordlen();
1037
+
1038
+
return extra_size + kdump_extra_fdt_size_ppc64(image);
1010
1039
}
1011
1040
1012
1041
/**
···
1180
1171
struct crash_mem *umem = NULL, *rmem = NULL;
1181
1172
int i, nr_ranges, ret;
1182
1173
1174
+
#ifdef CONFIG_CRASH_DUMP
1183
1175
/*
1184
1176
* Restrict memory usage for kdump kernel by setting up
1185
1177
* usable memory ranges and memory reserve map.
···
1217
1207
goto out;
1218
1208
}
1219
1209
}
1210
+
#endif
1220
1211
1221
1212
/* Update cpus nodes information to account hotplug CPUs. */
1222
1213
ret = update_cpus_node(fdt);
···
1289
1278
buf_min = kbuf->buf_min;
1290
1279
buf_max = kbuf->buf_max;
1291
1280
/* Segments for kdump kernel should be within crashkernel region */
1292
-
if (kbuf->image->type == KEXEC_TYPE_CRASH) {
1281
+
if (IS_ENABLED(CONFIG_CRASH_DUMP) && kbuf->image->type == KEXEC_TYPE_CRASH) {
1293
1282
buf_min = (buf_min < crashk_res.start ?
1294
1283
crashk_res.start : buf_min);
1295
1284
buf_max = (buf_max > crashk_res.end ?
+5
-2
arch/powerpc/mm/book3s32/mmu.c
+5
-2
arch/powerpc/mm/book3s32/mmu.c
···
193
193
return true;
194
194
}
195
195
196
-
void mmu_mark_initmem_nx(void)
196
+
int mmu_mark_initmem_nx(void)
197
197
{
198
198
int nb = mmu_has_feature(MMU_FTR_USE_HIGH_BATS) ? 8 : 4;
199
199
int i;
···
230
230
231
231
mtsr(mfsr(i << 28) | 0x10000000, i << 28);
232
232
}
233
+
return 0;
233
234
}
234
235
235
-
void mmu_mark_rodata_ro(void)
236
+
int mmu_mark_rodata_ro(void)
236
237
{
237
238
int nb = mmu_has_feature(MMU_FTR_USE_HIGH_BATS) ? 8 : 4;
238
239
int i;
···
246
245
}
247
246
248
247
update_bats();
248
+
249
+
return 0;
249
250
}
250
251
251
252
/*
+4
-4
arch/powerpc/mm/mmu_decl.h
+4
-4
arch/powerpc/mm/mmu_decl.h
···
160
160
#endif
161
161
162
162
#if defined(CONFIG_PPC_BOOK3S_32) || defined(CONFIG_PPC_8xx) || defined(CONFIG_PPC_E500)
163
-
void mmu_mark_initmem_nx(void);
164
-
void mmu_mark_rodata_ro(void);
163
+
int mmu_mark_initmem_nx(void);
164
+
int mmu_mark_rodata_ro(void);
165
165
#else
166
-
static inline void mmu_mark_initmem_nx(void) { }
167
-
static inline void mmu_mark_rodata_ro(void) { }
166
+
static inline int mmu_mark_initmem_nx(void) { return 0; }
167
+
static inline int mmu_mark_rodata_ro(void) { return 0; }
168
168
#endif
169
169
170
170
#ifdef CONFIG_PPC_8xx
+21
-12
arch/powerpc/mm/nohash/8xx.c
+21
-12
arch/powerpc/mm/nohash/8xx.c
···
119
119
PAGE_KERNEL_NCG, MMU_PAGE_512K, true);
120
120
}
121
121
122
-
static void mmu_mapin_ram_chunk(unsigned long offset, unsigned long top,
123
-
pgprot_t prot, bool new)
122
+
static int mmu_mapin_ram_chunk(unsigned long offset, unsigned long top,
123
+
pgprot_t prot, bool new)
124
124
{
125
125
unsigned long v = PAGE_OFFSET + offset;
126
126
unsigned long p = offset;
127
+
int err = 0;
127
128
128
129
WARN_ON(!IS_ALIGNED(offset, SZ_512K) || !IS_ALIGNED(top, SZ_512K));
129
130
130
-
for (; p < ALIGN(p, SZ_8M) && p < top; p += SZ_512K, v += SZ_512K)
131
-
__early_map_kernel_hugepage(v, p, prot, MMU_PAGE_512K, new);
132
-
for (; p < ALIGN_DOWN(top, SZ_8M) && p < top; p += SZ_8M, v += SZ_8M)
133
-
__early_map_kernel_hugepage(v, p, prot, MMU_PAGE_8M, new);
134
-
for (; p < ALIGN_DOWN(top, SZ_512K) && p < top; p += SZ_512K, v += SZ_512K)
135
-
__early_map_kernel_hugepage(v, p, prot, MMU_PAGE_512K, new);
131
+
for (; p < ALIGN(p, SZ_8M) && p < top && !err; p += SZ_512K, v += SZ_512K)
132
+
err = __early_map_kernel_hugepage(v, p, prot, MMU_PAGE_512K, new);
133
+
for (; p < ALIGN_DOWN(top, SZ_8M) && p < top && !err; p += SZ_8M, v += SZ_8M)
134
+
err = __early_map_kernel_hugepage(v, p, prot, MMU_PAGE_8M, new);
135
+
for (; p < ALIGN_DOWN(top, SZ_512K) && p < top && !err; p += SZ_512K, v += SZ_512K)
136
+
err = __early_map_kernel_hugepage(v, p, prot, MMU_PAGE_512K, new);
136
137
137
138
if (!new)
138
139
flush_tlb_kernel_range(PAGE_OFFSET + v, PAGE_OFFSET + top);
140
+
141
+
return err;
139
142
}
140
143
141
144
unsigned long __init mmu_mapin_ram(unsigned long base, unsigned long top)
···
169
166
return top;
170
167
}
171
168
172
-
void mmu_mark_initmem_nx(void)
169
+
int mmu_mark_initmem_nx(void)
173
170
{
174
171
unsigned long etext8 = ALIGN(__pa(_etext), SZ_8M);
175
172
unsigned long sinittext = __pa(_sinittext);
176
173
unsigned long boundary = strict_kernel_rwx_enabled() ? sinittext : etext8;
177
174
unsigned long einittext8 = ALIGN(__pa(_einittext), SZ_8M);
175
+
int err = 0;
178
176
179
177
if (!debug_pagealloc_enabled_or_kfence())
180
-
mmu_mapin_ram_chunk(boundary, einittext8, PAGE_KERNEL, false);
178
+
err = mmu_mapin_ram_chunk(boundary, einittext8, PAGE_KERNEL, false);
181
179
182
180
mmu_pin_tlb(block_mapped_ram, false);
181
+
182
+
return err;
183
183
}
184
184
185
185
#ifdef CONFIG_STRICT_KERNEL_RWX
186
-
void mmu_mark_rodata_ro(void)
186
+
int mmu_mark_rodata_ro(void)
187
187
{
188
188
unsigned long sinittext = __pa(_sinittext);
189
+
int err;
189
190
190
-
mmu_mapin_ram_chunk(0, sinittext, PAGE_KERNEL_ROX, false);
191
+
err = mmu_mapin_ram_chunk(0, sinittext, PAGE_KERNEL_ROX, false);
191
192
if (IS_ENABLED(CONFIG_PIN_TLB_DATA))
192
193
mmu_pin_tlb(block_mapped_ram, true);
194
+
195
+
return err;
193
196
}
194
197
#endif
195
198
+7
-3
arch/powerpc/mm/nohash/e500.c
+7
-3
arch/powerpc/mm/nohash/e500.c
···
285
285
}
286
286
287
287
#ifdef CONFIG_STRICT_KERNEL_RWX
288
-
void mmu_mark_rodata_ro(void)
288
+
int mmu_mark_rodata_ro(void)
289
289
{
290
290
unsigned long remapped;
291
291
292
292
remapped = map_mem_in_cams(__max_low_memory, CONFIG_LOWMEM_CAM_NUM, false, false);
293
293
294
-
WARN_ON(__max_low_memory != remapped);
294
+
if (WARN_ON(__max_low_memory != remapped))
295
+
return -EINVAL;
296
+
297
+
return 0;
295
298
}
296
299
#endif
297
300
298
-
void mmu_mark_initmem_nx(void)
301
+
int mmu_mark_initmem_nx(void)
299
302
{
300
303
/* Everything is done in mmu_mark_rodata_ro() */
304
+
return 0;
301
305
}
302
306
303
307
void setup_initial_memory_limit(phys_addr_t first_memblock_base,
+28
-10
arch/powerpc/mm/pgtable_32.c
+28
-10
arch/powerpc/mm/pgtable_32.c
···
130
130
}
131
131
}
132
132
133
-
void mark_initmem_nx(void)
133
+
static int __mark_initmem_nx(void)
134
134
{
135
135
unsigned long numpages = PFN_UP((unsigned long)_einittext) -
136
136
PFN_DOWN((unsigned long)_sinittext);
137
+
int err;
137
138
138
-
mmu_mark_initmem_nx();
139
+
err = mmu_mark_initmem_nx();
139
140
140
141
if (!v_block_mapped((unsigned long)_sinittext)) {
141
-
set_memory_nx((unsigned long)_sinittext, numpages);
142
-
set_memory_rw((unsigned long)_sinittext, numpages);
142
+
err = set_memory_nx((unsigned long)_sinittext, numpages);
143
+
if (err)
144
+
return err;
145
+
err = set_memory_rw((unsigned long)_sinittext, numpages);
143
146
}
147
+
return err;
148
+
}
149
+
150
+
void mark_initmem_nx(void)
151
+
{
152
+
int err = __mark_initmem_nx();
153
+
154
+
if (err)
155
+
panic("%s() failed, err = %d\n", __func__, err);
144
156
}
145
157
146
158
#ifdef CONFIG_STRICT_KERNEL_RWX
147
-
void mark_rodata_ro(void)
159
+
static int __mark_rodata_ro(void)
148
160
{
149
161
unsigned long numpages;
150
162
151
163
if (IS_ENABLED(CONFIG_STRICT_MODULE_RWX) && mmu_has_feature(MMU_FTR_HPTE_TABLE))
152
164
pr_warn("This platform has HASH MMU, STRICT_MODULE_RWX won't work\n");
153
165
154
-
if (v_block_mapped((unsigned long)_stext + 1)) {
155
-
mmu_mark_rodata_ro();
156
-
return;
157
-
}
166
+
if (v_block_mapped((unsigned long)_stext + 1))
167
+
return mmu_mark_rodata_ro();
158
168
159
169
/*
160
170
* mark text and rodata as read only. __end_rodata is set by
···
174
164
numpages = PFN_UP((unsigned long)__end_rodata) -
175
165
PFN_DOWN((unsigned long)_stext);
176
166
177
-
set_memory_ro((unsigned long)_stext, numpages);
167
+
return set_memory_ro((unsigned long)_stext, numpages);
168
+
}
169
+
170
+
void mark_rodata_ro(void)
171
+
{
172
+
int err = __mark_rodata_ro();
173
+
174
+
if (err)
175
+
panic("%s() failed, err = %d\n", __func__, err);
178
176
}
179
177
#endif
+1
-1
arch/powerpc/platforms/powernv/smp.c
+1
-1
arch/powerpc/platforms/powernv/smp.c
+6
-6
include/linux/crash_core.h
+6
-6
include/linux/crash_core.h
···
8
8
9
9
struct kimage;
10
10
11
+
struct crash_mem {
12
+
unsigned int max_nr_ranges;
13
+
unsigned int nr_ranges;
14
+
struct range ranges[] __counted_by(max_nr_ranges);
15
+
};
16
+
11
17
#ifdef CONFIG_CRASH_DUMP
12
18
13
19
int crash_shrink_memory(unsigned long new_size);
···
56
50
57
51
/* Alignment required for elf header segment */
58
52
#define ELF_CORE_HEADER_ALIGN 4096
59
-
60
-
struct crash_mem {
61
-
unsigned int max_nr_ranges;
62
-
unsigned int nr_ranges;
63
-
struct range ranges[] __counted_by(max_nr_ranges);
64
-
};
65
53
66
54
extern int crash_exclude_mem_range(struct crash_mem *mem,
67
55
unsigned long long mstart,