~ljy/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* linux/init/main.c
3	4	*
..	..	@@ -25,18 +26,21 @@
25	26	#include <linux/ioport.h>
26	27	#include <linux/init.h>
27	28	#include <linux/initrd.h>
28		-#include <linux/bootmem.h>
	29	+#include <linux/memblock.h>
29	30	#include <linux/acpi.h>
	31	+#include <linux/bootconfig.h>
30	32	#include <linux/console.h>
31	33	#include <linux/nmi.h>
32	34	#include <linux/percpu.h>
33	35	#include <linux/kmod.h>
	36	+#include <linux/kprobes.h>
34	37	#include <linux/vmalloc.h>
35	38	#include <linux/kernel_stat.h>
36	39	#include <linux/start_kernel.h>
37	40	#include <linux/security.h>
38	41	#include <linux/smp.h>
39	42	#include <linux/profile.h>
	43	+#include <linux/kfence.h>
40	44	#include <linux/rcupdate.h>
41	45	#include <linux/moduleparam.h>
42	46	#include <linux/kallsyms.h>
..	..	@@ -61,8 +65,9 @@
61	65	#include <linux/debugobjects.h>
62	66	#include <linux/lockdep.h>
63	67	#include <linux/kmemleak.h>
	68	+#include <linux/padata.h>
64	69	#include <linux/pid_namespace.h>
65		-#include <linux/device.h>
	70	+#include <linux/device/driver.h>
66	71	#include <linux/kthread.h>
67	72	#include <linux/sched.h>
68	73	#include <linux/sched/init.h>
..	..	@@ -92,6 +97,9 @@
92	97	#include <linux/rodata_test.h>
93	98	#include <linux/jump_label.h>
94	99	#include <linux/mem_encrypt.h>
	100	+#include <linux/kcsan.h>
	101	+#include <linux/init_syscalls.h>
	102	+#include <linux/stackdepot.h>
95	103
96	104	#include <asm/io.h>
97	105	#include <asm/bugs.h>
..	..	@@ -101,6 +109,8 @@
101	109
102	110	#define CREATE_TRACE_POINTS
103	111	#include <trace/events/initcall.h>
	112	+
	113	+#include <kunit/test.h>
104	114
105	115	static int kernel_init(void *);
106	116
..	..	@@ -133,14 +143,24 @@
133	143	char __initdata boot_command_line[COMMAND_LINE_SIZE];
134	144	/* Untouched saved command line (eg. for /proc) */
135	145	char *saved_command_line;
136		-EXPORT_SYMBOL_GPL(saved_command_line);
137	146	/* Command line for parameter parsing */
138	147	static char *static_command_line;
139		-/* Command line for per-initcall parameter parsing */
140		-static char *initcall_command_line;
	148	+/* Untouched extra command line */
	149	+static char *extra_command_line;
	150	+/* Extra init arguments */
	151	+static char *extra_init_args;
	152	+
	153	+#ifdef CONFIG_BOOT_CONFIG
	154	+/* Is bootconfig on command line? */
	155	+static bool bootconfig_found;
	156	+static bool initargs_found;
	157	+#else
	158	+# define bootconfig_found false
	159	+# define initargs_found false
	160	+#endif
141	161
142	162	static char *execute_command;
143		-static char *ramdisk_execute_command;
	163	+static char *ramdisk_execute_command = "/init";
