LCOV - code coverage report
Current view: top level - init - do_mounts.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 92 225 40.9 %
Date: 2020-09-30 20:25:40 Functions: 13 21 61.9 %
Branches: 39 159 24.5 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : #include <linux/module.h>
       3                 :            : #include <linux/sched.h>
       4                 :            : #include <linux/ctype.h>
       5                 :            : #include <linux/fd.h>
       6                 :            : #include <linux/tty.h>
       7                 :            : #include <linux/suspend.h>
       8                 :            : #include <linux/root_dev.h>
       9                 :            : #include <linux/security.h>
      10                 :            : #include <linux/delay.h>
      11                 :            : #include <linux/genhd.h>
      12                 :            : #include <linux/mount.h>
      13                 :            : #include <linux/device.h>
      14                 :            : #include <linux/init.h>
      15                 :            : #include <linux/fs.h>
      16                 :            : #include <linux/initrd.h>
      17                 :            : #include <linux/async.h>
      18                 :            : #include <linux/fs_struct.h>
      19                 :            : #include <linux/slab.h>
      20                 :            : #include <linux/ramfs.h>
      21                 :            : #include <linux/shmem_fs.h>
      22                 :            : 
      23                 :            : #include <linux/nfs_fs.h>
      24                 :            : #include <linux/nfs_fs_sb.h>
      25                 :            : #include <linux/nfs_mount.h>
      26                 :            : #include <uapi/linux/mount.h>
      27                 :            : 
      28                 :            : #include "do_mounts.h"
      29                 :            : 
      30                 :            : int __initdata rd_doload;       /* 1 = load RAM disk, 0 = don't load */
      31                 :            : 
      32                 :            : int root_mountflags = MS_RDONLY | MS_SILENT;
      33                 :            : static char * __initdata root_device_name;
      34                 :            : static char __initdata saved_root_name[64];
      35                 :            : static int root_wait;
      36                 :            : 
      37                 :            : dev_t ROOT_DEV;
      38                 :            : 
      39                 :          0 : static int __init load_ramdisk(char *str)
      40                 :            : {
      41                 :          0 :         rd_doload = simple_strtol(str,NULL,0) & 3;
      42                 :          0 :         return 1;
      43                 :            : }
      44                 :            : __setup("load_ramdisk=", load_ramdisk);
      45                 :            : 
      46                 :          0 : static int __init readonly(char *str)
      47                 :            : {
      48         [ #  # ]:          0 :         if (*str)
      49                 :            :                 return 0;
      50                 :          0 :         root_mountflags |= MS_RDONLY;
      51                 :          0 :         return 1;
      52                 :            : }
      53                 :            : 
      54                 :          0 : static int __init readwrite(char *str)
      55                 :            : {
      56         [ #  # ]:          0 :         if (*str)
      57                 :            :                 return 0;
      58                 :          0 :         root_mountflags &= ~MS_RDONLY;
      59                 :          0 :         return 1;
      60                 :            : }
      61                 :            : 
      62                 :            : __setup("ro", readonly);
      63                 :            : __setup("rw", readwrite);
      64                 :            : 
      65                 :            : #ifdef CONFIG_BLOCK
      66                 :            : struct uuidcmp {
      67                 :            :         const char *uuid;
      68                 :            :         int len;
      69                 :            : };
      70                 :            : 
      71                 :            : /**
      72                 :            :  * match_dev_by_uuid - callback for finding a partition using its uuid
      73                 :            :  * @dev:        device passed in by the caller
      74                 :            :  * @data:       opaque pointer to the desired struct uuidcmp to match
      75                 :            :  *
      76                 :            :  * Returns 1 if the device matches, and 0 otherwise.
      77                 :            :  */
      78                 :      35253 : static int match_dev_by_uuid(struct device *dev, const void *data)
      79                 :            : {
      80                 :            :         const struct uuidcmp *cmp = data;
      81                 :            :         struct hd_struct *part = dev_to_part(dev);
      82                 :            : 
      83         [ +  + ]:      35253 :         if (!part->info)
      84                 :            :                 goto no_match;
      85                 :            : 
      86         [ +  + ]:        414 :         if (strncasecmp(cmp->uuid, part->info->uuid, cmp->len))
      87                 :            :                 goto no_match;
      88                 :            : 
      89                 :            :         return 1;
      90                 :            : no_match:
      91                 :      35046 :         return 0;
      92                 :            : }
      93                 :            : 
      94                 :            : 
      95                 :            : /**
      96                 :            :  * devt_from_partuuid - looks up the dev_t of a partition by its UUID
      97                 :            :  * @uuid_str:   char array containing ascii UUID
      98                 :            :  *
      99                 :            :  * The function will return the first partition which contains a matching
     100                 :            :  * UUID value in its partition_meta_info struct.  This does not search
     101                 :            :  * by filesystem UUIDs.
     102                 :            :  *
     103                 :            :  * If @uuid_str is followed by a "/PARTNROFF=%d", then the number will be
     104                 :            :  * extracted and used as an offset from the partition identified by the UUID.
     105                 :            :  *
     106                 :            :  * Returns the matching dev_t on success or 0 on failure.
     107                 :            :  */
     108                 :       1443 : static dev_t devt_from_partuuid(const char *uuid_str)
     109                 :            : {
     110                 :            :         dev_t res = 0;
     111                 :            :         struct uuidcmp cmp;
     112                 :            :         struct device *dev = NULL;
     113                 :            :         struct gendisk *disk;
     114                 :            :         struct hd_struct *part;
     115                 :       1443 :         int offset = 0;
     116                 :            :         bool clear_root_wait = false;
     117                 :            :         char *slash;
     118                 :            : 
     119                 :       1443 :         cmp.uuid = uuid_str;
     120                 :            : 
     121                 :       1443 :         slash = strchr(uuid_str, '/');
     122                 :            :         /* Check for optional partition number offset attributes. */
     123         [ -  + ]:       1443 :         if (slash) {
     124                 :          0 :                 char c = 0;
     125                 :            :                 /* Explicitly fail on poor PARTUUID syntax. */
     126         [ #  # ]:          0 :                 if (sscanf(slash + 1,
     127                 :            :                            "PARTNROFF=%d%c", &offset, &c) != 1) {
     128                 :            :                         clear_root_wait = true;
     129                 :          0 :                         goto done;
     130                 :            :                 }
     131                 :          0 :                 cmp.len = slash - uuid_str;
     132                 :            :         } else {
     133                 :       1443 :                 cmp.len = strlen(uuid_str);
     134                 :            :         }
     135                 :            : 
     136         [ +  - ]:       1443 :         if (!cmp.len) {
     137                 :            :                 clear_root_wait = true;
     138                 :            :                 goto done;
     139                 :            :         }
     140                 :            : 
     141                 :       1443 :         dev = class_find_device(&block_class, NULL, &cmp,
     142                 :            :                                 &match_dev_by_uuid);
     143         [ +  + ]:       1443 :         if (!dev)
     144                 :            :                 goto done;
     145                 :            : 
     146                 :        207 :         res = dev->devt;
     147                 :            : 
     148                 :            :         /* Attempt to find the partition by offset. */
     149         [ -  + ]:        207 :         if (!offset)
     150                 :            :                 goto no_offset;
     151                 :            : 
     152                 :            :         res = 0;
     153                 :          0 :         disk = part_to_disk(dev_to_part(dev));
     154                 :          0 :         part = disk_get_part(disk, dev_to_part(dev)->partno + offset);
     155         [ #  # ]:          0 :         if (part) {
     156                 :            :                 res = part_devt(part);
     157                 :          0 :                 put_device(part_to_dev(part));
     158                 :            :         }
     159                 :            : 
     160                 :            : no_offset:
     161                 :        207 :         put_device(dev);
     162                 :            : done:
     163         [ -  + ]:       1443 :         if (clear_root_wait) {
     164                 :          0 :                 pr_err("VFS: PARTUUID= is invalid.\n"
     165                 :            :                        "Expected PARTUUID=<valid-uuid-id>[/PARTNROFF=%%d]\n");
     166         [ #  # ]:          0 :                 if (root_wait)
     167                 :          0 :                         pr_err("Disabling rootwait; root= is invalid.\n");
     168                 :          0 :                 root_wait = 0;
     169                 :            :         }
     170                 :       1443 :         return res;
     171                 :            : }
     172                 :            : 
     173                 :            : /**
     174                 :            :  * match_dev_by_label - callback for finding a partition using its label
     175                 :            :  * @dev:        device passed in by the caller
     176                 :            :  * @data:       opaque pointer to the label to match
     177                 :            :  *
     178                 :            :  * Returns 1 if the device matches, and 0 otherwise.
     179                 :            :  */
     180                 :          0 : static int match_dev_by_label(struct device *dev, const void *data)
     181                 :            : {
     182                 :            :         const char *label = data;
     183                 :            :         struct hd_struct *part = dev_to_part(dev);
     184                 :            : 
     185   [ #  #  #  # ]:          0 :         if (part->info && !strcmp(label, part->info->volname))
     186                 :            :                 return 1;
     187                 :            : 
     188                 :          0 :         return 0;
     189                 :            : }
     190                 :            : #endif
     191                 :            : 
     192                 :            : /*
     193                 :            :  *      Convert a name into device number.  We accept the following variants:
     194                 :            :  *
     195                 :            :  *      1) <hex_major><hex_minor> device number in hexadecimal represents itself
     196                 :            :  *         no leading 0x, for example b302.
     197                 :            :  *      2) /dev/nfs represents Root_NFS (0xff)
     198                 :            :  *      3) /dev/<disk_name> represents the device number of disk
     199                 :            :  *      4) /dev/<disk_name><decimal> represents the device number
     200                 :            :  *         of partition - device number of disk plus the partition number
     201                 :            :  *      5) /dev/<disk_name>p<decimal> - same as the above, that form is
     202                 :            :  *         used when disk name of partitioned disk ends on a digit.
     203                 :            :  *      6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
     204                 :            :  *         unique id of a partition if the partition table provides it.
     205                 :            :  *         The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
     206                 :            :  *         partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
     207                 :            :  *         filled hex representation of the 32-bit "NT disk signature", and PP
     208                 :            :  *         is a zero-filled hex representation of the 1-based partition number.
     209                 :            :  *      7) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
     210                 :            :  *         a partition with a known unique id.
     211                 :            :  *      8) <major>:<minor> major and minor number of the device separated by
     212                 :            :  *         a colon.
     213                 :            :  *      9) PARTLABEL=<name> with name being the GPT partition label.
     214                 :            :  *         MSDOS partitions do not support labels!
     215                 :            :  *
     216                 :            :  *      If name doesn't have fall into the categories above, we return (0,0).
     217                 :            :  *      block_class is used to check if something is a disk name. If the disk
     218                 :            :  *      name contains slashes, the device name has them replaced with
     219                 :            :  *      bangs.
     220                 :            :  */
     221                 :            : 
     222                 :       1443 : dev_t name_to_dev_t(const char *name)
     223                 :            : {
     224                 :            :         char s[32];
     225                 :            :         char *p;
     226                 :            :         dev_t res = 0;
     227                 :            :         int part;
     228                 :            : 
     229                 :            : #ifdef CONFIG_BLOCK
     230         [ +  - ]:       1443 :         if (strncmp(name, "PARTUUID=", 9) == 0) {
     231                 :       1443 :                 name += 9;
     232                 :       1443 :                 res = devt_from_partuuid(name);
     233         [ +  + ]:       1443 :                 if (!res)
     234                 :            :                         goto fail;
     235                 :            :                 goto done;
     236         [ #  # ]:          0 :         } else if (strncmp(name, "PARTLABEL=", 10) == 0) {
     237                 :            :                 struct device *dev;
     238                 :            : 
     239                 :          0 :                 dev = class_find_device(&block_class, NULL, name + 10,
     240                 :            :                                         &match_dev_by_label);
     241         [ #  # ]:          0 :                 if (!dev)
     242                 :            :                         goto fail;
     243                 :            : 
     244                 :          0 :                 res = dev->devt;
     245                 :          0 :                 put_device(dev);
     246                 :          0 :                 goto done;
     247                 :            :         }
     248                 :            : #endif
     249                 :            : 
     250         [ #  # ]:          0 :         if (strncmp(name, "/dev/", 5) != 0) {
     251                 :            :                 unsigned maj, min, offset;
     252                 :            :                 char dummy;
     253                 :            : 
     254   [ #  #  #  # ]:          0 :                 if ((sscanf(name, "%u:%u%c", &maj, &min, &dummy) == 2) ||
     255                 :          0 :                     (sscanf(name, "%u:%u:%u:%c", &maj, &min, &offset, &dummy) == 3)) {
     256                 :          0 :                         res = MKDEV(maj, min);
     257   [ #  #  #  # ]:          0 :                         if (maj != MAJOR(res) || min != MINOR(res))
     258                 :            :                                 goto fail;
     259                 :            :                 } else {
     260                 :          0 :                         res = new_decode_dev(simple_strtoul(name, &p, 16));
     261         [ #  # ]:          0 :                         if (*p)
     262                 :            :                                 goto fail;
     263                 :            :                 }
     264                 :          0 :                 goto done;
     265                 :            :         }
     266                 :            : 
     267                 :          0 :         name += 5;
     268                 :            :         res = Root_NFS;
     269         [ #  # ]:          0 :         if (strcmp(name, "nfs") == 0)
     270                 :            :                 goto done;
     271                 :            :         res = Root_RAM0;
     272         [ #  # ]:          0 :         if (strcmp(name, "ram") == 0)
     273                 :            :                 goto done;
     274                 :            : 
     275         [ #  # ]:          0 :         if (strlen(name) > 31)
     276                 :            :                 goto fail;
     277                 :          0 :         strcpy(s, name);
     278         [ #  # ]:          0 :         for (p = s; *p; p++)
     279         [ #  # ]:          0 :                 if (*p == '/')
     280                 :          0 :                         *p = '!';
     281                 :          0 :         res = blk_lookup_devt(s, 0);
     282         [ #  # ]:          0 :         if (res)
     283                 :            :                 goto done;
     284                 :            : 
     285                 :            :         /*
     286                 :            :          * try non-existent, but valid partition, which may only exist
     287                 :            :          * after revalidating the disk, like partitioned md devices
     288                 :            :          */
     289   [ #  #  #  # ]:          0 :         while (p > s && isdigit(p[-1]))
     290                 :          0 :                 p--;
     291   [ #  #  #  #  :          0 :         if (p == s || !*p || *p == '0')
                   #  # ]
     292                 :            :                 goto fail;
     293                 :            : 
     294                 :            :         /* try disk name without <part number> */
     295                 :          0 :         part = simple_strtoul(p, NULL, 10);
     296                 :          0 :         *p = '\0';
     297                 :          0 :         res = blk_lookup_devt(s, part);
     298         [ #  # ]:          0 :         if (res)
     299                 :            :                 goto done;
     300                 :            : 
     301                 :            :         /* try disk name without p<part number> */
     302   [ #  #  #  #  :          0 :         if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
                   #  # ]
     303                 :            :                 goto fail;
     304                 :          0 :         p[-1] = '\0';
     305                 :          0 :         res = blk_lookup_devt(s, part);
     306         [ #  # ]:          0 :         if (res)
     307                 :            :                 goto done;
     308                 :            : 
     309                 :            : fail:
     310                 :            :         return 0;
     311                 :            : done:
     312                 :        207 :         return res;
     313                 :            : }
     314                 :            : EXPORT_SYMBOL_GPL(name_to_dev_t);
     315                 :            : 
     316                 :        207 : static int __init root_dev_setup(char *line)
     317                 :            : {
     318                 :        207 :         strlcpy(saved_root_name, line, sizeof(saved_root_name));
     319                 :        207 :         return 1;
     320                 :            : }
     321                 :            : 
     322                 :            : __setup("root=", root_dev_setup);
     323                 :            : 
     324                 :        207 : static int __init rootwait_setup(char *str)
     325                 :            : {
     326         [ +  - ]:        207 :         if (*str)
     327                 :            :                 return 0;
     328                 :        207 :         root_wait = 1;
     329                 :        207 :         return 1;
     330                 :            : }
     331                 :            : 
     332                 :            : __setup("rootwait", rootwait_setup);
     333                 :            : 
     334                 :            : static char * __initdata root_mount_data;
     335                 :          0 : static int __init root_data_setup(char *str)
     336                 :            : {
     337                 :          0 :         root_mount_data = str;
     338                 :          0 :         return 1;
     339                 :            : }
     340                 :            : 
     341                 :            : static char * __initdata root_fs_names;
     342                 :        207 : static int __init fs_names_setup(char *str)
     343                 :            : {
     344                 :        207 :         root_fs_names = str;
     345                 :        207 :         return 1;
     346                 :            : }
     347                 :            : 
     348                 :            : static unsigned int __initdata root_delay;
     349                 :          0 : static int __init root_delay_setup(char *str)
     350                 :            : {
     351                 :          0 :         root_delay = simple_strtoul(str, NULL, 0);
     352                 :          0 :         return 1;
     353                 :            : }
     354                 :            : 
     355                 :            : __setup("rootflags=", root_data_setup);
     356                 :            : __setup("rootfstype=", fs_names_setup);
     357                 :            : __setup("rootdelay=", root_delay_setup);
     358                 :            : 
     359                 :        207 : static void __init get_fs_names(char *page)
     360                 :            : {
     361                 :            :         char *s = page;
     362                 :            : 
     363         [ +  - ]:        207 :         if (root_fs_names) {
     364                 :        207 :                 strcpy(page, root_fs_names);
     365         [ +  + ]:       1242 :                 while (*s++) {
     366         [ -  + ]:        828 :                         if (s[-1] == ',')
     367                 :          0 :                                 s[-1] = '\0';
     368                 :            :                 }
     369                 :            :         } else {
     370                 :          0 :                 int len = get_filesystem_list(page);
     371                 :            :                 char *p, *next;
     372                 :            : 
     373                 :          0 :                 page[len] = '\0';
     374         [ #  # ]:          0 :                 for (p = page-1; p; p = next) {
     375                 :          0 :                         next = strchr(++p, '\n');
     376         [ #  # ]:          0 :                         if (*p++ != '\t')
     377                 :          0 :                                 continue;
     378         [ #  # ]:          0 :                         while ((*s++ = *p++) != '\n')
     379                 :            :                                 ;
     380                 :          0 :                         s[-1] = '\0';
     381                 :            :                 }
     382                 :            :         }
     383                 :        207 :         *s = '\0';
     384                 :        207 : }
     385                 :            : 
     386                 :        207 : static int __init do_mount_root(char *name, char *fs, int flags, void *data)
     387                 :            : {
     388                 :            :         struct super_block *s;
     389                 :        207 :         int err = ksys_mount(name, "/root", fs, flags, data);
     390         [ +  - ]:        207 :         if (err)
     391                 :            :                 return err;
     392                 :            : 
     393                 :        207 :         ksys_chdir("/root");
     394                 :        207 :         s = current->fs->pwd.dentry->d_sb;
     395                 :        207 :         ROOT_DEV = s->s_dev;
     396         [ -  + ]:        414 :         printk(KERN_INFO
     397                 :            :                "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
     398                 :        207 :                s->s_type->name,
     399                 :            :                sb_rdonly(s) ? " readonly" : "",
     400                 :            :                MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
     401                 :        207 :         return 0;
     402                 :            : }
     403                 :            : 
     404                 :        207 : void __init mount_block_root(char *name, int flags)
     405                 :            : {
     406                 :            :         struct page *page = alloc_page(GFP_KERNEL);
     407                 :            :         char *fs_names = page_address(page);
     408                 :            :         char *p;
     409                 :            : #ifdef CONFIG_BLOCK
     410                 :            :         char b[BDEVNAME_SIZE];
     411                 :            : #else
     412                 :            :         const char *b = name;
     413                 :            : #endif
     414                 :            : 
     415                 :        207 :         get_fs_names(fs_names);
     416                 :            : retry:
     417         [ +  - ]:        414 :         for (p = fs_names; *p; p += strlen(p)+1) {
     418                 :        207 :                 int err = do_mount_root(name, p, flags, root_mount_data);
     419      [ -  -  + ]:        207 :                 switch (err) {
     420                 :            :                         case 0:
     421                 :            :                                 goto out;
     422                 :            :                         case -EACCES:
     423                 :            :                         case -EINVAL:
     424                 :          0 :                                 continue;
     425                 :            :                 }
     426                 :            :                 /*
     427                 :            :                  * Allow the user to distinguish between failed sys_open
     428                 :            :                  * and bad superblock on root device.
     429                 :            :                  * and give them a list of the available devices
     430                 :            :                  */
     431                 :            : #ifdef CONFIG_BLOCK
     432                 :          0 :                 __bdevname(ROOT_DEV, b);
     433                 :            : #endif
     434                 :          0 :                 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
     435                 :            :                                 root_device_name, b, err);
     436                 :          0 :                 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
     437                 :            : 
     438                 :          0 :                 printk_all_partitions();
     439                 :            : #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
     440                 :            :                 printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
     441                 :            :                        "explicit textual name for \"root=\" boot option.\n");
     442                 :            : #endif
     443                 :          0 :                 panic("VFS: Unable to mount root fs on %s", b);
     444                 :            :         }
     445         [ #  # ]:          0 :         if (!(flags & SB_RDONLY)) {
     446                 :          0 :                 flags |= SB_RDONLY;
     447                 :          0 :                 goto retry;
     448                 :            :         }
     449                 :            : 
     450                 :          0 :         printk("List of all partitions:\n");
     451                 :          0 :         printk_all_partitions();
     452                 :          0 :         printk("No filesystem could mount root, tried: ");
     453         [ #  # ]:          0 :         for (p = fs_names; *p; p += strlen(p)+1)
     454                 :          0 :                 printk(" %s", p);
     455                 :          0 :         printk("\n");
     456                 :            : #ifdef CONFIG_BLOCK
     457                 :          0 :         __bdevname(ROOT_DEV, b);
     458                 :            : #endif
     459                 :          0 :         panic("VFS: Unable to mount root fs on %s", b);
     460                 :            : out:
     461                 :        207 :         put_page(page);
     462                 :        207 : }
     463                 :            :  
     464                 :            : #ifdef CONFIG_ROOT_NFS
     465                 :            : 
     466                 :            : #define NFSROOT_TIMEOUT_MIN     5
     467                 :            : #define NFSROOT_TIMEOUT_MAX     30
     468                 :            : #define NFSROOT_RETRY_MAX       5
     469                 :            : 
     470                 :          0 : static int __init mount_nfs_root(void)
     471                 :            : {
     472                 :            :         char *root_dev, *root_data;
     473                 :            :         unsigned int timeout;
     474                 :            :         int try, err;
     475                 :            : 
     476                 :          0 :         err = nfs_root_data(&root_dev, &root_data);
     477         [ #  # ]:          0 :         if (err != 0)
     478                 :            :                 return 0;
     479                 :            : 
     480                 :            :         /*
     481                 :            :          * The server or network may not be ready, so try several
     482                 :            :          * times.  Stop after a few tries in case the client wants
     483                 :            :          * to fall back to other boot methods.
     484                 :            :          */
     485                 :            :         timeout = NFSROOT_TIMEOUT_MIN;
     486                 :          0 :         for (try = 1; ; try++) {
     487                 :          0 :                 err = do_mount_root(root_dev, "nfs",
     488                 :            :                                         root_mountflags, root_data);
     489         [ #  # ]:          0 :                 if (err == 0)
     490                 :            :                         return 1;
     491         [ #  # ]:          0 :                 if (try > NFSROOT_RETRY_MAX)
     492                 :            :                         break;
     493                 :            : 
     494                 :            :                 /* Wait, in case the server refused us immediately */
     495                 :            :                 ssleep(timeout);
     496                 :          0 :                 timeout <<= 1;
     497         [ #  # ]:          0 :                 if (timeout > NFSROOT_TIMEOUT_MAX)
     498                 :            :                         timeout = NFSROOT_TIMEOUT_MAX;
     499                 :          0 :         }
     500                 :            :         return 0;
     501                 :            : }
     502                 :            : #endif
     503                 :            : 
     504                 :            : #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
     505                 :          0 : void __init change_floppy(char *fmt, ...)
     506                 :            : {
     507                 :            :         struct termios termios;
     508                 :            :         char buf[80];
     509                 :            :         char c;
     510                 :            :         int fd;
     511                 :            :         va_list args;
     512                 :          0 :         va_start(args, fmt);
     513                 :          0 :         vsprintf(buf, fmt, args);
     514                 :          0 :         va_end(args);
     515                 :            :         fd = ksys_open("/dev/root", O_RDWR | O_NDELAY, 0);
     516         [ #  # ]:          0 :         if (fd >= 0) {
     517                 :          0 :                 ksys_ioctl(fd, FDEJECT, 0);
     518                 :          0 :                 ksys_close(fd);
     519                 :            :         }
     520                 :          0 :         printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
     521                 :            :         fd = ksys_open("/dev/console", O_RDWR, 0);
     522         [ #  # ]:          0 :         if (fd >= 0) {
     523                 :          0 :                 ksys_ioctl(fd, TCGETS, (long)&termios);
     524                 :          0 :                 termios.c_lflag &= ~ICANON;
     525                 :          0 :                 ksys_ioctl(fd, TCSETSF, (long)&termios);
     526                 :          0 :                 ksys_read(fd, &c, 1);
     527                 :          0 :                 termios.c_lflag |= ICANON;
     528                 :          0 :                 ksys_ioctl(fd, TCSETSF, (long)&termios);
     529                 :          0 :                 ksys_close(fd);
     530                 :            :         }
     531                 :          0 : }
     532                 :            : #endif
     533                 :            : 
     534                 :        207 : void __init mount_root(void)
     535                 :            : {
     536                 :            : #ifdef CONFIG_ROOT_NFS
     537         [ -  + ]:        207 :         if (ROOT_DEV == Root_NFS) {
     538         [ #  # ]:          0 :                 if (mount_nfs_root())
     539                 :        207 :                         return;
     540                 :            : 
     541                 :          0 :                 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
     542                 :          0 :                 ROOT_DEV = Root_FD0;
     543                 :            :         }
     544                 :            : #endif
     545                 :            : #ifdef CONFIG_BLK_DEV_FD
     546                 :            :         if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
     547                 :            :                 /* rd_doload is 2 for a dual initrd/ramload setup */
     548                 :            :                 if (rd_doload==2) {
     549                 :            :                         if (rd_load_disk(1)) {
     550                 :            :                                 ROOT_DEV = Root_RAM1;
     551                 :            :                                 root_device_name = NULL;
     552                 :            :                         }
     553                 :            :                 } else
     554                 :            :                         change_floppy("root floppy");
     555                 :            :         }
     556                 :            : #endif
     557                 :            : #ifdef CONFIG_BLOCK
     558                 :            :         {
     559                 :        207 :                 int err = create_dev("/dev/root", ROOT_DEV);
     560                 :            : 
     561         [ -  + ]:        207 :                 if (err < 0)
     562                 :          0 :                         pr_emerg("Failed to create /dev/root: %d\n", err);
     563                 :        207 :                 mount_block_root("/dev/root", root_mountflags);
     564                 :            :         }
     565                 :            : #endif
     566                 :            : }
     567                 :            : 
     568                 :            : /*
     569                 :            :  * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
     570                 :            :  */
     571                 :        207 : void __init prepare_namespace(void)
     572                 :            : {
     573                 :            :         int is_floppy;
     574                 :            : 
     575         [ -  + ]:        207 :         if (root_delay) {
     576                 :          0 :                 printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
     577                 :            :                        root_delay);
     578                 :          0 :                 ssleep(root_delay);
     579                 :            :         }
     580                 :            : 
     581                 :            :         /*
     582                 :            :          * wait for the known devices to complete their probing
     583                 :            :          *
     584                 :            :          * Note: this is a potential source of long boot delays.
     585                 :            :          * For example, it is not atypical to wait 5 seconds here
     586                 :            :          * for the touchpad of a laptop to initialize.
     587                 :            :          */
     588                 :        207 :         wait_for_device_probe();
     589                 :            : 
     590                 :            :         md_run_setup();
     591                 :            : 
     592         [ +  - ]:        207 :         if (saved_root_name[0]) {
     593                 :        207 :                 root_device_name = saved_root_name;
     594   [ +  -  -  + ]:        414 :                 if (!strncmp(root_device_name, "mtd", 3) ||
     595                 :        207 :                     !strncmp(root_device_name, "ubi", 3)) {
     596                 :          0 :                         mount_block_root(root_device_name, root_mountflags);
     597                 :          0 :                         goto out;
     598                 :            :                 }
     599                 :        207 :                 ROOT_DEV = name_to_dev_t(root_device_name);
     600         [ -  + ]:        207 :                 if (strncmp(root_device_name, "/dev/", 5) == 0)
     601                 :          0 :                         root_device_name += 5;
     602                 :            :         }
     603                 :            : 
     604         [ +  - ]:        207 :         if (initrd_load())
     605                 :            :                 goto out;
     606                 :            : 
     607                 :            :         /* wait for any asynchronous scanning to complete */
     608   [ +  -  +  - ]:        207 :         if ((ROOT_DEV == 0) && root_wait) {
     609                 :        207 :                 printk(KERN_INFO "Waiting for root device %s...\n",
     610                 :            :                         saved_root_name);
     611   [ +  +  +  + ]:       2808 :                 while (driver_probe_done() != 0 ||
     612                 :       1236 :                         (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
     613                 :       1158 :                         msleep(5);
     614                 :        207 :                 async_synchronize_full();
     615                 :            :         }
     616                 :            : 
     617                 :        207 :         is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
     618                 :            : 
     619   [ -  +  #  #  :        207 :         if (is_floppy && rd_doload && rd_load_disk(0))
                   #  # ]
     620                 :          0 :                 ROOT_DEV = Root_RAM0;
     621                 :            : 
     622                 :        207 :         mount_root();
     623                 :            : out:
     624                 :        207 :         devtmpfs_mount("dev");
     625                 :        207 :         ksys_mount(".", "/", NULL, MS_MOVE, NULL);
     626                 :        207 :         ksys_chroot(".");
     627                 :        207 : }
     628                 :            : 
     629                 :            : static bool is_tmpfs;
     630                 :        207 : static int rootfs_init_fs_context(struct fs_context *fc)
     631                 :            : {
     632         [ -  + ]:        207 :         if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
     633                 :          0 :                 return shmem_init_fs_context(fc);
     634                 :            : 
     635                 :        207 :         return ramfs_init_fs_context(fc);
     636                 :            : }
     637                 :            : 
     638                 :            : struct file_system_type rootfs_fs_type = {
     639                 :            :         .name           = "rootfs",
     640                 :            :         .init_fs_context = rootfs_init_fs_context,
     641                 :            :         .kill_sb        = kill_litter_super,
     642                 :            : };
     643                 :            : 
     644                 :        207 : void __init init_rootfs(void)
     645                 :            : {
     646   [ -  +  #  # ]:        207 :         if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
     647         [ #  # ]:          0 :                 (!root_fs_names || strstr(root_fs_names, "tmpfs")))
     648                 :          0 :                 is_tmpfs = true;
     649                 :        207 : }

Generated by: LCOV version 1.14