Android 4.2启动代码分析(一)

Android系统启动过程分析

Android系统的框架架构图如下(来自网上)：

 

Linux内核启动之后----->就到Android的Init进程 ----->进而启动Android相关的服务和应用。

整个的启动过程如下图所示：

以下针对Android 4.2内核代码的启动部分进行分析。

Init进程，是一个由内核启动的用户级进程。内核自行启动（已被载入内存，开始运行，并已初始化所有的设备驱动程序和数据结构等）之后，就通过启动用户级程序init的方式，完成引导进程。

Init进程始终是第一个进程。Init进程的对应的代码的main函数在目录~/my_android/system/core/init/init.c

整个Android系统的启动分为Linux kernel的启动和Android系统的启动。

Linux kernel启动起来后，然后就运行第一个用户程序，在Android中，就是init程序，在目录~/my_android/system/core/init/init.c，对其中的main()函数分段进行介绍

1. 首先声明一些局部变量，代码如下：

int main(int argc, char **argv)
{
    int fd_count = 0;
    struct pollfd ufds[4];
    char *tmpdev;
    char* debuggable;
    char tmp[32];
    int property_set_fd_init = 0;
    int signal_fd_init = 0;
    int keychord_fd_init = 0;
    bool is_charger = false;
    ......
    ......
}

main函数中该段代码主要是声明了一些后续会使用的变量，其中涉及一个结构体pollfd，后续对其操作时再进行介绍

2.对传入的argv[0]进行判断，决定程序的执行分支，代码如下：

int main(int argc, char **argv)
{
    ...
	...

    if (!strcmp(basename(argv[0]), "ueventd"))
        return ueventd_main(argc, argv);

    if (!strcmp(basename(argv[0]), "watchdogd"))
        return watchdogd_main(argc, argv);

	...
	...
}

说明了这里处理kernel执行会跳转到以外，还有其他地方会调用这个main函数。
其中的argv[0]就是表示要执行的函数名称。
从这里看，应该有三个地方会执行此处的main()函数：

• 标准的android启动代码
• ueventd_main（）代码
• watchdogd_main（）代码

3. 创建并挂载Android系统启动所需要的文件系统

int main(int argc, char **argv)
{
    ...
	...

    /* clear the umask */
    umask(0);

        /* Get the basic filesystem setup we need put
         * together in the initramdisk on / and then we'll
         * let the rc file figure out the rest.
         */
    /* Don't repeat the setup of these filesystems,
     * it creates double mount points with an unknown effect
     * on the system.  This init file is for 2nd-init anyway.
     */
#ifndef NO_DEVFS_SETUP
    mkdir("/dev", 0755);
    mkdir("/proc", 0755);
    mkdir("/sys", 0755);

    mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
    mkdir("/dev/pts", 0755);
    mkdir("/dev/socket", 0755);
    mount("devpts", "/dev/pts", "devpts", 0, NULL);
    mount("proc", "/proc", "proc", 0, NULL);
    mount("sysfs", "/sys", "sysfs", 0, NULL);

        /* indicate that booting is in progress to background fw loaders, etc */
    close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));

        /* We must have some place other than / to create the
         * device nodes for kmsg and null, otherwise we won't
         * be able to remount / read-only later on.
         * Now that tmpfs is mounted on /dev, we can actually
         * talk to the outside world.
         */
	...
	...
}

4.生成log设备，以及一些属性设置

int main(int argc, char **argv)
{
    ...
	...
        /* We must have some place other than / to create the
         * device nodes for kmsg and null, otherwise we won't
         * be able to remount / read-only later on.
         * Now that tmpfs is mounted on /dev, we can actually
         * talk to the outside world.
         */
    open_devnull_stdio();
    klog_init();
#endif
    property_init();

    get_hardware_name(hardware, &revision);

    process_kernel_cmdline();
	...
	...
}

其中open_devnull_stdio()的定义在~/my_android/system/core/init/util.c中，代码如下：

void open_devnull_stdio(void)
{
    int fd;
    static const char *name = "/dev/__null__";
    if (mknod(name, S_IFCHR | 0600, (1 << 8) | 3) == 0) {
        fd = open(name, O_RDWR);
        unlink(name);
        if (fd >= 0) {
            dup2(fd, 0);
            dup2(fd, 1);
            dup2(fd, 2);
            if (fd > 2) {
                close(fd);
            }
            return;
        }
    }

    exit(1);
}