144	164
145	165	/*
146	166	* Used to generate warnings if static_key manipulation functions are used
..	..	@@ -245,9 +265,223 @@
245	265
246	266	early_param("loglevel", loglevel);
247	267
248		-/* Change NUL term back to "=", to make "param" the whole string. */
249		-static int __init repair_env_string(char param, char val,
	268	+#ifdef CONFIG_BLK_DEV_INITRD
	269	+static void * __init get_boot_config_from_initrd(u32 _size, u32 _csum)
	270	+{
	271	+ u32 size, csum;
	272	+ char *data;
	273	+ u32 *hdr;
	274	+ int i;
	275	+
	276	+ if (!initrd_end)
	277	+ return NULL;
	278	+
	279	+ data = (char *)initrd_end - BOOTCONFIG_MAGIC_LEN;
	280	+ /*
	281	+ * Since Grub may align the size of initrd to 4, we must
	282	+ * check the preceding 3 bytes as well.
	283	+ */
	284	+ for (i = 0; i < 4; i++) {
	285	+ if (!memcmp(data, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN))
	286	+ goto found;
	287	+ data--;
	288	+ }
	289	+ return NULL;
	290	+
	291	+found:
	292	+ hdr = (u32 *)(data - 8);
	293	+ size = le32_to_cpu(hdr[0]);
	294	+ csum = le32_to_cpu(hdr[1]);
	295	+
	296	+ data = ((void *)hdr) - size;
	297	+ if ((unsigned long)data < initrd_start) {
	298	+ pr_err("bootconfig size %d is greater than initrd size %ld\n",
	299	+ size, initrd_end - initrd_start);
	300	+ return NULL;
	301	+ }
	302	+
	303	+ /* Remove bootconfig from initramfs/initrd */
	304	+ initrd_end = (unsigned long)data;
	305	+ if (_size)
	306	+ *_size = size;
	307	+ if (_csum)
	308	+ *_csum = csum;
	309	+
	310	+ return data;
	311	+}
	312	+#else
	313	+static void * __init get_boot_config_from_initrd(u32 _size, u32 _csum)
	314	+{
	315	+ return NULL;
	316	+}
	317	+#endif
	318	+
	319	+#ifdef CONFIG_BOOT_CONFIG
	320	+
	321	+static char xbc_namebuf[XBC_KEYLEN_MAX] __initdata;
	322	+
	323	+#define rest(dst, end) ((end) > (dst) ? (end) - (dst) : 0)
	324	+
	325	+static int __init xbc_snprint_cmdline(char *buf, size_t size,
	326	+ struct xbc_node *root)
	327	+{
	328	+ struct xbc_node knode, vnode;
	329	+ char *end = buf + size;
	330	+ const char *val;
	331	+ int ret;
	332	+
	333	+ xbc_node_for_each_key_value(root, knode, val) {
	334	+ ret = xbc_node_compose_key_after(root, knode,
	335	+ xbc_namebuf, XBC_KEYLEN_MAX);
	336	+ if (ret < 0)
	337	+ return ret;
	338	+
	339	+ vnode = xbc_node_get_child(knode);
	340	+ if (!vnode) {
	341	+ ret = snprintf(buf, rest(buf, end), "%s ", xbc_namebuf);
	342	+ if (ret < 0)
	343	+ return ret;
	344	+ buf += ret;
	345	+ continue;
	346	+ }
	347	+ xbc_array_for_each_value(vnode, val) {
	348	+ ret = snprintf(buf, rest(buf, end), "%s=\"%s\" ",
	349	+ xbc_namebuf, val);
	350	+ if (ret < 0)
	351	+ return ret;
	352	+ buf += ret;
	353	+ }
	354	+ }
	355	+
	356	+ return buf - (end - size);
	357	+}
	358	+#undef rest
	359	+
	360	+/* Make an extra command line under given key word */
	361	+static char * __init xbc_make_cmdline(const char *key)
	362	+{
	363	+ struct xbc_node *root;
	364	+ char *new_cmdline;
	365	+ int ret, len = 0;
	366	+
	367	+ root = xbc_find_node(key);
	368	+ if (!root)
	369	+ return NULL;
	370	+
	371	+ /* Count required buffer size */
	372	+ len = xbc_snprint_cmdline(NULL, 0, root);
	373	+ if (len <= 0)
	374	+ return NULL;
	375	+
	376	+ new_cmdline = memblock_alloc(len + 1, SMP_CACHE_BYTES);
	377	+ if (!new_cmdline) {
	378	+ pr_err("Failed to allocate memory for extra kernel cmdline.\n");
	379	+ return NULL;
	380	+ }
	381	+
	382	+ ret = xbc_snprint_cmdline(new_cmdline, len + 1, root);
	383	+ if (ret < 0 \|\| ret > len) {
	384	+ pr_err("Failed to print extra kernel cmdline.\n");
	385	+ memblock_free(__pa(new_cmdline), len + 1);
	386	+ return NULL;
	387	+ }
	388	+
	389	+ return new_cmdline;
	390	+}
	391	+
	392	+static int __init bootconfig_params(char param, char val,
250	393	const char unused, void arg)
	394	+{
	395	+ if (strcmp(param, "bootconfig") == 0) {
	396	+ bootconfig_found = true;
	397	+ }
	398	+ return 0;
	399	+}
	400	+
	401	+static void __init setup_boot_config(const char *cmdline)
	402	+{
	403	+ static char tmp_cmdline[COMMAND_LINE_SIZE] __initdata;
	404	+ const char *msg;
	405	+ int pos;
	406	+ u32 size, csum;
	407	+ char data, copy, *err;
	408	+ int ret;
	409	+
	410	+ /* Cut out the bootconfig data even if we have no bootconfig option */
	411	+ data = get_boot_config_from_initrd(&size, &csum);
	412	+
	413	+ strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
	414	+ err = parse_args("bootconfig", tmp_cmdline, NULL, 0, 0, 0, NULL,
	415	+ bootconfig_params);
	416	+
	417	+ if (IS_ERR(err) \|\| !bootconfig_found)
	418	+ return;
	419	+
	420	+ /* parse_args() stops at '--' and returns an address */
	421	+ if (err)
	422	+ initargs_found = true;
	423	+
	424	+ if (!data) {
	425	+ pr_err("'bootconfig' found on command line, but no bootconfig found\n");
	426	+ return;
	427	+ }
	428	+
	429	+ if (size >= XBC_DATA_MAX) {
	430	+ pr_err("bootconfig size %d greater than max size %d\n",
	431	+ size, XBC_DATA_MAX);
	432	+ return;
	433	+ }
	434	+
	435	+ if (xbc_calc_checksum(data, size) != csum) {
	436	+ pr_err("bootconfig checksum failed\n");
	437	+ return;
	438	+ }
	439	+
	440	+ copy = memblock_alloc(size + 1, SMP_CACHE_BYTES);
	441	+ if (!copy) {
	442	+ pr_err("Failed to allocate memory for bootconfig\n");
	443	+ return;
	444	+ }
	445	+
	446	+ memcpy(copy, data, size);
	447	+ copy[size] = '\0';
	448	+
	449	+ ret = xbc_init(copy, &msg, &pos);
	450	+ if (ret < 0) {
	451	+ if (pos < 0)
	452	+ pr_err("Failed to init bootconfig: %s.\n", msg);
	453	+ else
	454	+ pr_err("Failed to parse bootconfig: %s at %d.\n",
	455	+ msg, pos);
	456	+ } else {
	457	+ pr_info("Load bootconfig: %d bytes %d nodes\n", size, ret);
	458	+ /* keys starting with "kernel." are passed via cmdline */
	459	+ extra_command_line = xbc_make_cmdline("kernel");
	460	+ /* Also, "init." keys are init arguments */
	461	+ extra_init_args = xbc_make_cmdline("init");
	462	+ }
	463	+ return;
	464	+}
	465	+
	466	+#else
	467	+
	468	+static void __init setup_boot_config(const char *cmdline)
	469	+{
	470	+ /* Remove bootconfig data from initrd */
	471	+ get_boot_config_from_initrd(NULL, NULL);
	472	+}
	473	+
	474	+static int __init warn_bootconfig(char *str)
	475	+{
	476	+ pr_warn("WARNING: 'bootconfig' found on the kernel command line but CONFIG_BOOT_CONFIG is not set.\n");
	477	+ return 0;
	478	+}
	479	+early_param("bootconfig", warn_bootconfig);
	480	+
	481	+#endif
	482	+
	483	+/* Change NUL term back to "=", to make "param" the whole string. */
	484	+static void __init repair_env_string(char param, char val)
251	485	{
252	486	if (val) {
253	487	/* param=val or param="val"? */
..	..	@@ -256,11 +490,9 @@
256	490	else if (val == param+strlen(param)+2) {
257	491	val[-2] = '=';
258	492	memmove(val-1, val, strlen(val)+1);
259		- val--;
260	493	} else
261	494	BUG();
262	495	}
263		- return 0;
264	496	}
265	497
266	498	/* Anything after -- gets handed straight to init. */
..	..	@@ -272,7 +504,7 @@
272	504	if (panic_later)
273	505	return 0;
274	506
275		- repair_env_string(param, val, unused, NULL);
	507	+ repair_env_string(param, val);
276	508
277	509	for (i = 0; argv_init[i]; i++) {
278	510	if (i == MAX_INIT_ARGS) {
..	..	@@ -292,14 +524,16 @@
292	524	static int __init unknown_bootoption(char param, char val,
293	525	const char unused, void arg)
294	526	{
295		- repair_env_string(param, val, unused, NULL);
	527	+ size_t len = strlen(param);
	528	+
	529	+ repair_env_string(param, val);
296	530
297	531	/* Handle obsolete-style parameters */
298	532	if (obsolete_checksetup(param))
299	533	return 0;
300	534
301	535	/* Unused module parameter. */
302		- if (strchr(param, '.') && (!val \|\| strchr(param, '.') < val))
	536	+ if (strnchr(param, len, '.'))
303	537	return 0;
304	538
305	539	if (panic_later)
..	..	@@ -313,7 +547,7 @@
313	547	panic_later = "env";
314	548	panic_param = param;
315	549	}
316		- if (!strncmp(param, envp_init[i], val - param))
	550	+ if (!strncmp(param, envp_init[i], len+1))
317	551	break;
318	552	}
319	553	envp_init[i] = param;
..	..	@@ -374,13 +608,51 @@
374	608	*/
375	609	static void __init setup_command_line(char *command_line)
376	610	{
377		- saved_command_line =
378		- memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
379		- initcall_command_line =
380		- memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
381		- static_command_line = memblock_virt_alloc(strlen(command_line) + 1, 0);
382		- strcpy(saved_command_line, boot_command_line);
383		- strcpy(static_command_line, command_line);
	611	+ size_t len, xlen = 0, ilen = 0;
	612	+
	613	+ if (extra_command_line)
	614	+ xlen = strlen(extra_command_line);
	615	+ if (extra_init_args)
	616	+ ilen = strlen(extra_init_args) + 4; /* for " -- " */
	617	+
	618	+ len = xlen + strlen(boot_command_line) + 1;
	619	+
	620	+ saved_command_line = memblock_alloc(len + ilen, SMP_CACHE_BYTES);
	621	+ if (!saved_command_line)
	622	+ panic("%s: Failed to allocate %zu bytes\n", __func__, len + ilen);
	623	+
	624	+ static_command_line = memblock_alloc(len, SMP_CACHE_BYTES);
	625	+ if (!static_command_line)
	626	+ panic("%s: Failed to allocate %zu bytes\n", __func__, len);
	627	+
	628	+ if (xlen) {
	629	+ /*
	630	+ * We have to put extra_command_line before boot command
	631	+ * lines because there could be dashes (separator of init
	632	+ * command line) in the command lines.
	633	+ */
	634	+ strcpy(saved_command_line, extra_command_line);
	635	+ strcpy(static_command_line, extra_command_line);
	636	+ }
	637	+ strcpy(saved_command_line + xlen, boot_command_line);
	638	+ strcpy(static_command_line + xlen, command_line);
	639	+
	640	+ if (ilen) {
	641	+ /*
	642	+ * Append supplemental init boot args to saved_command_line
	643	+ * so that user can check what command line options passed
	644	+ * to init.
	645	+ */
	646	+ len = strlen(saved_command_line);
	647	+ if (initargs_found) {
	648	+ saved_command_line[len++] = ' ';
	649	+ } else {
	650	+ strcpy(saved_command_line + len, " -- ");
	651	+ len += 4;
	652	+ }
	653	+
	654	+ strcpy(saved_command_line + len, extra_init_args);
	655	+ }
384	656	}
385	657
386	658	/*
..	..	@@ -394,7 +666,7 @@
394	666
395	667	static __initdata DECLARE_COMPLETION(kthreadd_done);
396	668
397		-static noinline void __ref rest_init(void)
	669	+noinline void __ref rest_init(void)
398	670	{
399	671	struct task_struct *tsk;
400	672	int pid;
..	..	@@ -424,7 +696,7 @@
424	696
425	697	/*
426	698	* Enable might_sleep() and smp_processor_id() checks.
427		- * They cannot be enabled earlier because with CONFIG_PREEMPT=y
	699	+ * They cannot be enabled earlier because with CONFIG_PREEMPTION=y
428	700	* kernel_thread() would trigger might_sleep() splats. With
429	701	* CONFIG_PREEMPT_VOLUNTARY=y the init task might have scheduled
430	702	* already, but it's stuck on the kthreadd_done completion.
..	..	@@ -496,6 +768,10 @@
496	768
497	769	void __init __weak mem_encrypt_init(void) { }
498	770
	771	+void __init __weak poking_init(void) { }
	772	+
	773	+void __init __weak pgtable_cache_init(void) { }
	774	+
499	775	bool initcall_debug;
500	776	core_param(initcall_debug, initcall_debug, bool, 0644);
501	777
..	..	@@ -542,10 +818,17 @@
542	818	* bigger than MAX_ORDER unless SPARSEMEM.
543	819	*/
544	820	page_ext_init_flatmem();
	821	+ init_mem_debugging_and_hardening();
	822	+ kfence_alloc_pool();
545	823	report_meminit();
	824	+ stack_depot_init();
546	825	mem_init();
	826	+ /* page_owner must be initialized after buddy is ready */
	827	+ page_ext_init_flatmem_late();
547	828	kmem_cache_init();
	829	+ kmemleak_init();
548	830	pgtable_init();
	831	+ debug_objects_mem_init();
549	832	vmalloc_init();
550	833	ioremap_huge_init();
551	834	/* Should be run before the first non-init thread is created */
..	..	@@ -554,7 +837,12 @@
554	837	pti_init();
555	838	}
556	839
557		-asmlinkage __visible void __init start_kernel(void)
	840	+void __init __weak arch_call_rest_init(void)
	841	+{
	842	+ rest_init();
	843	+}
	844	+
	845	+asmlinkage __visible void __init __no_sanitize_address start_kernel(void)
558	846	{
559	847	char *command_line;
560	848	char *after_dashes;
..	..	@@ -575,8 +863,9 @@
575	863	boot_cpu_init();
576	864	page_address_init();
577	865	pr_notice("%s", linux_banner);
	866	+ early_security_init();
578	867	setup_arch(&command_line);
579		- mm_init_cpumask(&init_mm);
	868	+ setup_boot_config(command_line);
580	869	setup_command_line(command_line);
581	870	setup_nr_cpu_ids();
582	871	setup_per_cpu_areas();
..	..	@@ -588,10 +877,10 @@
588	877
589	878	#ifdef CONFIG_ARCH_ROCKCHIP
590	879	{
591		- const char *s = boot_command_line;
592		- const char *e = &boot_command_line[strlen(boot_command_line)];
	880	+ const char *s = saved_command_line;
	881	+ const char *e = &saved_command_line[strlen(saved_command_line)];
593	882	int n =
594		- pr_notice("Kernel command line: %s\n", boot_command_line);
	883	+ pr_notice("Kernel command line: %s\n", saved_command_line);
595	884	n -= strlen("Kernel command line: ");
596	885	s += n;
597	886	/* command line maybe too long to print one time */
..	..	@@ -601,7 +890,7 @@
601	890	}
602	891	}
603	892	#else
604		- pr_notice("Kernel command line: %s\n", boot_command_line);
	893	+ pr_notice("Kernel command line: %s\n", saved_command_line);
605	894	#endif
606	895	/* parameters may set static keys */
607	896	jump_label_init();
..	..	@@ -613,6 +902,9 @@
613	902	if (!IS_ERR_OR_NULL(after_dashes))
614	903	parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
615	904	NULL, set_init_arg);
	905	+ if (extra_init_args)
	906	+ parse_args("Setting extra init args", extra_init_args,
	907	+ NULL, 0, -1, -1, NULL, set_init_arg);
