LCOV - code coverage report
Current view: top level - init - main.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 341 490 69.6 %
Date: 2022-03-28 15:32:58 Functions: 30 46 65.2 %
Branches: 81 172 47.1 %

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

Generated by: LCOV version 1.14