该函数首先创建一个设备节点"/dev/__null__"(在/dev目录下生产__null__设备节点文件)，然后打开这个设备文件，并将打开的文件描述符保存在变量fd中，接着使用unlink函数删除该文件，虽然文件删除了，但是现在系统中借助这个fd还是能够找到该文件的内容的。if中的语句利用dup2函数将文件描述符fd的0,1,2信息重定向到这个fd文件描述符的文件中。即把标准输入、标准输出、标准错误输出重定向到一个设备文件中（0——标准输入，1——标准输出，2——标准错误输出）。重定向操作完成后，就关闭掉fd。示意图如下：

回到main()函数中，接着是执行klog_init()函数，其定义在：~/my_android/system/core/libcutils/klog.c中，实现代码如下：

void klog_init(void)
{
    static const char *name = "/dev/__kmsg__";
    if (mknod(name, S_IFCHR | 0600, (1 << 8) | 11) == 0) {
        klog_fd = open(name, O_WRONLY);
        fcntl(klog_fd, F_SETFD, FD_CLOEXEC);
        unlink(name);
    }
}

该函数和open_devnull_stdio的实现很相像，创建设备节点，打开，操作，然后删除文件。其中的fcntl(klog_fd, F_SETFD, FD_CLOEXEC); 表示当在子进程中使用exec执行其他程序时会把这个文件描述符关闭。

接着是执行main()函数中的property_init()函数，其定义在：~/my_android/system/core/init/property_service.c文件中。实现的代码如下：

void property_init(void)
{
    init_property_area();
}

此处调用了另一函数init_property_area()，其定义也在~/my_android/system/core/init/property_service.c文件中，实现代码如下：

static int init_property_area(void)
{
    prop_area *pa;

    if(pa_info_array)
        return -1;

    if(init_workspace(&pa_workspace, PA_SIZE))
        return -1;

    fcntl(pa_workspace.fd, F_SETFD, FD_CLOEXEC);

    pa_info_array = (void*) (((char*) pa_workspace.data) + PA_INFO_START);

    pa = pa_workspace.data;
    memset(pa, 0, PA_SIZE);
    pa->magic = PROP_AREA_MAGIC;
    pa->version = PROP_AREA_VERSION;

        /* plug into the lib property services */
    __system_property_area__ = pa;
    property_area_inited = 1;
    return 0;
}

在该函数中，涉及了几个结构体变量，首先看一下各结构体的定义

prop_area结构体的定义如下，其定义在：

struct prop_area{
	nsigned volatile count;
	unsigned volatile serial;
	unsigned magic;
	unsigned version;
	unsigned reserved[4];
	unsigned toc[1];
};

然后是pa_info_array的定义为：

static pro_info *pa_info_array;

所以在函数中，由于pa_info_array由于刚刚定义的，所以当if判断其是否为空，结果为空，所以继续往下执行。接着调用init_workspace(&pa_workspace, PA_SIZE)函数，其定义为：

static int init_workspace(workspace *w, size_t size)
{
    void *data;
    int fd;

        /* dev is a tmpfs that we can use to carve a shared workspace
         * out of, so let's do that...
         */
    fd = open("/dev/__properties__", O_RDWR | O_CREAT, 0600);
    if (fd < 0)
        return -1;

    if (ftruncate(fd, size) < 0)
        goto out;

    data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(data == MAP_FAILED)
        goto out;

    close(fd);

    fd = open("/dev/__properties__", O_RDONLY);
    if (fd < 0)
        return -1;

    unlink("/dev/__properties__");

    w->data = data;
    w->size = size;
    w->fd = fd;
    return 0;

out:
    close(fd);
    return -1;
}

pa_workspace和PA_SIZE也在当前文件夹中定义，如下：

#define PA_SIZE 49152
static workspace pa_workspace;

该函数中有涉及另一个结构体workplace，就定义当函数所在的文件夹，其定义为：

typedef struct {
    void *data;
    size_t size;
    int fd;
} workspace;

这个文件夹中存储了三个变量，数据、大小和文件描述符。init_workplace（)这个函数里面就要初始化一个这样的结构体。

首先，打开一个设备文件/dev/__properties__"， 通过ftruncate()函数调用将这个文件的大小改为size。size是通过调用函数时形参传递进来的。

然后，调用mmap()函数映射一段内存。返回映射区的地址保存在data中。

最后，将对应的data、size、fd分别给workplace结构体指针w赋值。