616	908
617	909	/*
618	910	* These use large bootmem allocations and must precede
..	..	@@ -635,11 +927,7 @@
635	927	* time - but meanwhile we still have a functioning scheduler.
636	928	*/
637	929	sched_init();
638		- /*
639		- * Disable preemption - early bootup scheduling is extremely
640		- * fragile until we cpu_idle() for the first time.
641		- */
642		- preempt_disable();
	930	+
643	931	if (WARN(!irqs_disabled(),
644	932	"Interrupts were enabled very early, fixing it\n"))
645	933	local_irq_disable();
..	..	@@ -676,21 +964,19 @@
676	964	hrtimers_init();
677	965	softirq_init();
678	966	timekeeping_init();
	967	+ kfence_init();
	968	+ time_init();
679	969
680	970	/*
681	971	* For best initial stack canary entropy, prepare it after:
682	972	* - setup_arch() for any UEFI RNG entropy and boot cmdline access
683		- * - timekeeping_init() for ktime entropy used in rand_initialize()
684		- * - rand_initialize() to get any arch-specific entropy like RDRAND
685		- * - add_latent_entropy() to get any latent entropy
686		- * - adding command line entropy
	973	+ * - timekeeping_init() for ktime entropy used in random_init()
	974	+ * - time_init() for making random_get_entropy() work on some platforms
	975	+ * - random_init() to initialize the RNG from from early entropy sources
687	976	*/
688		- rand_initialize();
689		- add_latent_entropy();
690		- add_device_randomness(command_line, strlen(command_line));
	977	+ random_init(command_line);
