Android Init Process Analysis Ueventd

Transferred from: http://blog.csdn.net/freshui/article/details/2132299

(Lazy people recently think of me and csdn for a long time, this Android init is lying in my draft box for almost 5 years, a little change to send it out)

UEVENTD is mainly responsible for the creation of device nodes, permission settings and other tasks. The service uses Uevent to monitor the messages sent by the driver for further processing.
Ueventd Actual and Init are the same binary, just walk the different branches and see the previous section.

Ueventd's overall code is relatively simple, mainly three parts:

• Parsing ueventd.rc
• Initializing device information
• Looping polling uevent messages

The main functions and related functions are as follows:

[CPP]View PlainCopy

2. int Ueventd_main (int argc, char **argv)
4. {
6. //As with INIT, no std input and output
8. Open_devnull_stdio ();
10. //Initialize kernel log, let Ueventd log output to the string via kernel PRINTK log
12. Klog_init ();
16. //parsing and processing of UEVENTD RC files
18. Import_kernel_cmdline (0, Import_kernel_nv);
20. Get_hardware_name (Hardware, &revision);
22. Ueventd_parse_config_file ("/ueventd.rc");
24. SNPRINTF (TMP, sizeof (TMP), "/ueventd.%s.rc", hardware);
26. Ueventd_parse_config_file (TMP);
30. //Device initialization
32. Device_init ();
38. //Polling uevent messages to manage the device
40. Ufd.events = Pollin;
42. UFD.FD = GET_DEVICE_FD ();
44. While (1) {
46. ufd.revents = 0;
48. NR = Poll (&UFD, 1,-1);
50. if (nr <= 0)
52. continue;
54. if (ufd.revents = = Pollin)
56. HANDLE_DEVICE_FD (); //Polling to message, handling event message
58. }
60. }

Processing and parsing ueventd.rc
This part compared to init.rc, giant simple, nothing special. Mainly through the RC file, to control the permissions of the directory node. Such as:

[Plain]View PlainCopy

1. /DEV/TTYUSB2 0666 Radio Radio
2. /dev/ts0710mux* 0640 Radio Radio
3. /DEV/PPP 0666 Radio VPN
5. # SYSFS Properties
6. /sys/devices/virtual/input/input* Enable 0666 System system
7. /sys/devices/virtual/input/input* Poll_delay 0666 System System

Details should not need to be expanded, basically can understand.

Device initialization
Kernel when the device is loaded, the Uevent event is sent through the socket to userspace, in Init, to create the node of the device by accepting these uevent events. The main function is Device_init ()

The initialization function is Device_init, as follows

[CPP]View PlainCopy

2. void Device_init (void)
4. {
6. suseconds_t t0, T1;
8. struct STAT info;
10. int fd;
14. Sehandle = NULL;
16. if (is_selinux_enabled () > 0) {
18. Sehandle = Selinux_android_file_context_handle ();
20. }
24. / * is 256K enough udev uses 16mb! * /
26. DEVICE_FD = Uevent_open_socket (256*1024, true);
28. if (device_fd < 0)
30. return;
34. Fcntl (DEVICE_FD, F_SETFD, fd_cloexec);
36. Fcntl (DEVICE_FD, F_SETFL, O_nonblock);
40. if (stat (Coldboot_done, &info) < 0) {
42. T0 = Get_usecs ();
44. Coldboot ("/sys/class");
46. Coldboot ("/sys/block");
48. Coldboot ("/sys/devices");
50. T1 = Get_usecs ();
52. FD = open (Coldboot_done, o_wronly| o_creat, 0000);
54. Close (FD);
56. Log_event_print ("Coldboot%ld us\n", ((long) (t1-t0)));
58. } Else {
60. Log_event_print ("Skipping coldboot, already done\n");
62. }
64. }

Open_uevent_socket ();
This is the socket that opens the uevent. The uevent here is used to netlink the kernel event to the User state notification (netlink_kobject_uevent) function, is the kernel and the user configuration for two-way data transmission of the very good way, in addition to eventd outside, NETD and Vold are also used in uevent.
In the initialization function, the comparison to pay attention to the Coldboot this function, the literal meaning is cold start, it is the role of those in the Uventd before the start, already add on the driver, and then re-operation, let them send an event message, the upper number targeted processing.
Here, the devices under/sys/class,/sys/block and/sys/devices are traversed again:

[CPP]View PlainCopy

2. static void Do_coldboot (DIR *d)
4. {
6. struct dirent *de;
8. int DFD, FD;
12. DFD = DIRFD (d);
16. FD = Openat (DFD, "Uevent", o_wronly);
18. if (fd >= 0) {
20. Write (FD, "add\n", 4);
22. Close (FD);
24. HANDLE_DEVICE_FD ();
26. }
30. While ((de = Readdir (d))) {
32. DIR *d2;
36. if (de->d_type! = Dt_dir | | de->d_name[0] = = '. ')
38. continue;
42. FD = Openat (DFD, de->d_name, O_rdonly | O_directory);
44. if (FD < 0)
46. continue;
50. D2 = Fdopendir (FD);
52. if (D2 = = 0)
54. Close (FD);
56. else {
58. Do_coldboot (D2);
60. Closedir (D2);
62. }
64. }
66. }

Write (FD, "add\n", 4) activates the kernel, re-sends the UEVENT,HANDLE_DEVICE_FD () of the Add event, and responds to the event message.

Uevent Message Processing

After the initialization is good, daemon program as long as polling new event events, polling to, call HANDLE_DEVICE_FD (), to handle, you can look at this function:

[CPP]View PlainCopy

2. void Handle_device_fd ()
4. {
6. Char msg[uevent_msg_len+2];
8. int n;
10. While ((n = uevent_kernel_multicast_recv (DEVICE_FD, MSG, uevent_msg_len)) > 0) {
12. if (n >= uevent_msg_len) /* Overflow--Discard * /
14. continue;
18. Msg[n] = ' + ';
20. MSG[N+1] = ' + ';
24. struct uevent uevent;
26. Parse_event (msg, &uevent);
30. Handle_device_event (&uevent);
32. Handle_firmware_event (&uevent);
34. }
36. }

The function is to accept the inside of the event message, and then parser this message to process the corresponding message event.

Over here:

[CPP]View PlainCopy

2. static void handle_device_event (struct uevent *uevent)
4. {
6. if (!strcmp (Uevent->action,"add") | |!strcmp (uevent->action, "Change"))
8. Fixup_sys_perms (Uevent->path);
12. if (!strncmp (Uevent->subsystem, "block", 5)) {
14. Handle_block_device_event (uevent);
16. } Else if (!strncmp (Uevent->subsystem, "platform", 8)) {
18. Handle_platform_device_event (uevent);
20. } Else {
22. Handle_generic_device_event (uevent);
24. }
26. }

The main function is to create/delete device nodes based on the uevent sent, and update some node permissions with the permission settings described in Ueventd.rc.

[CPP]View PlainCopy

2. static void handle_firmware_event (struct uevent *uevent)
4. {
6. pid_t pid;
8. int ret;
12. if (strcmp (Uevent->subsystem, "firmware"))
14. return;
18. if (strcmp (Uevent->action, "Add"))
20. return;
24. / * We fork, to avoid making large memory allocations in init proper * /
26. PID = fork ();
28. if (!pid) {
30. Process_firmware_event (uevent);
32. Exit (exit_success);
34. }
36. }

If there is a coprocessor, but also to download the coprocessor firmware, here is the processing coprocessor to download firmware instructions, fork a child process processing.

Android Init Process Analysis Ueventd