./system/core/init/init.c

int main(int argc, char **argv)

{

    ....

    if (!strcmp(basename(argv[0]), "ueventd"))

        return ueventd_main(argc, argv);

    ....

}

ueventd.%hardware%.rc

Nexus Sdml /ueventd.herring.rc 내용

/dev/pvrsrvkm            0666    system    system

/dev/uwibro               0660    system    system

/dev/swmxctl             0660    system    system

/dev/video0               0660    system    camera

/dev/video1               0660    system    camera

/dev/video2               0660    system    camera

/dev/s3c-jpg             0660    system    camera

/dev/s3c-mem           0660    system    system

/dev/s3c-mfc            0660     media      media

/dev/modem_ctl          0660     radio       radio

/dev/modem_fmt          0660     radio       radio

/dev/modem_rfs          0660     radio       radio

/dev/s3c2410_serial3   0660     radio       radio

/dev/block/mtdblcok5  0660     radio       radio

/dev/mtd/mtd5ro         0660     radio       radio

/dev/mtd/mtd5            0660     radio       radio

# for Sensor HAL

/dev/akm 8973            0660    system    system

/dev/accelerometer     0660    system    system

# for GPS

/dev/s3c2410_serial1    0600     gps        gps 

./system/core/init/ueventd.c

int ueventd_main(int argc, char **argv)

{

    struct pollfd ufd;

    int nr;

    char tmp[32];

    umask(000);

    signal(SIGCHLD, SIG_IGN);

    open_devnull_stdio();

    klog_init();

    INFO("starting ueventd\n");

    /* Respect hardware passed in through the kernel cmd line, Here we will look

    * for androidboot.hardware param in kernel cmdline, and save its value in

    * hardware[]. */

    import_kernel_cmdline(0, import_kernel_nv);

    get_hardware_name(hardware, &revision);

    ueventd_parse_config_file("/ueventd.rc");

    snprintf(tmp, sizeof(tmp),"/ueventd.%s.rc", hardware);

    ueventd_parse_config_file(tmp);

    device_init();

    ufd.events = POLLIN;

    ufd.fd = get_device_fd();

    while(1) {

        ufd.revents = 0;

        nr = poll(&ufd, 1, -1);

        if (nr <= 0)

             continue;

        if (ufd.revents == POLLIN)

               handle_device_fd();

    }

}

./system/core/init/devices.c

 void device_init(void)

{

    suseconds_t t0, t1;

    struct stat info;

    int fd;

#ifdev HAVE_SELINUX

    struct selinux_opt seopts[] = {

        { SELABEL_OPT_PATH, "/file_contexts" }

    };

    if(is_selinux_enabled() > 0)

       sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);

#endif

    /* is 64K enough? udev uses 16MB! */

    device_fd = uevent_open_socket(64*1024, true);

    if(device_fd < 0)

        return;

    fcntl(device_fd, F_SETFD, FD_CLOEXEC);

    fcntl(device_fd, F_SETFD, O_NONBLOCK);

    if (stat(coldboot_done, &info) < 0) {

        t0 = get_usecs();

         coldboot("/sys/class");

         coldboot("/sys/block");

         coldboot("/sys/devices");

        t1 = get_usecs();

        fd = open(coldboot_done, O_WRONLY|O_CREAT, 0000);

        close(fd);

        //log_event_print("coldboot%ld uS\n", ((long)(t1 -t0)));

        ERROR("coldboot %ld uS\n", ((long)(t1 -t0)));

    } else {

        //log_event_print("skipping coldboot, already done\n")

        ERROR("skipping coldboot, already done\n");

    }

}

./system/core/init/devices.c

static void do_coldboot(DIR *d)

{

    struct dirent*de;

    int dfd, fd;

    dfd = dirfd(d);

    fd = openat(dfd, "uevent", O_WRONLY);

    if(fd >=0) {

        write(fd, "add\n", 4);

        close(fd);

        handle_device_fd();

    }

    while((de = readdir(d))) {

        DIR *d2;

        if(de ->d_type != DT_DIR || de->d_name[0] =='.')

            continue;

        fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY);

        if(fd < 0)

            continue;

        f2 = fdopendir(fd);

        if(d2 == 0)

            close(fd);

        else {

            do_coldboot(d2);

            closedir(d2);

         }

    }

} 

./system/core/init/devices.c

#define UEVENT_MSG_LEN 1024

void handle_device_fd()

{

    char msg[UEVENT_MSG_LEN+2];

    int n;

    while ((n = uevent_kernel_multicast_recv(device_fd, msg, UEVENT_MSG_LEN)) > 0) {

        if(n >= UEVENT_MSG_LEN) /* overflow -- discard */

            continue;

        msg[n] = '\0';

        msg[n+1] = '\0';

        struct uevent uevent;

        parse_event(msg, &uevent);

        handle_device_event(&uevent);

        handle_firmware_event(&uevent);

     }

}

./system/core/init/devices.c

static void handle_device_event(struct uevent *uevent)

{

    if (!strcmp(uevent->action,"add"))

        fixup_sys_perms(uevent->path);

    if (!strncmp(uevent->subsystem, "block",5)) {

        handle_block_device_event(uevent);

    } else if (!strncmp(uevent->subsystem, "platform", 8)) {

        handle_platform_device_event(uevent);

    } else {

        handle_generic_device_event(uevent);

    }

}

./system/core/init/devices.c 

static void handle_firmware_event(struct uevent *uevent)

{

    pid_t pid;

    int ret;

    if(strcmp(uevent->subsystem, "firmware"))

        return;

    if(strcmp(uevent->action, "add"))

        return;

    /* we fork, to avoid making large memory allocations in init proper */

    pid = fork();

    if (!pid) {

         process_firmware_event(uevent);

         exit(EXIT_SUCCESS);

    }

}