691	978	boot_init_stack_canary();
692	979
693		- time_init();
694	980	perf_event_init();
695	981	profile_init();
696	982	call_function_init();
..	..	@@ -737,8 +1023,6 @@
737	1023	initrd_start = 0;
738	1024	}
739	1025	#endif
740		- kmemleak_init();
741		- debug_objects_mem_init();
742	1026	setup_per_cpu_pageset();
743	1027	numa_policy_init();
744	1028	acpi_early_init();
..	..	@@ -772,18 +1056,16 @@
772	1056	taskstats_init_early();
773	1057	delayacct_init();
774	1058
	1059	+ poking_init();
775	1060	check_bugs();
776	1061
777	1062	acpi_subsystem_init();
778	1063	arch_post_acpi_subsys_init();
779	1064	sfi_init_late();
780		-
781		- if (efi_enabled(EFI_RUNTIME_SERVICES)) {
782		- efi_free_boot_services();
783		- }
	1065	+ kcsan_init();
784	1066
785	1067	/* Do the rest non-__init'ed, we're now alive */
786		- rest_init();
	1068	+ arch_call_rest_init();
787	1069
788	1070	prevent_tail_call_optimization();
789	1071	}
..	..	@@ -817,14 +1099,22 @@
817	1099	str_entry = strsep(&str, ",");
818	1100	if (str_entry) {
819	1101	pr_debug("blacklisting initcall %s\n", str_entry);
820		- entry = alloc_bootmem(sizeof(*entry));
821		- entry->buf = alloc_bootmem(strlen(str_entry) + 1);
	1102	+ entry = memblock_alloc(sizeof(*entry),
	1103	+ SMP_CACHE_BYTES);
	1104	+ if (!entry)
	1105	+ panic("%s: Failed to allocate %zu bytes\n",
	1106	+ __func__, sizeof(*entry));
	1107	+ entry->buf = memblock_alloc(strlen(str_entry) + 1,
	1108	+ SMP_CACHE_BYTES);
	1109	+ if (!entry->buf)
	1110	+ panic("%s: Failed to allocate %zu bytes\n",
	1111	+ __func__, strlen(str_entry) + 1);
822	1112	strcpy(entry->buf, str_entry);
823	1113	list_add(&entry->next, &blacklisted_initcalls);
824	1114	}
825	1115	} while (str_entry);
826	1116
827		- return 0;
	1117	+ return 1;
