LCOV - code coverage report
Current view: top level - init - main.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 263 378 69.6 %
Date: 2020-09-30 20:25:40 Functions: 30 43 69.8 %
Branches: 77 156 49.4 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  *  linux/init/main.c
       4                 :            :  *
       5                 :            :  *  Copyright (C) 1991, 1992  Linus Torvalds
       6                 :            :  *
       7                 :            :  *  GK 2/5/95  -  Changed to support mounting root fs via NFS
       8                 :            :  *  Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96
       9                 :            :  *  Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96
      10                 :            :  *  Simplified starting of init:  Michael A. Griffith <grif@acm.org>
      11                 :            :  */
      12                 :            : 
      13                 :            : #define DEBUG           /* Enable initcall_debug */
      14                 :            : 
      15                 :            : #include <linux/types.h>
      16                 :            : #include <linux/extable.h>
      17                 :            : #include <linux/module.h>
      18                 :            : #include <linux/proc_fs.h>
      19                 :            : #include <linux/binfmts.h>
      20                 :            : #include <linux/kernel.h>
      21                 :            : #include <linux/syscalls.h>
      22                 :            : #include <linux/stackprotector.h>
      23                 :            : #include <linux/string.h>
      24                 :            : #include <linux/ctype.h>
      25                 :            : #include <linux/delay.h>
      26                 :            : #include <linux/ioport.h>
      27                 :            : #include <linux/init.h>
      28                 :            : #include <linux/initrd.h>
      29                 :            : #include <linux/memblock.h>
      30                 :            : #include <linux/acpi.h>
      31                 :            : #include <linux/console.h>
      32                 :            : #include <linux/nmi.h>
      33                 :            : #include <linux/percpu.h>
      34                 :            : #include <linux/kmod.h>
      35                 :            : #include <linux/vmalloc.h>
      36                 :            : #include <linux/kernel_stat.h>
      37                 :            : #include <linux/start_kernel.h>
      38                 :            : #include <linux/security.h>
      39                 :            : #include <linux/smp.h>
      40                 :            : #include <linux/profile.h>
      41                 :            : #include <linux/rcupdate.h>
      42                 :            : #include <linux/moduleparam.h>
      43                 :            : #include <linux/kallsyms.h>
      44                 :            : #include <linux/writeback.h>
      45                 :            : #include <linux/cpu.h>
      46                 :            : #include <linux/cpuset.h>
      47                 :            : #include <linux/cgroup.h>
      48                 :            : #include <linux/efi.h>
      49                 :            : #include <linux/tick.h>
      50                 :            : #include <linux/sched/isolation.h>
      51                 :            : #include <linux/interrupt.h>
      52                 :            : #include <linux/taskstats_kern.h>
      53                 :            : #include <linux/delayacct.h>
      54                 :            : #include <linux/unistd.h>
      55                 :            : #include <linux/utsname.h>
      56                 :            : #include <linux/rmap.h>
      57                 :            : #include <linux/mempolicy.h>
      58                 :            : #include <linux/key.h>
      59                 :            : #include <linux/buffer_head.h>
      60                 :            : #include <linux/page_ext.h>
      61                 :            : #include <linux/debug_locks.h>
      62                 :            : #include <linux/debugobjects.h>
      63                 :            : #include <linux/lockdep.h>
      64                 :            : #include <linux/kmemleak.h>
      65                 :            : #include <linux/pid_namespace.h>
      66                 :            : #include <linux/device.h>
      67                 :            : #include <linux/kthread.h>
      68                 :            : #include <linux/sched.h>
      69                 :            : #include <linux/sched/init.h>
      70                 :            : #include <linux/signal.h>
      71                 :            : #include <linux/idr.h>
      72                 :            : #include <linux/kgdb.h>
      73                 :            : #include <linux/ftrace.h>
      74                 :            : #include <linux/async.h>
      75                 :            : #include <linux/sfi.h>
      76                 :            : #include <linux/shmem_fs.h>
      77                 :            : #include <linux/slab.h>
      78                 :            : #include <linux/perf_event.h>
      79                 :            : #include <linux/ptrace.h>
      80                 :            : #include <linux/pti.h>
      81                 :            : #include <linux/blkdev.h>
      82                 :            : #include <linux/elevator.h>
      83                 :            : #include <linux/sched/clock.h>
      84                 :            : #include <linux/sched/task.h>
      85                 :            : #include <linux/sched/task_stack.h>
      86                 :            : #include <linux/context_tracking.h>
      87                 :            : #include <linux/random.h>
      88                 :            : #include <linux/list.h>
      89                 :            : #include <linux/integrity.h>
      90                 :            : #include <linux/proc_ns.h>
      91                 :            : #include <linux/io.h>
      92                 :            : #include <linux/cache.h>
      93                 :            : #include <linux/rodata_test.h>
      94                 :            : #include <linux/jump_label.h>
      95                 :            : #include <linux/mem_encrypt.h>
      96                 :            : 
      97                 :            : #include <asm/io.h>
      98                 :            : #include <asm/bugs.h>
      99                 :            : #include <asm/setup.h>
     100                 :            : #include <asm/sections.h>
     101                 :            : #include <asm/cacheflush.h>
     102                 :            : 
     103                 :            : #define CREATE_TRACE_POINTS
     104                 :            : #include <trace/events/initcall.h>
     105                 :            : 
     106                 :            : static int kernel_init(void *);
     107                 :            : 
     108                 :            : extern void init_IRQ(void);
     109                 :            : extern void radix_tree_init(void);
     110                 :            : 
     111                 :            : /*
     112                 :            :  * Debug helper: via this flag we know that we are in 'early bootup code'
     113                 :            :  * where only the boot processor is running with IRQ disabled.  This means
     114                 :            :  * two things - IRQ must not be enabled before the flag is cleared and some
     115                 :            :  * operations which are not allowed with IRQ disabled are allowed while the
     116                 :            :  * flag is set.
     117                 :            :  */
     118                 :            : bool early_boot_irqs_disabled __read_mostly;
     119                 :            : 
     120                 :            : enum system_states system_state __read_mostly;
     121                 :            : EXPORT_SYMBOL(system_state);
     122                 :            : 
     123                 :            : /*
     124                 :            :  * Boot command-line arguments
     125                 :            :  */
     126                 :            : #define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT
     127                 :            : #define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT
     128                 :            : 
     129                 :            : extern void time_init(void);
     130                 :            : /* Default late time init is NULL. archs can override this later. */
     131                 :            : void (*__initdata late_time_init)(void);
     132                 :            : 
     133                 :            : /* Untouched command line saved by arch-specific code. */
     134                 :            : char __initdata boot_command_line[COMMAND_LINE_SIZE];
     135                 :            : /* Untouched saved command line (eg. for /proc) */
     136                 :            : char *saved_command_line;
     137                 :            : /* Command line for parameter parsing */
     138                 :            : static char *static_command_line;
     139                 :            : /* Command line for per-initcall parameter parsing */
     140                 :            : static char *initcall_command_line;
     141                 :            : 
     142                 :            : static char *execute_command;
     143                 :            : static char *ramdisk_execute_command;
     144                 :            : 
     145                 :            : /*
     146                 :            :  * Used to generate warnings if static_key manipulation functions are used
     147                 :            :  * before jump_label_init is called.
     148                 :            :  */
     149                 :            : bool static_key_initialized __read_mostly;
     150                 :            : EXPORT_SYMBOL_GPL(static_key_initialized);
     151                 :            : 
     152                 :            : /*
     153                 :            :  * If set, this is an indication to the drivers that reset the underlying
     154                 :            :  * device before going ahead with the initialization otherwise driver might
     155                 :            :  * rely on the BIOS and skip the reset operation.
     156                 :            :  *
     157                 :            :  * This is useful if kernel is booting in an unreliable environment.
     158                 :            :  * For ex. kdump situation where previous kernel has crashed, BIOS has been
     159                 :            :  * skipped and devices will be in unknown state.
     160                 :            :  */
     161                 :            : unsigned int reset_devices;
     162                 :            : EXPORT_SYMBOL(reset_devices);
     163                 :            : 
     164                 :          0 : static int __init set_reset_devices(char *str)
     165                 :            : {
     166                 :          0 :         reset_devices = 1;
     167                 :          0 :         return 1;
     168                 :            : }
     169                 :            : 
     170                 :            : __setup("reset_devices", set_reset_devices);
     171                 :            : 
     172                 :            : static const char *argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
     173                 :            : const char *envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
     174                 :            : static const char *panic_later, *panic_param;
     175                 :            : 
     176                 :            : extern const struct obs_kernel_param __setup_start[], __setup_end[];
     177                 :            : 
     178                 :       2898 : static bool __init obsolete_checksetup(char *line)
     179                 :            : {
     180                 :            :         const struct obs_kernel_param *p;
     181                 :            :         bool had_early_param = false;
     182                 :            : 
     183                 :            :         p = __setup_start;
     184                 :            :         do {
     185                 :     316710 :                 int n = strlen(p->str);
     186         [ +  + ]:     316710 :                 if (parameqn(line, p->str, n)) {
     187         [ +  + ]:       1449 :                         if (p->early) {
     188                 :            :                                 /* Already done in parse_early_param?
     189                 :            :                                  * (Needs exact match on param part).
     190                 :            :                                  * Keep iterating, as we can have early
     191                 :            :                                  * params and __setups of same names 8( */
     192         [ +  - ]:        414 :                                 if (line[n] == '\0' || line[n] == '=')
     193                 :            :                                         had_early_param = true;
     194         [ -  + ]:       1035 :                         } else if (!p->setup_func) {
     195                 :          0 :                                 pr_warn("Parameter %s is obsolete, ignored\n",
     196                 :            :                                         p->str);
     197                 :          0 :                                 return true;
     198         [ -  + ]:       1035 :                         } else if (p->setup_func(line + n))
     199                 :            :                                 return true;
     200                 :            :                 }
     201                 :     315675 :                 p++;
     202         [ +  + ]:     315675 :         } while (p < __setup_end);
     203                 :            : 
     204                 :       1863 :         return had_early_param;
     205                 :            : }
     206                 :            : 
     207                 :            : /*
     208                 :            :  * This should be approx 2 Bo*oMips to start (note initial shift), and will
     209                 :            :  * still work even if initially too large, it will just take slightly longer
     210                 :            :  */
     211                 :            : unsigned long loops_per_jiffy = (1<<12);
     212                 :            : EXPORT_SYMBOL(loops_per_jiffy);
     213                 :            : 
     214                 :          0 : static int __init debug_kernel(char *str)
     215                 :            : {
     216                 :          0 :         console_loglevel = CONSOLE_LOGLEVEL_DEBUG;
     217                 :          0 :         return 0;
     218                 :            : }
     219                 :            : 
     220                 :        207 : static int __init quiet_kernel(char *str)
     221                 :            : {
     222                 :        207 :         console_loglevel = CONSOLE_LOGLEVEL_QUIET;
     223                 :        207 :         return 0;
     224                 :            : }
     225                 :            : 
     226                 :            : early_param("debug", debug_kernel);
     227                 :            : early_param("quiet", quiet_kernel);
     228                 :            : 
     229                 :          0 : static int __init loglevel(char *str)
     230                 :            : {
     231                 :            :         int newlevel;
     232                 :            : 
     233                 :            :         /*
     234                 :            :          * Only update loglevel value when a correct setting was passed,
     235                 :            :          * to prevent blind crashes (when loglevel being set to 0) that
     236                 :            :          * are quite hard to debug
     237                 :            :          */
     238         [ #  # ]:          0 :         if (get_option(&str, &newlevel)) {
     239                 :          0 :                 console_loglevel = newlevel;
     240                 :          0 :                 return 0;
     241                 :            :         }
     242                 :            : 
     243                 :            :         return -EINVAL;
     244                 :            : }
     245                 :            : 
     246                 :            : early_param("loglevel", loglevel);
     247                 :            : 
     248                 :            : /* Change NUL term back to "=", to make "param" the whole string. */
     249                 :      26082 : static int __init repair_env_string(char *param, char *val,
     250                 :            :                                     const char *unused, void *arg)
     251                 :            : {
     252         [ +  + ]:      26082 :         if (val) {
     253                 :            :                 /* param=val or param="val"? */
     254         [ +  - ]:      18630 :                 if (val == param+strlen(param)+1)
     255                 :      18630 :                         val[-1] = '=';
     256         [ #  # ]:          0 :                 else if (val == param+strlen(param)+2) {
     257                 :          0 :                         val[-2] = '=';
     258                 :          0 :                         memmove(val-1, val, strlen(val)+1);
     259                 :            :                         val--;
     260                 :            :                 } else
     261                 :          0 :                         BUG();
     262                 :            :         }
     263                 :      26082 :         return 0;
     264                 :            : }
     265                 :            : 
     266                 :            : /* Anything after -- gets handed straight to init. */
     267                 :          0 : static int __init set_init_arg(char *param, char *val,
     268                 :            :                                const char *unused, void *arg)
     269                 :            : {
     270                 :            :         unsigned int i;
     271                 :            : 
     272         [ #  # ]:          0 :         if (panic_later)
     273                 :            :                 return 0;
     274                 :            : 
     275                 :          0 :         repair_env_string(param, val, unused, NULL);
     276                 :            : 
     277         [ #  # ]:          0 :         for (i = 0; argv_init[i]; i++) {
     278         [ #  # ]:          0 :                 if (i == MAX_INIT_ARGS) {
     279                 :          0 :                         panic_later = "init";
     280                 :          0 :                         panic_param = param;
     281                 :          0 :                         return 0;
     282                 :            :                 }
     283                 :            :         }
     284                 :          0 :         argv_init[i] = param;
     285                 :          0 :         return 0;
     286                 :            : }
     287                 :            : 
     288                 :            : /*
     289                 :            :  * Unknown boot options get handed to init, unless they look like
     290                 :            :  * unused parameters (modprobe will find them in /proc/cmdline).
     291                 :            :  */
     292                 :       2898 : static int __init unknown_bootoption(char *param, char *val,
     293                 :            :                                      const char *unused, void *arg)
     294                 :            : {
     295                 :       2898 :         repair_env_string(param, val, unused, NULL);
     296                 :            : 
     297                 :            :         /* Handle obsolete-style parameters */
     298         [ +  + ]:       2898 :         if (obsolete_checksetup(param))
     299                 :            :                 return 0;
     300                 :            : 
     301                 :            :         /* Unused module parameter. */
     302   [ +  +  +  +  :       1449 :         if (strchr(param, '.') && (!val || strchr(param, '.') < val))
                   -  + ]
     303                 :            :                 return 0;
     304                 :            : 
     305         [ +  - ]:        414 :         if (panic_later)
     306                 :            :                 return 0;
     307                 :            : 
     308         [ +  + ]:        414 :         if (val) {
     309                 :            :                 /* Environment option */
     310                 :            :                 unsigned int i;
     311         [ +  + ]:        414 :                 for (i = 0; envp_init[i]; i++) {
     312         [ -  + ]:        414 :                         if (i == MAX_INIT_ENVS) {
     313                 :          0 :                                 panic_later = "env";
     314                 :          0 :                                 panic_param = param;
     315                 :            :                         }
     316         [ +  - ]:        414 :                         if (!strncmp(param, envp_init[i], val - param))
     317                 :            :                                 break;
     318                 :            :                 }
     319                 :        207 :                 envp_init[i] = param;
     320                 :            :         } else {
     321                 :            :                 /* Command line option */
     322                 :            :                 unsigned int i;
     323         [ +  + ]:        207 :                 for (i = 0; argv_init[i]; i++) {
     324         [ -  + ]:        207 :                         if (i == MAX_INIT_ARGS) {
     325                 :          0 :                                 panic_later = "init";
     326                 :          0 :                                 panic_param = param;
     327                 :            :                         }
     328                 :            :                 }
     329                 :        207 :                 argv_init[i] = param;
     330                 :            :         }
     331                 :            :         return 0;
     332                 :            : }
     333                 :            : 
     334                 :          0 : static int __init init_setup(char *str)
     335                 :            : {
     336                 :            :         unsigned int i;
     337                 :            : 
     338                 :          0 :         execute_command = str;
     339                 :            :         /*
     340                 :            :          * In case LILO is going to boot us with default command line,
     341                 :            :          * it prepends "auto" before the whole cmdline which makes
     342                 :            :          * the shell think it should execute a script with such name.
     343                 :            :          * So we ignore all arguments entered _before_ init=... [MJ]
     344                 :            :          */
     345         [ #  # ]:          0 :         for (i = 1; i < MAX_INIT_ARGS; i++)
     346                 :          0 :                 argv_init[i] = NULL;
     347                 :          0 :         return 1;
     348                 :            : }
     349                 :            : __setup("init=", init_setup);
     350                 :            : 
     351                 :          0 : static int __init rdinit_setup(char *str)
     352                 :            : {
     353                 :            :         unsigned int i;
     354                 :            : 
     355                 :          0 :         ramdisk_execute_command = str;
     356                 :            :         /* See "auto" comment in init_setup */
     357         [ #  # ]:          0 :         for (i = 1; i < MAX_INIT_ARGS; i++)
     358                 :          0 :                 argv_init[i] = NULL;
     359                 :          0 :         return 1;
     360                 :            : }
     361                 :            : __setup("rdinit=", rdinit_setup);
     362                 :            : 
     363                 :            : #ifndef CONFIG_SMP
     364                 :            : static const unsigned int setup_max_cpus = NR_CPUS;
     365                 :            : static inline void setup_nr_cpu_ids(void) { }
     366                 :            : static inline void smp_prepare_cpus(unsigned int maxcpus) { }
     367                 :            : #endif
     368                 :            : 
     369                 :            : /*
     370                 :            :  * We need to store the untouched command line for future reference.
     371                 :            :  * We also need to store the touched command line since the parameter
     372                 :            :  * parsing is performed in place, and we should allow a component to
     373                 :            :  * store reference of name/value for future reference.
     374                 :            :  */
     375                 :        207 : static void __init setup_command_line(char *command_line)
     376                 :            : {
     377                 :        207 :         size_t len = strlen(boot_command_line) + 1;
     378                 :            : 
     379                 :        207 :         saved_command_line = memblock_alloc(len, SMP_CACHE_BYTES);
     380         [ -  + ]:        207 :         if (!saved_command_line)
     381                 :          0 :                 panic("%s: Failed to allocate %zu bytes\n", __func__, len);
     382                 :            : 
     383                 :        207 :         initcall_command_line = memblock_alloc(len, SMP_CACHE_BYTES);
     384         [ -  + ]:        207 :         if (!initcall_command_line)
     385                 :          0 :                 panic("%s: Failed to allocate %zu bytes\n", __func__, len);
     386                 :            : 
     387                 :        207 :         static_command_line = memblock_alloc(len, SMP_CACHE_BYTES);
     388         [ -  + ]:        207 :         if (!static_command_line)
     389                 :          0 :                 panic("%s: Failed to allocate %zu bytes\n", __func__, len);
     390                 :            : 
     391                 :        207 :         strcpy(saved_command_line, boot_command_line);
     392                 :        207 :         strcpy(static_command_line, command_line);
     393                 :        207 : }
     394                 :            : 
     395                 :            : /*
     396                 :            :  * We need to finalize in a non-__init function or else race conditions
     397                 :            :  * between the root thread and the init thread may cause start_kernel to
     398                 :            :  * be reaped by free_initmem before the root thread has proceeded to
     399                 :            :  * cpu_idle.
     400                 :            :  *
     401                 :            :  * gcc-3.4 accidentally inlines this function, so use noinline.
     402                 :            :  */
     403                 :            : 
     404                 :            : static __initdata DECLARE_COMPLETION(kthreadd_done);
     405                 :            : 
     406                 :        207 : noinline void __ref rest_init(void)
     407                 :            : {
     408                 :            :         struct task_struct *tsk;
     409                 :            :         int pid;
     410                 :            : 
     411                 :        207 :         rcu_scheduler_starting();
     412                 :            :         /*
     413                 :            :          * We need to spawn init first so that it obtains pid 1, however
     414                 :            :          * the init task will end up wanting to create kthreads, which, if
     415                 :            :          * we schedule it before we create kthreadd, will OOPS.
     416                 :            :          */
     417                 :        207 :         pid = kernel_thread(kernel_init, NULL, CLONE_FS);
     418                 :            :         /*
     419                 :            :          * Pin init on the boot CPU. Task migration is not properly working
     420                 :            :          * until sched_init_smp() has been run. It will set the allowed
     421                 :            :          * CPUs for init to the non isolated CPUs.
     422                 :            :          */
     423                 :            :         rcu_read_lock();
     424                 :        207 :         tsk = find_task_by_pid_ns(pid, &init_pid_ns);
     425                 :        414 :         set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id()));
     426                 :            :         rcu_read_unlock();
     427                 :            : 
     428                 :            :         numa_default_policy();
     429                 :        207 :         pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
     430                 :            :         rcu_read_lock();
     431                 :        207 :         kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
     432                 :            :         rcu_read_unlock();
     433                 :            : 
     434                 :            :         /*
     435                 :            :          * Enable might_sleep() and smp_processor_id() checks.
     436                 :            :          * They cannot be enabled earlier because with CONFIG_PREEMPTION=y
     437                 :            :          * kernel_thread() would trigger might_sleep() splats. With
     438                 :            :          * CONFIG_PREEMPT_VOLUNTARY=y the init task might have scheduled
     439                 :            :          * already, but it's stuck on the kthreadd_done completion.
     440                 :            :          */
     441                 :        207 :         system_state = SYSTEM_SCHEDULING;
     442                 :            : 
     443                 :        207 :         complete(&kthreadd_done);
     444                 :            : 
     445                 :            :         /*
     446                 :            :          * The boot idle thread must execute schedule()
     447                 :            :          * at least once to get things moving:
     448                 :            :          */
     449                 :        207 :         schedule_preempt_disabled();
     450                 :            :         /* Call into cpu_idle with preempt disabled */
     451                 :        207 :         cpu_startup_entry(CPUHP_ONLINE);
     452                 :          0 : }
     453                 :            : 
     454                 :            : /* Check for early params. */
     455                 :       3933 : static int __init do_early_param(char *param, char *val,
     456                 :            :                                  const char *unused, void *arg)
     457                 :            : {
     458                 :            :         const struct obs_kernel_param *p;
     459                 :            : 
     460         [ +  + ]:     613548 :         for (p = __setup_start; p < __setup_end; p++) {
     461   [ +  +  +  +  :    1218816 :                 if ((p->early && parameq(param, p->str)) ||
                   +  + ]
     462         [ +  + ]:     673371 :                     (strcmp(param, "console") == 0 &&
     463                 :      64170 :                      strcmp(p->str, "earlycon") == 0)
     464                 :            :                 ) {
     465         [ -  + ]:        828 :                         if (p->setup_func(val) != 0)
     466                 :          0 :                                 pr_warn("Malformed early option '%s'\n", param);
     467                 :            :                 }
     468                 :            :         }
     469                 :            :         /* We accept everything at this stage. */
     470                 :       3933 :         return 0;
     471                 :            : }
     472                 :            : 
     473                 :        207 : void __init parse_early_options(char *cmdline)
     474                 :            : {
     475                 :        207 :         parse_args("early options", cmdline, NULL, 0, 0, 0, NULL,
     476                 :            :                    do_early_param);
     477                 :        207 : }
     478                 :            : 
     479                 :            : /* Arch code calls this early on, or if not, just before other parsing. */
     480                 :        414 : void __init parse_early_param(void)
     481                 :            : {
     482                 :            :         static int done __initdata;
     483                 :            :         static char tmp_cmdline[COMMAND_LINE_SIZE] __initdata;
     484                 :            : 
     485         [ +  + ]:        414 :         if (done)
     486                 :        414 :                 return;
     487                 :            : 
     488                 :            :         /* All fall through to do_early_param. */
     489                 :        207 :         strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
     490                 :        207 :         parse_early_options(tmp_cmdline);
     491                 :        207 :         done = 1;
     492                 :            : }
     493                 :            : 
     494                 :        207 : void __init __weak arch_post_acpi_subsys_init(void) { }
     495                 :            : 
     496                 :          0 : void __init __weak smp_setup_processor_id(void)
     497                 :            : {
     498                 :          0 : }
     499                 :            : 
     500                 :            : # if THREAD_SIZE >= PAGE_SIZE
     501                 :        207 : void __init __weak thread_stack_cache_init(void)
     502                 :            : {
     503                 :        207 : }
     504                 :            : #endif
     505                 :            : 
     506                 :        207 : void __init __weak mem_encrypt_init(void) { }
     507                 :            : 
     508                 :        207 : void __init __weak poking_init(void) { }
     509                 :            : 
     510                 :        207 : void __init __weak pgtable_cache_init(void) { }
     511                 :            : 
     512                 :            : bool initcall_debug;
     513                 :            : core_param(initcall_debug, initcall_debug, bool, 0644);
     514                 :            : 
     515                 :            : #ifdef TRACEPOINTS_ENABLED
     516                 :            : static void __init initcall_debug_enable(void);
     517                 :            : #else
     518                 :            : static inline void initcall_debug_enable(void)
     519                 :            : {
     520                 :            : }
     521                 :            : #endif
     522                 :            : 
     523                 :            : /* Report memory auto-initialization states for this boot. */
     524                 :        207 : static void __init report_meminit(void)
     525                 :            : {
     526                 :            :         const char *stack;
     527                 :            : 
     528                 :            :         if (IS_ENABLED(CONFIG_INIT_STACK_ALL))
     529                 :            :                 stack = "all";
     530                 :            :         else if (IS_ENABLED(CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL))
     531                 :            :                 stack = "byref_all";
     532                 :            :         else if (IS_ENABLED(CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF))
     533                 :            :                 stack = "byref";
     534                 :            :         else if (IS_ENABLED(CONFIG_GCC_PLUGIN_STRUCTLEAK_USER))
     535                 :            :                 stack = "__user";
     536                 :            :         else
     537                 :            :                 stack = "off";
     538                 :            : 
     539   [ +  -  +  - ]:        414 :         pr_info("mem auto-init: stack:%s, heap alloc:%s, heap free:%s\n",
     540                 :            :                 stack, want_init_on_alloc(GFP_KERNEL) ? "on" : "off",
     541                 :            :                 want_init_on_free() ? "on" : "off");
     542         [ -  + ]:        207 :         if (want_init_on_free())
     543                 :          0 :                 pr_info("mem auto-init: clearing system memory may take some time...\n");
     544                 :        207 : }
     545                 :            : 
     546                 :            : /*
     547                 :            :  * Set up kernel memory allocators
     548                 :            :  */
     549                 :        207 : static void __init mm_init(void)
     550                 :            : {
     551                 :            :         /*
     552                 :            :          * page_ext requires contiguous pages,
     553                 :            :          * bigger than MAX_ORDER unless SPARSEMEM.
     554                 :            :          */
     555                 :            :         page_ext_init_flatmem();
     556                 :            :         init_debug_pagealloc();
     557                 :        207 :         report_meminit();
     558                 :        207 :         mem_init();
     559                 :        207 :         kmem_cache_init();
     560                 :            :         kmemleak_init();
     561                 :            :         pgtable_init();
     562                 :            :         debug_objects_mem_init();
     563                 :        207 :         vmalloc_init();
     564                 :            :         ioremap_huge_init();
     565                 :            :         /* Should be run before the first non-init thread is created */
     566                 :            :         init_espfix_bsp();
     567                 :            :         /* Should be run after espfix64 is set up. */
     568                 :            :         pti_init();
     569                 :        207 : }
     570                 :            : 
     571                 :        207 : void __init __weak arch_call_rest_init(void)
     572                 :            : {
     573                 :        207 :         rest_init();
     574                 :          0 : }
     575                 :            : 
     576                 :        207 : asmlinkage __visible void __init start_kernel(void)
     577                 :            : {
     578                 :            :         char *command_line;
     579                 :            :         char *after_dashes;
     580                 :            : 
     581                 :        207 :         set_task_stack_end_magic(&init_task);
     582                 :        207 :         smp_setup_processor_id();
     583                 :            :         debug_objects_early_init();
     584                 :            : 
     585                 :        207 :         cgroup_init_early();
     586                 :            : 
     587                 :        207 :         local_irq_disable();
     588                 :        207 :         early_boot_irqs_disabled = true;
     589                 :            : 
     590                 :            :         /*
     591                 :            :          * Interrupts are still disabled. Do necessary setups, then
     592                 :            :          * enable them.
     593                 :            :          */
     594                 :        207 :         boot_cpu_init();
     595                 :            :         page_address_init();
     596                 :        207 :         pr_notice("%s", linux_banner);
     597                 :        207 :         early_security_init();
     598                 :        207 :         setup_arch(&command_line);
     599                 :        207 :         setup_command_line(command_line);
     600                 :        207 :         setup_nr_cpu_ids();
     601                 :        207 :         setup_per_cpu_areas();
     602                 :        207 :         smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
     603                 :        207 :         boot_cpu_hotplug_init();
     604                 :            : 
     605                 :        207 :         build_all_zonelists(NULL);
     606                 :        207 :         page_alloc_init();
     607                 :            : 
     608                 :        207 :         pr_notice("Kernel command line: %s\n", boot_command_line);
     609                 :            :         /* parameters may set static keys */
     610                 :        207 :         jump_label_init();
     611                 :        207 :         parse_early_param();
     612                 :        414 :         after_dashes = parse_args("Booting kernel",
     613                 :            :                                   static_command_line, __start___param,
     614                 :        207 :                                   __stop___param - __start___param,
     615                 :            :                                   -1, -1, NULL, &unknown_bootoption);
     616         [ -  + ]:        207 :         if (!IS_ERR_OR_NULL(after_dashes))
     617                 :          0 :                 parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
     618                 :            :                            NULL, set_init_arg);
     619                 :            : 
     620                 :            :         /*
     621                 :            :          * These use large bootmem allocations and must precede
     622                 :            :          * kmem_cache_init()
     623                 :            :          */
     624                 :        207 :         setup_log_buf(0);
     625                 :        207 :         vfs_caches_init_early();
     626                 :        207 :         sort_main_extable();
     627                 :        207 :         trap_init();
     628                 :        207 :         mm_init();
     629                 :            : 
     630                 :        207 :         ftrace_init();
     631                 :            : 
     632                 :            :         /* trace_printk can be enabled here */
     633                 :        207 :         early_trace_init();
     634                 :            : 
     635                 :            :         /*
     636                 :            :          * Set up the scheduler prior starting any interrupts (such as the
     637                 :            :          * timer interrupt). Full topology setup happens at smp_init()
     638                 :            :          * time - but meanwhile we still have a functioning scheduler.
     639                 :            :          */
     640                 :        207 :         sched_init();
     641                 :            :         /*
     642                 :            :          * Disable preemption - early bootup scheduling is extremely
     643                 :            :          * fragile until we cpu_idle() for the first time.
     644                 :            :          */
     645                 :        207 :         preempt_disable();
     646   [ -  +  -  + ]:        207 :         if (WARN(!irqs_disabled(),
     647                 :            :                  "Interrupts were enabled *very* early, fixing it\n"))
     648                 :          0 :                 local_irq_disable();
     649                 :        207 :         radix_tree_init();
     650                 :            : 
     651                 :            :         /*
     652                 :            :          * Set up housekeeping before setting up workqueues to allow the unbound
     653                 :            :          * workqueue to take non-housekeeping into account.
     654                 :            :          */
     655                 :        207 :         housekeeping_init();
     656                 :            : 
     657                 :            :         /*
     658                 :            :          * Allow workqueue creation and work item queueing/cancelling
     659                 :            :          * early.  Work item execution depends on kthreads and starts after
     660                 :            :          * workqueue_init().
     661                 :            :          */
     662                 :        207 :         workqueue_init_early();
     663                 :            : 
     664                 :        207 :         rcu_init();
     665                 :            : 
     666                 :            :         /* Trace events are available after this */
     667                 :        207 :         trace_init();
     668                 :            : 
     669         [ -  + ]:        207 :         if (initcall_debug)
     670                 :          0 :                 initcall_debug_enable();
     671                 :            : 
     672                 :            :         context_tracking_init();
     673                 :            :         /* init some links before init_ISA_irqs() */
     674                 :        207 :         early_irq_init();
     675                 :        207 :         init_IRQ();
     676                 :        207 :         tick_init();
     677                 :            :         rcu_init_nohz();
     678                 :        207 :         init_timers();
     679                 :        207 :         hrtimers_init();
     680                 :        207 :         softirq_init();
     681                 :        207 :         timekeeping_init();
     682                 :            : 
     683                 :            :         /*
     684                 :            :          * For best initial stack canary entropy, prepare it after:
     685                 :            :          * - setup_arch() for any UEFI RNG entropy and boot cmdline access
     686                 :            :          * - timekeeping_init() for ktime entropy used in rand_initialize()
     687                 :            :          * - rand_initialize() to get any arch-specific entropy like RDRAND
     688                 :            :          * - add_latent_entropy() to get any latent entropy
     689                 :            :          * - adding command line entropy
     690                 :            :          */
     691                 :        207 :         rand_initialize();
     692                 :            :         add_latent_entropy();
     693                 :        207 :         add_device_randomness(command_line, strlen(command_line));
     694                 :            :         boot_init_stack_canary();
     695                 :            : 
     696                 :        207 :         time_init();
     697                 :        207 :         perf_event_init();
     698                 :        207 :         profile_init();
     699                 :        207 :         call_function_init();
     700         [ -  + ]:        207 :         WARN(!irqs_disabled(), "Interrupts were enabled early\n");
     701                 :            : 
     702                 :        207 :         early_boot_irqs_disabled = false;
     703                 :        207 :         local_irq_enable();
     704                 :            : 
     705                 :        207 :         kmem_cache_init_late();
     706                 :            : 
     707                 :            :         /*
     708                 :            :          * HACK ALERT! This is early. We're enabling the console before
     709                 :            :          * we've done PCI setups etc, and console_init() must be aware of
     710                 :            :          * this. But we do want output early, in case something goes wrong.
     711                 :            :          */
     712                 :        207 :         console_init();
     713         [ -  + ]:        207 :         if (panic_later)
     714                 :          0 :                 panic("Too many boot %s vars at `%s'", panic_later,
     715                 :            :                       panic_param);
     716                 :            : 
     717                 :            :         lockdep_init();
     718                 :            : 
     719                 :            :         /*
     720                 :            :          * Need to run this when irqs are enabled, because it wants
     721                 :            :          * to self-test [hard/soft]-irqs on/off lock inversion bugs
     722                 :            :          * too:
     723                 :            :          */
     724                 :            :         locking_selftest();
     725                 :            : 
     726                 :            :         /*
     727                 :            :          * This needs to be called before any devices perform DMA
     728                 :            :          * operations that might use the SWIOTLB bounce buffers. It will
     729                 :            :          * mark the bounce buffers as decrypted so that their usage will
     730                 :            :          * not cause "plain-text" data to be decrypted when accessed.
     731                 :            :          */
     732                 :        207 :         mem_encrypt_init();
     733                 :            : 
     734                 :            : #ifdef CONFIG_BLK_DEV_INITRD
     735   [ -  +  #  #  :        207 :         if (initrd_start && !initrd_below_start_ok &&
                   #  # ]
     736                 :          0 :             page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
     737                 :          0 :                 pr_crit("initrd overwritten (0x%08lx < 0x%08lx) - disabling it.\n",
     738                 :            :                     page_to_pfn(virt_to_page((void *)initrd_start)),
     739                 :            :                     min_low_pfn);
     740                 :          0 :                 initrd_start = 0;
     741                 :            :         }
     742                 :            : #endif
     743                 :        207 :         setup_per_cpu_pageset();
     744                 :            :         numa_policy_init();
     745                 :            :         acpi_early_init();
     746         [ -  + ]:        207 :         if (late_time_init)
     747                 :          0 :                 late_time_init();
     748                 :        207 :         sched_clock_init();
     749                 :        207 :         calibrate_delay();
     750                 :        207 :         pid_idr_init();
     751                 :        207 :         anon_vma_init();
     752                 :            : #ifdef CONFIG_X86
     753                 :            :         if (efi_enabled(EFI_RUNTIME_SERVICES))
     754                 :            :                 efi_enter_virtual_mode();
     755                 :            : #endif
     756                 :        207 :         thread_stack_cache_init();
     757                 :        207 :         cred_init();
     758                 :        207 :         fork_init();
     759                 :        207 :         proc_caches_init();
     760                 :        207 :         uts_ns_init();
     761                 :        207 :         buffer_init();
     762                 :        207 :         key_init();
     763                 :        207 :         security_init();
     764                 :        207 :         dbg_late_init();
     765                 :        207 :         vfs_caches_init();
     766                 :        207 :         pagecache_init();
     767                 :        207 :         signals_init();
     768                 :        207 :         seq_file_init();
     769                 :        207 :         proc_root_init();
     770                 :        207 :         nsfs_init();
     771                 :        207 :         cpuset_init();
     772                 :        207 :         cgroup_init();
     773                 :        207 :         taskstats_init_early();
     774                 :        207 :         delayacct_init();
     775                 :            : 
     776                 :        207 :         poking_init();
     777                 :        207 :         check_bugs();
     778                 :            : 
     779                 :            :         acpi_subsystem_init();
     780                 :        207 :         arch_post_acpi_subsys_init();
     781                 :            :         sfi_init_late();
     782                 :            : 
     783                 :            :         /* Do the rest non-__init'ed, we're now alive */
     784                 :        207 :         arch_call_rest_init();
     785                 :            : 
     786                 :          0 :         prevent_tail_call_optimization();
     787                 :          0 : }
     788                 :            : 
     789                 :            : /* Call all constructor functions linked into the kernel. */
     790                 :        207 : static void __init do_ctors(void)
     791                 :            : {
     792                 :            : #ifdef CONFIG_CONSTRUCTORS
     793                 :            :         ctor_fn_t *fn = (ctor_fn_t *) __ctors_start;
     794                 :            : 
     795         [ +  + ]:     345897 :         for (; fn < (ctor_fn_t *) __ctors_end; fn++)
     796                 :     345690 :                 (*fn)();
     797                 :            : #endif
     798                 :        207 : }
     799                 :            : 
     800                 :            : #ifdef CONFIG_KALLSYMS
     801                 :            : struct blacklist_entry {
     802                 :            :         struct list_head next;
     803                 :            :         char *buf;
     804                 :            : };
     805                 :            : 
     806                 :            : static __initdata_or_module LIST_HEAD(blacklisted_initcalls);
     807                 :            : 
     808                 :          0 : static int __init initcall_blacklist(char *str)
     809                 :            : {
     810                 :            :         char *str_entry;
     811                 :            :         struct blacklist_entry *entry;
     812                 :            : 
     813                 :            :         /* str argument is a comma-separated list of functions */
     814                 :            :         do {
     815                 :          0 :                 str_entry = strsep(&str, ",");
     816         [ #  # ]:          0 :                 if (str_entry) {
     817                 :          0 :                         pr_debug("blacklisting initcall %s\n", str_entry);
     818                 :          0 :                         entry = memblock_alloc(sizeof(*entry),
     819                 :            :                                                SMP_CACHE_BYTES);
     820         [ #  # ]:          0 :                         if (!entry)
     821                 :          0 :                                 panic("%s: Failed to allocate %zu bytes\n",
     822                 :            :                                       __func__, sizeof(*entry));
     823                 :          0 :                         entry->buf = memblock_alloc(strlen(str_entry) + 1,
     824                 :            :                                                     SMP_CACHE_BYTES);
     825         [ #  # ]:          0 :                         if (!entry->buf)
     826                 :          0 :                                 panic("%s: Failed to allocate %zu bytes\n",
     827                 :          0 :                                       __func__, strlen(str_entry) + 1);
     828                 :          0 :                         strcpy(entry->buf, str_entry);
     829                 :          0 :                         list_add(&entry->next, &blacklisted_initcalls);
     830                 :            :                 }
     831         [ #  # ]:          0 :         } while (str_entry);
     832                 :            : 
     833                 :          0 :         return 0;
     834                 :            : }
     835                 :            : 
     836                 :     123579 : static bool __init_or_module initcall_blacklisted(initcall_t fn)
     837                 :            : {
     838                 :            :         struct blacklist_entry *entry;
     839                 :            :         char fn_name[KSYM_SYMBOL_LEN];
     840                 :            :         unsigned long addr;
     841                 :            : 
     842         [ -  + ]:     123579 :         if (list_empty(&blacklisted_initcalls))
     843                 :            :                 return false;
     844                 :            : 
     845                 :          0 :         addr = (unsigned long) dereference_function_descriptor(fn);
     846                 :          0 :         sprint_symbol_no_offset(fn_name, addr);
     847                 :            : 
     848                 :            :         /*
     849                 :            :          * fn will be "function_name [module_name]" where [module_name] is not
     850                 :            :          * displayed for built-in init functions.  Strip off the [module_name].
     851                 :            :          */
     852                 :          0 :         strreplace(fn_name, ' ', '\0');
     853                 :            : 
     854         [ #  # ]:          0 :         list_for_each_entry(entry, &blacklisted_initcalls, next) {
     855         [ #  # ]:          0 :                 if (!strcmp(fn_name, entry->buf)) {
     856                 :          0 :                         pr_debug("initcall %s blacklisted\n", fn_name);
     857                 :          0 :                         return true;
     858                 :            :                 }
     859                 :            :         }
     860                 :            : 
     861                 :            :         return false;
     862                 :            : }
     863                 :            : #else
     864                 :            : static int __init initcall_blacklist(char *str)
     865                 :            : {
     866                 :            :         pr_warn("initcall_blacklist requires CONFIG_KALLSYMS\n");
     867                 :            :         return 0;
     868                 :            : }
     869                 :            : 
     870                 :            : static bool __init_or_module initcall_blacklisted(initcall_t fn)
     871                 :            : {
     872                 :            :         return false;
     873                 :            : }
     874                 :            : #endif
     875                 :            : __setup("initcall_blacklist=", initcall_blacklist);
     876                 :            : 
     877                 :            : static __init_or_module void
     878                 :          0 : trace_initcall_start_cb(void *data, initcall_t fn)
     879                 :            : {
     880                 :            :         ktime_t *calltime = (ktime_t *)data;
     881                 :            : 
     882                 :          0 :         printk(KERN_DEBUG "calling  %pS @ %i\n", fn, task_pid_nr(current));
     883                 :          0 :         *calltime = ktime_get();
     884                 :          0 : }
     885                 :            : 
     886                 :            : static __init_or_module void
     887                 :          0 : trace_initcall_finish_cb(void *data, initcall_t fn, int ret)
     888                 :            : {
     889                 :            :         ktime_t *calltime = (ktime_t *)data;
     890                 :            :         ktime_t delta, rettime;
     891                 :            :         unsigned long long duration;
     892                 :            : 
     893                 :          0 :         rettime = ktime_get();
     894                 :          0 :         delta = ktime_sub(rettime, *calltime);
     895                 :          0 :         duration = (unsigned long long) ktime_to_ns(delta) >> 10;
     896                 :          0 :         printk(KERN_DEBUG "initcall %pS returned %d after %lld usecs\n",
     897                 :            :                  fn, ret, duration);
     898                 :          0 : }
     899                 :            : 
     900                 :            : static ktime_t initcall_calltime;
     901                 :            : 
     902                 :            : #ifdef TRACEPOINTS_ENABLED
     903                 :          0 : static void __init initcall_debug_enable(void)
     904                 :            : {
     905                 :            :         int ret;
     906                 :            : 
     907                 :            :         ret = register_trace_initcall_start(trace_initcall_start_cb,
     908                 :            :                                             &initcall_calltime);
     909                 :          0 :         ret |= register_trace_initcall_finish(trace_initcall_finish_cb,
     910                 :            :                                               &initcall_calltime);
     911         [ #  # ]:          0 :         WARN(ret, "Failed to register initcall tracepoints\n");
     912                 :          0 : }
     913                 :            : # define do_trace_initcall_start        trace_initcall_start
     914                 :            : # define do_trace_initcall_finish       trace_initcall_finish
     915                 :            : #else
     916                 :            : static inline void do_trace_initcall_start(initcall_t fn)
     917                 :            : {
     918                 :            :         if (!initcall_debug)
     919                 :            :                 return;
     920                 :            :         trace_initcall_start_cb(&initcall_calltime, fn);
     921                 :            : }
     922                 :            : static inline void do_trace_initcall_finish(initcall_t fn, int ret)
     923                 :            : {
     924                 :            :         if (!initcall_debug)
     925                 :            :                 return;
     926                 :            :         trace_initcall_finish_cb(&initcall_calltime, fn, ret);
     927                 :            : }
     928                 :            : #endif /* !TRACEPOINTS_ENABLED */
     929                 :            : 
     930                 :     123579 : int __init_or_module do_one_initcall(initcall_t fn)
     931                 :            : {
     932                 :            :         int count = preempt_count();
     933                 :            :         char msgbuf[64];
     934                 :            :         int ret;
     935                 :            : 
     936         [ +  - ]:     123579 :         if (initcall_blacklisted(fn))
     937                 :            :                 return -EPERM;
     938                 :            : 
     939                 :     123579 :         do_trace_initcall_start(fn);
     940                 :     123579 :         ret = fn();
     941                 :     123579 :         do_trace_initcall_finish(fn, ret);
     942                 :            : 
     943                 :     123579 :         msgbuf[0] = 0;
     944                 :            : 
     945         [ -  + ]:     123579 :         if (preempt_count() != count) {
     946                 :          0 :                 sprintf(msgbuf, "preemption imbalance ");
     947                 :            :                 preempt_count_set(count);
     948                 :            :         }
     949         [ -  + ]:     123579 :         if (irqs_disabled()) {
     950                 :          0 :                 strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
     951                 :          0 :                 local_irq_enable();
     952                 :            :         }
     953         [ -  + ]:     123579 :         WARN(msgbuf[0], "initcall %pS returned with %s\n", fn, msgbuf);
     954                 :            : 
     955                 :            :         add_latent_entropy();
     956                 :     123579 :         return ret;
     957                 :            : }
     958                 :            : 
     959                 :            : 
     960                 :            : extern initcall_entry_t __initcall_start[];
     961                 :            : extern initcall_entry_t __initcall0_start[];
     962                 :            : extern initcall_entry_t __initcall1_start[];
     963                 :            : extern initcall_entry_t __initcall2_start[];
     964                 :            : extern initcall_entry_t __initcall3_start[];
     965                 :            : extern initcall_entry_t __initcall4_start[];
     966                 :            : extern initcall_entry_t __initcall5_start[];
     967                 :            : extern initcall_entry_t __initcall6_start[];
     968                 :            : extern initcall_entry_t __initcall7_start[];
     969                 :            : extern initcall_entry_t __initcall_end[];
     970                 :            : 
     971                 :            : static initcall_entry_t *initcall_levels[] __initdata = {
     972                 :            :         __initcall0_start,
     973                 :            :         __initcall1_start,
     974                 :            :         __initcall2_start,
     975                 :            :         __initcall3_start,
     976                 :            :         __initcall4_start,
     977                 :            :         __initcall5_start,
     978                 :            :         __initcall6_start,
     979                 :            :         __initcall7_start,
     980                 :            :         __initcall_end,
     981                 :            : };
     982                 :            : 
     983                 :            : /* Keep these in sync with initcalls in include/linux/init.h */
     984                 :            : static const char *initcall_level_names[] __initdata = {
     985                 :            :         "pure",
     986                 :            :         "core",
     987                 :            :         "postcore",
     988                 :            :         "arch",
     989                 :            :         "subsys",
     990                 :            :         "fs",
     991                 :            :         "device",
     992                 :            :         "late",
     993                 :            : };
     994                 :            : 
     995                 :       1656 : static void __init do_initcall_level(int level)
     996                 :            : {
     997                 :            :         initcall_entry_t *fn;
     998                 :            : 
     999                 :       1656 :         strcpy(initcall_command_line, saved_command_line);
    1000                 :       3312 :         parse_args(initcall_level_names[level],
    1001                 :            :                    initcall_command_line, __start___param,
    1002                 :       1656 :                    __stop___param - __start___param,
    1003                 :            :                    level, level,
    1004                 :            :                    NULL, &repair_env_string);
    1005                 :            : 
    1006                 :       1656 :         trace_initcall_level(initcall_level_names[level]);
    1007         [ +  + ]:     116334 :         for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
    1008                 :     114678 :                 do_one_initcall(initcall_from_entry(fn));
    1009                 :       1656 : }
    1010                 :            : 
    1011                 :        207 : static void __init do_initcalls(void)
    1012                 :            : {
    1013                 :            :         int level;
    1014                 :            : 
    1015         [ +  + ]:       1863 :         for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
    1016                 :       1656 :                 do_initcall_level(level);
    1017                 :        207 : }
    1018                 :            : 
    1019                 :            : /*
    1020                 :            :  * Ok, the machine is now initialized. None of the devices
    1021                 :            :  * have been touched yet, but the CPU subsystem is up and
    1022                 :            :  * running, and memory and process management works.
    1023                 :            :  *
    1024                 :            :  * Now we can finally start doing some real work..
    1025                 :            :  */
    1026                 :        207 : static void __init do_basic_setup(void)
    1027                 :            : {
    1028                 :        207 :         cpuset_init_smp();
    1029                 :        207 :         driver_init();
    1030                 :        207 :         init_irq_proc();
    1031                 :        207 :         do_ctors();
    1032                 :            :         usermodehelper_enable();
    1033                 :        207 :         do_initcalls();
    1034                 :        207 : }
    1035                 :            : 
    1036                 :        207 : static void __init do_pre_smp_initcalls(void)
    1037                 :            : {
    1038                 :            :         initcall_entry_t *fn;
    1039                 :            : 
    1040                 :        207 :         trace_initcall_level("early");
    1041         [ +  + ]:       3726 :         for (fn = __initcall_start; fn < __initcall0_start; fn++)
    1042                 :       3519 :                 do_one_initcall(initcall_from_entry(fn));
    1043                 :        207 : }
    1044                 :            : 
    1045                 :        207 : static int run_init_process(const char *init_filename)
    1046                 :            : {
    1047                 :        207 :         argv_init[0] = init_filename;
    1048                 :        207 :         pr_info("Run %s as init process\n", init_filename);
    1049                 :        207 :         return do_execve(getname_kernel(init_filename),
    1050                 :            :                 (const char __user *const __user *)argv_init,
    1051                 :            :                 (const char __user *const __user *)envp_init);
    1052                 :            : }
    1053                 :            : 
    1054                 :        207 : static int try_to_run_init_process(const char *init_filename)
    1055                 :            : {
    1056                 :            :         int ret;
    1057                 :            : 
    1058                 :        207 :         ret = run_init_process(init_filename);
    1059                 :            : 
    1060         [ -  + ]:        207 :         if (ret && ret != -ENOENT) {
    1061                 :          0 :                 pr_err("Starting init: %s exists but couldn't execute it (error %d)\n",
    1062                 :            :                        init_filename, ret);
    1063                 :            :         }
    1064                 :            : 
    1065                 :        207 :         return ret;
    1066                 :            : }
    1067                 :            : 
    1068                 :            : static noinline void __init kernel_init_freeable(void);
    1069                 :            : 
    1070                 :            : #if defined(CONFIG_STRICT_KERNEL_RWX) || defined(CONFIG_STRICT_MODULE_RWX)
    1071                 :            : bool rodata_enabled __ro_after_init = true;
    1072                 :          0 : static int __init set_debug_rodata(char *str)
    1073                 :            : {
    1074                 :          0 :         return strtobool(str, &rodata_enabled);
    1075                 :            : }
    1076                 :            : __setup("rodata=", set_debug_rodata);
    1077                 :            : #endif
    1078                 :            : 
    1079                 :            : #ifdef CONFIG_STRICT_KERNEL_RWX
    1080                 :        207 : static void mark_readonly(void)
    1081                 :            : {
    1082         [ +  - ]:        207 :         if (rodata_enabled) {
    1083                 :            :                 /*
    1084                 :            :                  * load_module() results in W+X mappings, which are cleaned
    1085                 :            :                  * up with call_rcu().  Let's make sure that queued work is
    1086                 :            :                  * flushed so that we don't hit false positives looking for
    1087                 :            :                  * insecure pages which are W+X.
    1088                 :            :                  */
    1089                 :        207 :                 rcu_barrier();
    1090                 :        207 :                 mark_rodata_ro();
    1091                 :            :                 rodata_test();
    1092                 :            :         } else
    1093                 :          0 :                 pr_info("Kernel memory protection disabled.\n");
    1094                 :        207 : }
    1095                 :            : #else
    1096                 :            : static inline void mark_readonly(void)
    1097                 :            : {
    1098                 :            :         pr_warn("This architecture does not have kernel memory protection.\n");
    1099                 :            : }
    1100                 :            : #endif
    1101                 :            : 
    1102                 :          0 : void __weak free_initmem(void)
    1103                 :            : {
    1104                 :            :         free_initmem_default(POISON_FREE_INITMEM);
    1105                 :          0 : }
    1106                 :            : 
    1107                 :        207 : static int __ref kernel_init(void *unused)
    1108                 :            : {
    1109                 :            :         int ret;
    1110                 :            : 
    1111                 :        207 :         kernel_init_freeable();
    1112                 :            :         /* need to finish all async __init code before freeing the memory */
    1113                 :        207 :         async_synchronize_full();
    1114                 :        207 :         ftrace_free_init_mem();
    1115                 :        207 :         free_initmem();
    1116                 :        207 :         mark_readonly();
    1117                 :            : 
    1118                 :            :         /*
    1119                 :            :          * Kernel mappings are now finalized - update the userspace page-table
    1120                 :            :          * to finalize PTI.
    1121                 :            :          */
    1122                 :            :         pti_finalize();
    1123                 :            : 
    1124                 :        207 :         system_state = SYSTEM_RUNNING;
    1125                 :            :         numa_default_policy();
    1126                 :            : 
    1127                 :        207 :         rcu_end_inkernel_boot();
    1128                 :            : 
    1129         [ -  + ]:        207 :         if (ramdisk_execute_command) {
    1130                 :          0 :                 ret = run_init_process(ramdisk_execute_command);
    1131         [ #  # ]:          0 :                 if (!ret)
    1132                 :            :                         return 0;
    1133                 :          0 :                 pr_err("Failed to execute %s (error %d)\n",
    1134                 :            :                        ramdisk_execute_command, ret);
    1135                 :            :         }
    1136                 :            : 
    1137                 :            :         /*
    1138                 :            :          * We try each of these until one succeeds.
    1139                 :            :          *
    1140                 :            :          * The Bourne shell can be used instead of init if we are
    1141                 :            :          * trying to recover a really broken machine.
    1142                 :            :          */
    1143         [ -  + ]:        207 :         if (execute_command) {
    1144                 :          0 :                 ret = run_init_process(execute_command);
    1145         [ #  # ]:          0 :                 if (!ret)
    1146                 :            :                         return 0;
    1147                 :          0 :                 panic("Requested init %s failed (error %d).",
    1148                 :            :                       execute_command, ret);
    1149                 :            :         }
    1150   [ -  +  #  # ]:        207 :         if (!try_to_run_init_process("/sbin/init") ||
    1151         [ #  # ]:          0 :             !try_to_run_init_process("/etc/init") ||
    1152         [ #  # ]:          0 :             !try_to_run_init_process("/bin/init") ||
    1153                 :          0 :             !try_to_run_init_process("/bin/sh"))
    1154                 :            :                 return 0;
    1155                 :            : 
    1156                 :          0 :         panic("No working init found.  Try passing init= option to kernel. "
    1157                 :            :               "See Linux Documentation/admin-guide/init.rst for guidance.");
    1158                 :            : }
    1159                 :            : 
    1160                 :        207 : static noinline void __init kernel_init_freeable(void)
    1161                 :            : {
    1162                 :            :         /*
    1163                 :            :          * Wait until kthreadd is all set-up.
    1164                 :            :          */
    1165                 :        207 :         wait_for_completion(&kthreadd_done);
    1166                 :            : 
    1167                 :            :         /* Now the scheduler is fully set up and can do blocking allocations */
    1168                 :        207 :         gfp_allowed_mask = __GFP_BITS_MASK;
    1169                 :            : 
    1170                 :            :         /*
    1171                 :            :          * init can allocate pages on any node
    1172                 :            :          */
    1173                 :        207 :         set_mems_allowed(node_states[N_MEMORY]);
    1174                 :            : 
    1175                 :        414 :         cad_pid = task_pid(current);
    1176                 :            : 
    1177                 :        207 :         smp_prepare_cpus(setup_max_cpus);
    1178                 :            : 
    1179                 :        207 :         workqueue_init();
    1180                 :            : 
    1181                 :        207 :         init_mm_internals();
    1182                 :            : 
    1183                 :        207 :         do_pre_smp_initcalls();
    1184                 :            :         lockup_detector_init();
    1185                 :            : 
    1186                 :        207 :         smp_init();
    1187                 :        207 :         sched_init_smp();
    1188                 :            : 
    1189                 :        207 :         page_alloc_init_late();
    1190                 :            :         /* Initialize page ext after all struct pages are initialized. */
    1191                 :            :         page_ext_init();
    1192                 :            : 
    1193                 :        207 :         do_basic_setup();
    1194                 :            : 
    1195                 :            :         /* Open the /dev/console on the rootfs, this should never fail */
    1196         [ -  + ]:        207 :         if (ksys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
    1197                 :          0 :                 pr_err("Warning: unable to open an initial console.\n");
    1198                 :            : 
    1199                 :        207 :         (void) ksys_dup(0);
    1200                 :        207 :         (void) ksys_dup(0);
    1201                 :            :         /*
    1202                 :            :          * check if there is an early userspace init.  If yes, let it do all
    1203                 :            :          * the work
    1204                 :            :          */
    1205                 :            : 
    1206         [ +  - ]:        207 :         if (!ramdisk_execute_command)
    1207                 :        207 :                 ramdisk_execute_command = "/init";
    1208                 :            : 
    1209         [ +  - ]:        414 :         if (ksys_access((const char __user *)
    1210                 :            :                         ramdisk_execute_command, 0) != 0) {
    1211                 :        207 :                 ramdisk_execute_command = NULL;
    1212                 :        207 :                 prepare_namespace();
    1213                 :            :         }
    1214                 :            : 
    1215                 :            :         /*
    1216                 :            :          * Ok, we have completed the initial bootup, and
    1217                 :            :          * we're essentially up and running. Get rid of the
    1218                 :            :          * initmem segments and start the user-mode stuff..
    1219                 :            :          *
    1220                 :            :          * rootfs is available now, try loading the public keys
    1221                 :            :          * and default modules
    1222                 :            :          */
    1223                 :            : 
    1224                 :        207 :         integrity_load_keys();
    1225                 :        207 : }

Generated by: LCOV version 1.14