函数执行成功，返回0。回到init_property_area函数中。init_workplace(）函数返回后进行if判断，若执行成功，返回0，所以接着往下执行。

调用fcntl()函数，关于fcntl函数的功能，

参考：http://www.cnblogs.com/andtt/articles/2178875.html和http://blog.csdn.net/ustc_dylan/article/details/6930189

pa_workspace.data表示的是一段大小为PA_SIZE的内存地址，将这个地址加上PA_INFO_START赋值给pa_info_array。PA_INFO_START定义为：

#define PA_INFO_START 1536

然后将pa_workplace.data代表的那段大小为PA_SIZE的内存通过调用memset()函数将其内存清0。
记者就是一些简单的赋值操作了，现在回到main()函数中。

执行get_hardware_name(hardware, &revision);该函数定义在:~/my_android/system/core/init/util.c文件中，实现代码如下：

void get_hardware_name(char *hardware, unsigned int *revision)
{
    char data[1024];
    int fd, n;
    char *x, *hw, *rev;

    /* Hardware string was provided on kernel command line */
    if (hardware[0])
        return;

    fd = open("/proc/cpuinfo", O_RDONLY);
    if (fd < 0) return;

    n = read(fd, data, 1023);
    close(fd);
    if (n < 0) return;

    data[n] = 0;
    hw = strstr(data, "\nHardware");
    rev = strstr(data, "\nRevision");

    if (hw) {
        x = strstr(hw, ": ");
        if (x) {
            x += 2;
            n = 0;
            while (*x && *x != '\n') {
                if (!isspace(*x))
                    hardware[n++] = tolower(*x);
                x++;
                if (n == 31) break;
            }
            hardware[n] = 0;
        }
    }

    if (rev) {
        x = strstr(rev, ": ");
        if (x) {
            *revision = strtoul(x + 2, 0, 16);
        }
    }
}

这个函数的实参hardware是一32个元素的字符数组，revision为一个unsigned值，也定义在函数所在的文件中，定义如下：

static char hardware[32];
static unsigned revision = 0;

get_hardware_name()函数从"proc/cpuinfo"文件读取相应字符串到data中，然后通过调用strstr函数将data中"\nHardware"开始的字符保存到hw中，将“\nRevision”开始的字符保存到rev中。

strstr()函数的功能：就是在第一个参数中查找第二个参数第一次出现的地址，将地址赋值给一个字符指针，接着就可以利用这个字符指针找到从这个地址开始往后的字符。

"/proc/cpuinfo中"中的内容，可以通过adb shell登录模拟器来查看，其内容如下：

后面两个if语句对hw和rev进行处理，最终得到我们想要的数值。其中hw部分，提取Goldfish这几个字符，并将其大写转为小写。rev那部分数据转化为十六进制表示。

回到main()函数，接着执行process_kernel_cmdline();该函数和main()函数定义在同一文件夹中，实现代码如下：

static void process_kernel_cmdline(void)
{
    /* don't expose the raw commandline to nonpriv processes */
    chmod("/proc/cmdline", 0440);

    /* first pass does the common stuff, and finds if we are in qemu.
     * second pass is only necessary for qemu to export all kernel params
     * as props.
     */
    import_kernel_cmdline(0, import_kernel_nv);
    if (qemu[0])
        import_kernel_cmdline(1, import_kernel_nv);

    /* now propogate the info given on command line to internal variables
     * used by init as well as the current required properties
     */
    export_kernel_boot_props();
}

除了使用import_kernel_cmdline函数导入内核变量外，主要的功能就是调用export_kernel_boot_props函数通过属性设置内核变量，主要实现的功能是处理内核命令行，以下从细节进行分析。

首先调用chmod()函数改变"/proc/cmdline"的文件属性。

import_kernel_cmdline(0, import_kernel_nv);的定义在~/my_android/system/core/init/util.c中，实现代码如下：

void import_kernel_cmdline(int in_qemu,
                           void (*import_kernel_nv)(char *name, int in_qemu))
{
    char cmdline[1024];
    char *ptr;
    int fd;

    fd = open("/proc/cmdline", O_RDONLY);
    if (fd >= 0) {
        int n = read(fd, cmdline, 1023);
        if (n < 0) n = 0;

        /* get rid of trailing newline, it happens */
        if (n > 0 && cmdline[n-1] == '\n') n--;

        cmdline[n] = 0;
        close(fd);
    } else {
        cmdline[0] = 0;
    }

    ptr = cmdline;
    while (ptr && *ptr) {
        char *x = strchr(ptr, ' ');
        if (x != 0) *x++ = 0; //可以拆分为*x = 0; x++;
        import_kernel_nv(ptr, in_qemu);
        ptr = x;
    }
}

首先打开文件"/proc/cmdline"，读取其内容到变量cmdline中，"/proc/cmdline"中内容如下：

其后对cmdline的字符数组处理非常简单。然后到while()循环，

strchr函数返回第二个变量在第一个变量中第一次出现的位置，具体用法可参考：http://blog.csdn.net/sky2098/article/details/1530433

import_kernel_nv(ptr, in_qemu)定义在~/my_android/system/core/init/init.c中，实现的代码如下：

static void import_kernel_nv(char *name, int for_emulator)
{
    char *value = strchr(name, '=');
    int name_len = strlen(name);

    if (value == 0) return;
    *value++ = 0;
    if (name_len == 0) return;

#ifdef HAVE_SELINUX
    if (!strcmp(name,"selinux")) {
        selinux_enabled = atoi(value);
    }
#endif

    if (for_emulator) {
        /* in the emulator, export any kernel option with the
         * ro.kernel. prefix */
        char buff[PROP_NAME_MAX];
        int len = snprintf( buff, sizeof(buff), "ro.kernel.%s", name );

        if (len < (int)sizeof(buff))
            property_set( buff, value );
        return;
    }

    if (!strcmp(name,"qemu")) {
        strlcpy(qemu, value, sizeof(qemu));
#ifdef WANTS_EMMC_BOOT
    } else if (!strcmp(name,"androidboot.emmc")) {
        if (!strcmp(value,"true")) {
            emmc_boot = 1;
        }
#endif
    } else if (!strcmp(name,BOARD_CHARGING_CMDLINE_NAME)) {
        strlcpy(battchg_pause, value, sizeof(battchg_pause));
    } else if (!strncmp(name, "androidboot.", 12) && name_len > 12) {
        const char *boot_prop_name = name + 12;
        char prop[PROP_NAME_MAX];
        int cnt;

        cnt = snprintf(prop, sizeof(prop), "ro.boot.%s", boot_prop_name);
        if (cnt < PROP_NAME_MAX)
            property_set(prop, value);
    }
}

然后，返回到process_kernel_cmdline()中，由于变量qemu的定义为：

static char qemu[32];

由于没有初始化，所以if(qemu[0])判断为否，所以接着执行export_kernel_boot_props()函数，其定义在~/my_android/system/core/init/init.c中，实现的代码如下：

static void export_kernel_boot_props(void)
{
    char tmp[PROP_VALUE_MAX];
    const char *pval;
    unsigned i;
    struct {
        const char *src_prop;
        const char *dest_prop;
        const char *def_val;
    } prop_map[] = {
        { "ro.boot.serialno", "ro.serialno", "", },
        { "ro.boot.mode", "ro.bootmode", "unknown", },
        { "ro.boot.baseband", "ro.baseband", "unknown", },
        { "ro.boot.bootloader", "ro.bootloader", "unknown", },
    };

    for (i = 0; i < ARRAY_SIZE(prop_map); i++) {
        pval = property_get(prop_map[i].src_prop);
        property_set(prop_map[i].dest_prop, pval ?: prop_map[i].def_val);
    }

    pval = property_get("ro.boot.console");
    if (pval)
        strlcpy(console, pval, sizeof(console));

    /* save a copy for init's usage during boot */
    strlcpy(bootmode, property_get("ro.bootmode"), sizeof(bootmode));

    /* if this was given on kernel command line, override what we read
     * before (e.g. from /proc/cpuinfo), if anything */
    pval = property_get("ro.boot.hardware");
    if (pval)
        strlcpy(hardware, pval, sizeof(hardware));
    property_set("ro.hardware", hardware);

    snprintf(tmp, PROP_VALUE_MAX, "%d", revision);
    property_set("ro.revision", tmp);
    property_set("ro.emmc",emmc_boot ? "1" : "0");
    property_set("ro.boot.emmc", emmc_boot ? "1" : "0");

    /* TODO: these are obsolete. We should delete them */
    if (!strcmp(bootmode,"factory"))
        property_set("ro.factorytest", "1");
    else if (!strcmp(bootmode,"factory2"))
        property_set("ro.factorytest", "2");
    else
        property_set("ro.factorytest", "0");
}

从export_kernel_boot_props函数的代码可以看出，该函数实际上就是来回设置一些属性值，并且利用某些属性值修改console、hardware等变量。其中hardware变量（就是一个长度为32的字符数组）在get_hardware_name函数中已经从/proc/cpuinfo文件中获得过一次值了，在export_kernel_boot_props函数中又通过ro.boot.hardware属性设置了一次值。

接下来的#ifdef HAVE_SELINUX……#endif，是和Security-Enhanced Android相关的。

参考：

1. http://blog.csdn.net/jiangbei_lengyu/article/details/8564144
2. http://www.cnblogs.com/bastard/archive/2012/08/28/2660389.html
3. http://www.cnblogs.com/nokiaguy/archive/2013/04/14/3020774.html