828	1118	}
829	1119
830	1120	static bool __init_or_module initcall_blacklisted(initcall_t fn)
..	..	@@ -873,7 +1163,7 @@
873	1163	{
874	1164	ktime_t calltime = (ktime_t )data;
875	1165
876		- printk(KERN_DEBUG "calling %pF @ %i\n", fn, task_pid_nr(current));
	1166	+ printk(KERN_DEBUG "calling %pS @ %i\n", fn, task_pid_nr(current));
877	1167	*calltime = ktime_get();
878	1168	}
879	1169
..	..	@@ -887,7 +1177,7 @@
887	1177	rettime = ktime_get();
888	1178	delta = ktime_sub(rettime, *calltime);
889	1179	duration = (unsigned long long) ktime_to_ns(delta) >> 10;
890		- printk(KERN_DEBUG "initcall %pF returned %d after %lld usecs\n",
	1180	+ printk(KERN_DEBUG "initcall %pS returned %d after %lld usecs\n",
891	1181	fn, ret, duration);
892	1182	}
893	1183
..	..	@@ -944,7 +1234,7 @@
944	1234	strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
945	1235	local_irq_enable();
946	1236	}
947		- WARN(msgbuf[0], "initcall %pF returned with %s\n", fn, msgbuf);
	1237	+ WARN(msgbuf[0], "initcall %pS returned with %s\n", fn, msgbuf);
948	1238
949	1239	add_latent_entropy();
950	1240	return ret;
..	..	@@ -975,7 +1265,7 @@
975	1265	};
976	1266
977	1267	/* Keep these in sync with initcalls in include/linux/init.h */
978		-static char *initcall_level_names[] __initdata = {
	1268	+static const char *initcall_level_names[] __initdata = {
979	1269	"pure",
980	1270	"core",
981	1271	"postcore",
..	..	@@ -985,6 +1275,12 @@
985	1275	"device",
986	1276	"late",
987	1277	};
	1278	+
	1279	+static int __init ignore_unknown_bootoption(char param, char val,
	1280	+ const char unused, void arg)
	1281	+{
	1282	+ return 0;
	1283	+}
988	1284
989	1285	#ifdef CONFIG_INITCALL_ASYNC
990	1286	extern initcall_entry_t __initcall0s_start[];
..	..	@@ -1163,16 +1459,15 @@
1163	1459	}
1164	1460	#endif /* CONFIG_INITCALL_ASYNC */
1165	1461
1166		-static void __init do_initcall_level(int level)
	1462	+static void __init do_initcall_level(int level, char *command_line)
1167	1463	{
1168	1464	initcall_entry_t *fn;
1169	1465
1170		- strcpy(initcall_command_line, saved_command_line);
1171	1466	parse_args(initcall_level_names[level],
1172		- initcall_command_line, __start___param,
	1467	+ command_line, __start___param,
1173	1468	__stop___param - __start___param,
1174	1469	level, level,
1175		- NULL, &repair_env_string);
	1470	+ NULL, ignore_unknown_bootoption);
1176	1471
1177	1472	trace_initcall_level(initcall_level_names[level]);
1178	1473
..	..	@@ -1189,13 +1484,24 @@
1189	1484	static void __init do_initcalls(void)
1190	1485	{
1191	1486	int level;
	1487	+ size_t len = strlen(saved_command_line) + 1;
	1488	+ char *command_line;
1192	1489
1193	1490	#ifdef CONFIG_INITCALL_ASYNC
1194	1491	initcall_init_workers();
1195	1492	#endif
1196	1493
1197		- for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
1198		- do_initcall_level(level);
	1494	+ command_line = kzalloc(len, GFP_KERNEL);
	1495	+ if (!command_line)
	1496	+ panic("%s: Failed to allocate %zu bytes\n", __func__, len);
	1497	+
	1498	+ for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++) {
	1499	+ /* Parser modifies command_line, restore it each time */
	1500	+ strcpy(command_line, saved_command_line);
	1501	+ do_initcall_level(level, command_line);
	1502	+ }
	1503	+
	1504	+ kfree(command_line);
1199	1505
1200	1506	#ifdef CONFIG_INITCALL_ASYNC
1201	1507	initcall_free_works();
..	..	@@ -1212,7 +1518,6 @@
1212	1518	static void __init do_basic_setup(void)
1213	1519	{
1214	1520	cpuset_init_smp();
1215		- shmem_init();
1216	1521	driver_init();
1217	1522	init_irq_proc();
1218	1523	do_ctors();
..	..	@@ -1229,24 +1534,19 @@
1229	1534	do_one_initcall(initcall_from_entry(fn));
1230	1535	}
1231	1536
1232		-/*
1233		- * This function requests modules which should be loaded by default and is
1234		- * called twice right after initrd is mounted and right before init is
1235		- * exec'd. If such modules are on either initrd or rootfs, they will be
1236		- * loaded before control is passed to userland.
1237		- */
1238		-void __init load_default_modules(void)
1239		-{
1240		- load_default_elevator_module();
1241		-}
1242		-
1243	1537	static int run_init_process(const char *init_filename)
1244	1538	{
	1539	+ const char const p;
	1540	+
1245	1541	argv_init[0] = init_filename;
1246	1542	pr_info("Run %s as init process\n", init_filename);
1247		- return do_execve(getname_kernel(init_filename),
1248		- (const char __user const __user )argv_init,
1249		- (const char __user const __user )envp_init);
	1543	+ pr_debug(" with arguments:\n");
	1544	+ for (p = argv_init; *p; p++)
	1545	+ pr_debug(" %s\n", *p);
	1546	+ pr_debug(" with environment:\n");
	1547	+ for (p = envp_init; *p; p++)
	1548	+ pr_debug(" %s\n", *p);
	1549	+ return kernel_execve(init_filename, argv_init, envp_init);
1250	1550	}
1251	1551
1252	1552	static int try_to_run_init_process(const char *init_filename)
..	..	@@ -1269,7 +1569,9 @@
1269	1569	bool rodata_enabled __ro_after_init = true;
1270	1570	static int __init set_debug_rodata(char *str)
1271	1571	{
1272		- return strtobool(str, &rodata_enabled);
	1572	+ if (strtobool(str, &rodata_enabled))
	1573	+ pr_warn("Invalid option string for rodata: '%s'\n", str);
	1574	+ return 1;
1273	1575	}
1274	1576	__setup("rodata=", set_debug_rodata);
1275	1577	#endif
..	..	@@ -1279,16 +1581,21 @@
1279	1581	{
1280	1582	if (rodata_enabled) {
1281	1583	/*
1282		- * load_module() results in W+X mappings, which are cleaned up
1283		- * with call_rcu_sched(). Let's make sure that queued work is
	1584	+ * load_module() results in W+X mappings, which are cleaned
	1585	+ * up with call_rcu(). Let's make sure that queued work is
1284	1586	* flushed so that we don't hit false positives looking for
1285	1587	* insecure pages which are W+X.
1286	1588	*/
1287		- rcu_barrier_sched();
	1589	+ rcu_barrier();
1288	1590	mark_rodata_ro();
1289	1591	rodata_test();
1290	1592	} else
1291	1593	pr_info("Kernel memory protection disabled.\n");
	1594	+}
	1595	+#elif defined(CONFIG_ARCH_HAS_STRICT_KERNEL_RWX)
	1596	+static inline void mark_readonly(void)
	1597	+{
	1598	+ pr_warn("Kernel memory protection not selected by kernel config.\n");
1292	1599	}
1293	1600	#else
1294	1601	static inline void mark_readonly(void)
..	..	@@ -1297,6 +1604,11 @@
1297	1604	}
1298	1605	#endif
1299	1606
	1607	+void __weak free_initmem(void)
	1608	+{
	1609	+ free_initmem_default(POISON_FREE_INITMEM);
	1610	+}
	1611	+
1300	1612	static int __ref kernel_init(void *unused)
1301	1613	{
1302	1614	int ret;
..	..	@@ -1304,8 +1616,9 @@
1304	1616	kernel_init_freeable();
1305	1617	/* need to finish all async __init code before freeing the memory */
1306	1618	async_synchronize_full();
	1619	+ kprobe_free_init_mem();
1307	1620	ftrace_free_init_mem();
1308		- jump_label_invalidate_initmem();
	1621	+ kgdb_free_init_mem();
1309	1622	free_initmem();
1310	1623	mark_readonly();
1311	1624
..	..	@@ -1319,6 +1632,8 @@
1319	1632	numa_default_policy();
1320	1633
1321	1634	rcu_end_inkernel_boot();
	1635	+
	1636	+ do_sysctl_args();
1322	1637
1323	1638	if (ramdisk_execute_command) {
1324	1639	ret = run_init_process(ramdisk_execute_command);
..	..	@@ -1341,6 +1656,16 @@
1341	1656	panic("Requested init %s failed (error %d).",
1342	1657	execute_command, ret);
1343	1658	}
	1659	+
	1660	+ if (CONFIG_DEFAULT_INIT[0] != '\0') {
	1661	+ ret = run_init_process(CONFIG_DEFAULT_INIT);
	1662	+ if (ret)
	1663	+ pr_err("Default init %s failed (error %d)\n",
	1664	+ CONFIG_DEFAULT_INIT, ret);
	1665	+ else
	1666	+ return 0;
	1667	+ }
	1668	+
1344	1669	if (!try_to_run_init_process("/sbin/init") \|\|
1345	1670	!try_to_run_init_process("/etc/init") \|\|
1346	1671	!try_to_run_init_process("/bin/init") \|\|
..	..	@@ -1349,6 +1674,21 @@
1349	1674
1350	1675	panic("No working init found. Try passing init= option to kernel. "
1351	1676	"See Linux Documentation/admin-guide/init.rst for guidance.");
	1677	+}
	1678	+
	1679	+/* Open /dev/console, for stdin/stdout/stderr, this should never fail */
	1680	+void __init console_on_rootfs(void)
	1681	+{
	1682	+ struct file *file = filp_open("/dev/console", O_RDWR, 0);
	1683	+
	1684	+ if (IS_ERR(file)) {
	1685	+ pr_err("Warning: unable to open an initial console.\n");
	1686	+ return;
	1687	+ }
	1688	+ init_dup(file);
	1689	+ init_dup(file);
	1690	+ init_dup(file);
	1691	+ fput(file);
1352	1692	}
1353	1693
1354	1694	static noinline void __init kernel_init_freeable(void)
..	..	@@ -1374,42 +1714,37 @@
1374	1714
1375	1715	init_mm_internals();
1376	1716
	1717	+ rcu_init_tasks_generic();
1377	1718	do_pre_smp_initcalls();
1378	1719	lockup_detector_init();
1379	1720
1380	1721	smp_init();
1381	1722	sched_init_smp();
1382	1723
1383		-#ifdef CONFIG_ROCKCHIP_THUNDER_BOOT
1384		- kthread_run(defer_free_bootmem, NULL, "defer_mem");
	1724	+#if defined(CONFIG_ROCKCHIP_THUNDER_BOOT) && defined(CONFIG_SMP)
	1725	+ kthread_run(defer_free_memblock, NULL, "defer_mem");
1385	1726	#endif
1386	1727
	1728	+ padata_init();
1387	1729	page_alloc_init_late();
1388	1730	/* Initialize page ext after all struct pages are initialized. */
1389	1731	page_ext_init();
1390	1732
1391	1733	do_basic_setup();
1392	1734
	1735	+ kunit_run_all_tests();
	1736	+
1393	1737	#if IS_BUILTIN(CONFIG_INITRD_ASYNC)
1394	1738	async_synchronize_full();
1395	1739	#endif
1396	1740
1397		- /* Open the /dev/console on the rootfs, this should never fail */
1398		- if (ksys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
1399		- pr_err("Warning: unable to open an initial console.\n");
	1741	+ console_on_rootfs();
1400	1742
1401		- (void) ksys_dup(0);
1402		- (void) ksys_dup(0);
1403	1743	/*
1404	1744	* check if there is an early userspace init. If yes, let it do all
1405	1745	* the work
1406	1746	*/
1407		-
1408		- if (!ramdisk_execute_command)
1409		- ramdisk_execute_command = "/init";
1410		-
1411		- if (ksys_access((const char __user *)
1412		- ramdisk_execute_command, 0) != 0) {
	1747	+ if (init_eaccess(ramdisk_execute_command) != 0) {
1413	1748	ramdisk_execute_command = NULL;
1414	1749	prepare_namespace();
1415	1750	}
..	..	@@ -1424,5 +1759,4 @@
1424	1759	*/
1425	1760
1426	1761	integrity_load_keys();
1427		- load_default_modules();
1428	1762	}