一、Android热插拔事件处理流程图

Android热插拔事件处理流程如下图所示：

二、组成

1. NetlinkManager:
全称是NetlinkManager.cpp位于Android 4.x 源码位置/system/vold/NetlinkManager.cpp。该类的主要通过引用NetlinkHandler类中的onEvent()方法来接收来自内核的事件消息，NetlinkHandler位于/system/vold/NetlinkHandler.cpp。

2. VolumeManager:
全称是VolumeManager.cpp位于Android 4.x源码位置/system/vold/VolumeManager.cpp。该类的主要作用是接收经过NetlinkManager处理过后的事件消息。因为我们这里是SD的挂载，因此经过NetlinkManager处理过后的消息会分为五种，分别是：block,switch,usb_composite,battery,power_supply。这里SD卡挂载的事件是block。

3. DirectVolume:
位于/system/vold/DirectVolume.cpp。该类的是一个工具类，主要负责对传入的事件进行进一步的处理，block事件又可以分为：Add,Removed,Change,Noaction这四种。后文通过介绍Add事件展开。

4. Volume:
位于/system/vold/Volume.cpp，该类是负责SD卡挂载的主要类。Volume.cpp主要负责检查SD卡格式，以及对复合要求的SD卡进行挂载，并通过Socket将消息SD卡挂载的消息传递给NativeDaemonConnector。

5. CommandListener:
该类位于位于/system/vold/CommandListener.cpp。通过vold socket与NativeDaemonConnector通信。

6. NativeDaemonConnector:
该类位于frameworks/base/services/java/com.android.server/NativeDaemonConnector.java。该类用于接收来自Volume.cpp 发来的SD卡挂载消息并向上传递。

7. MountService:
位于frameworks/base/services/java/com.android.server/MountService.java。MountService是一个服务类，该服务是系统服务，提供对外部存储设备的管理、查询等。在外部存储设备状态发生变化的时候，该类会发出相应的通知给上层应用。在Android系统中这是一个非常重要的类。

8.StorageManaer:
位于frameworks/base/core/java/andriod/os/storage/StorageManager.java。在该类的说明中有提到，该类是系统存储服务的接口。在系统设置中，有Storage相关项，同时Setting也注册了该类的监听器。而StorageManager又将自己的监听器注册到了MountService中，因此该类主要用于上层应用获取SD卡状态。

三、典型流程描述 (SD卡挂载流程)

整个过程从Kernel检测到SD卡插入事件开始，之前的一些硬件中断的触发以及driver的加载这里并不叙述，一直到SD卡挂载消息更新到“Android——系统设置——存储”一项中。
1. Kernel发出SD卡插入uevent。
2.NetlinkHandler::onEvent()接收内核发出的uevent并进行解析。
3. VolumeManager::handlBlockEvent()处理经过第二步处理后的事件。
4. 接下来调用DirectVolume:: handleBlockEvent()。
在该方法中主要有两点需要注意：
第一，程序首先会遍历mPath容器，寻找与event对应的sysfs_path是否存在与mPath容器中。
第二，针对event中的action有4种处理方式：Add,Removed,Change,Noaction 。
例如：在Add action中会有如下操作(因为我们这里所讲的是SD卡的挂载流程，因此以Add来说明),首先创建设备节点，其次对disk和partition两种格式的设备分别进行处理。SD卡属于disk类型。
5. 经过上一步之后会调用DirectVolume::handleDiskAdded()方法，在该方法中会广播disk insert消息。
6. SocketListener::runListener会接收DirectVolume::handleDiskAdded()广播的消息。该方法主要完成对event中数据的获取，通过Socket。(PS:这里的SocketListener.cpp位于Android源码/system/core/libsysutils/src/中，后文的FramworkListener.cpp也是，之前自己找了很久 T_T)
7. 调用FrameworkListener::onDataAvailable()方法处理接收到的消息内容。
8. FrameworkListener::dispatchCommand()该方法用于分发指令。
9. 在FrameworkListener::dispatchCommand()方法中，通过runCommand()方法去调用相应的指令。
10. 在/system/vold/CommandListener.cpp中有runCommand()的具体实现。在该类中可以找到这个方法：CommandListener::VolumeCmd::runCommand()，从字面意思上来看这个方法就是对Volume分发指令的解析。该方法中会执行“mount”函数：vm->mountVolume(arg[2])。
11. mountVolume(arg[2])在VolumeManager::mountVolume()中实现，在该方法中调用v->mountVol()。
12. mountVol()方法在Volume::mountVol()中实现，该函数是真正的挂载函数。(在该方法中，后续的处理都在该方法中，在Mount过程中会广播相应的消息给上层，通过setState()函数。)
13. setState(Volume::Checking);广播给上层，正在检查SD卡，为挂载做准备。
14. Fat::check();SD卡检查方法，检查SD卡是否是FAT格式。
15. Fat::doMount()挂载SD卡。
至此，SD的挂载已算初步完成，接下来应该将SD卡挂载后的消息发送给上层，在13中也提到过，在挂载以及检查的过程中其实也有发送消息给上层的。
16. MountService的构造函数中会开启监听线程，用于监听来自vold的socket信息。
Thread thread = new Thread(mConnector,VOLD_TAG); thread.start();
17. mConnector是NativeDaemonConnector的对象，NativeDaemonConnector继承了Runnable并Override了run方法。在run方法中通过一个while(true)调用ListenToSocket()方法来实现实时监听。
18. 在ListenToSocket()中，首先建立与Vold通信的Socket Server端，然后调用MountService中的onDaemonConnected()方法。(PS:Java与Native通信可以通过JNI，那么Native与Java通信就需要通过Socket来实现了。Android中Native与Frameworks通信 这篇文章中有简介，感兴趣的朋友可以参考一下)
19. onDaemonConnected()方法是在接口INativeDaemonConnectorCallbacks中定义的，MountService实现了该接口并Override了onDaemonConnected()方法。该方法开启一个线程用于更新外置存储设备的状态，主要更新状态的方法也在其中实现。
20. 然后回到ListenToSocket中，通过inputStream来获取Vold传递来的event，并存放在队列中。
21. 然后这些event会在onDaemonConnected()通过队列的”队列.take()”方法取出。并根据不同的event调用updatePublicVolumeState()方法，在该方法中调用packageManagerService中的updateExteralState()方法来更新存储设备的状态。(注：这里不太理解packageManagerService中的unloadAllContainers(args)方法)
22. 更新是通过packageHelper.getMountService().finishMediaUpdate()方法来实现的。
23. 在updatePublicVolumeState()方法中，更新后会执行如下代码：
bl.mListener.onStorageStateChanged();
在Android源码/packages/apps/Settings/src/com.android.settings.deviceinfo/Memory.java代码中，实现了StorageEventListener 的匿名内部类，并Override了onStorageStateChanged();方法。因此在updatePublicVolumeState()中调用onStorageStateChanged();方法后，Memory.java中也会收到。在Memory.java中收到以后会在Setting界面进行更新,系统设置——存储中会更新SD卡的状态。从而SD卡的挂载从底层到达了上层。

四、Vold

1. Vold简介

Vold的全称是volume daemon。主要负责系统对大容量存储设备(USB/SD)的挂载/卸载任务，它是一个守护进程，该进程支持这些存储外设的热插拔。自Android 2.2开始，Vold升级为vold 2.0，配置文件路径在Android 4.0之后变为/etc/vold.fstab。

2.Vold工作流程

Vold的工作流程大致可以分为三个部分:创建监听、引导、事件处理。

(1)创建监听

创建监听指的是创建监听链接，一方面用于监听来自内核的uevent，另一方面用于监听来自上层的控制命令，这些命令包括控制SD卡的挂载与卸载，这里所说的链接也就是socket。在Android 系统启动的时候，init进程会去解析init.rc文件，在该文件中，有如下代码：

Service vold /system/bin/vold
Socket vold stream 0660 root mount
Iprio be 2

这样系统会在启动的时候创建与上层通信的socket，此socket name为"vold"。

在Android 4.0源码/system/vold路径下的main.cpp<NetlinkManager::start():socket(PF_NETLINK,SOCK_DGRAM,NETLINK_KOBJECT_UEVENT) >中创建了与内核通信的socket。在main.cpp中通过实例化VolumeManager和NetlinkManager时创建。

(2)引导

Vold进程启动时候会对现有的外部存储设备进行检查。首先加载并解析vold.fstab，并检查挂载点是否已被挂载。然后执行SD卡的挂载，最后处理USB大容量存储。因为系统是按行解析的，通过查看vold.fstab可以很清楚的知道这一点。
vold.fatab中最重要的语句：

dev_mount sdcard /mnt/sdcard auto /devices/platform/rk29_sdmmc.0/mmc_host/mmc0
dev_mount <lable> <mount_point> <part> <sysfs_path…>
挂载命令 标签 挂载点第几个分区 设备的sysfs paths
注：
第几个分区：如果为auto则表示第1个分区。
参数之间不能有空格，只能以tab为间隔(注意：这里为了对齐因此采用空格隔开，如果自行修改vold.fstab之后加以空格的话系统会识别不到的)。
如果vold.fstab解析无误，VolueManager将创建DirectVolume，若vold.fstab解析不存在或者打开失败，Vold将会读取Linux内核中的参数，此时如果参数中存在SDCARD(也就是SD的默认路径)，VolumeManager则会创建AutoVolume，如果不存在这个默认路径那么就不会创建。

(3)事件处理

通过对两个socket的监听，完成对事件的处理以及对上层应用的响应。

a) Kernel发出uevent
NetlinkManager检测到kernel发出的uevent，解析后调用NetlinkHandler::onEvent()方法。该方法会分别处理不同的事件，这里重要的事件有：
“block”事件主要指Volume的mount、unmount、createAsec等。由VolumeManager的handleBlockEvent(evt)来处理，根据多态性最终将会调用AutoVolume或者DirectVolume的handleBlockEvent方法来处理。
“switch”事件主要指Volume的connet、disconnet等。根据相关操作，改变设备参数(设备类型、挂载点等)通过CommandListener告知FrameWork层。

b)FrameWork发出控制命令
与a)相反，CommandListener检测到FrameWork层的命令(MountService发出的命令)调用VolumeManager的函数，VolumeManager找出对应的Volume，调用Volume函数去挂载/卸载操作。而Volume类中的相关操作最终通过调用Linux函数完成。

五、Vold用户态

1. NetlinkManager

NetlinkManager负责与Kernel交互，通过PF_NETLINK来现。

Vlod启动代码如下(/system/vold/main.cpp)：

[cpp] view plain copy

1. intmain(){
3. VolumeManager*vm;
4. CommandListener*cl;
5. NetlinkManager*nm;
7. SLOGI("Vold2.1(therevenge)firingup");
9. mkdir("/dev/block/vold",0755);
11. /*Createoursingletonmanagers*/
12. if(!(vm=VolumeManager::Instance())){
13. SLOGE("UnabletocreateVolumeManager");
14. exit(1);
15. };
17. if(!(nm=NetlinkManager::Instance())){
18. SLOGE("UnabletocreateNetlinkManager");
19. exit(1);
20. };
23. cl=newCommandListener();
24. vm->setBroadcaster((SocketListener*)cl);
25. nm->setBroadcaster((SocketListener*)cl);
27. if(vm->start()){
28. SLOGE("UnabletostartVolumeManager(%s)",strerror(errno));
29. exit(1);
30. }
32. /*解析/etc/vold.fstab文件，
33. 读取type，label,mount_point,part
34. 1)构建DirectVolume对象：如果part为auto，则调用dv=newDirectVolume(vm,label,mount_point,-1);
35. 2)添加vold.fstab中定义的某一挂载项对应的sysfs_path到DirectVolume对象的mPaths容器dv->addPath(sysfs_path);
36. 3)将这个DirectVolume对象添加到VolumeManager对象的容器mVolumes中vm->addVolume(dv)；
37. */
38. if(process_config(vm)){
39. SLOGE("Errorreadingconfiguration(%s)...continuinganyways",strerror(errno));
40. }
42. /*会调用NetlinkManager类的start()方法，它创建PF_NETLINKsocket,
43. 并开启线程从此socket中读取数据*/
44. if(nm->start()){
45. SLOGE("UnabletostartNetlinkManager(%s)",strerror(errno));
46. exit(1);
47. }
49. #ifdefUSE_USB_MODE_SWITCH
50. SLOGE("StartMiscdevicesManager...");
51. MiscManager*mm;
52. if(!(mm=MiscManager::Instance())){
53. SLOGE("UnabletocreateMiscManager");
54. exit(1);
55. };
56. mm->setBroadcaster((SocketListener*)cl);
57. if(mm->start()){
58. SLOGE("UnabletostartMiscManager(%s)",strerror(errno));
59. exit(1);
60. }
61. G3Dev*g3=newG3Dev(mm);
62. g3->handleUsb();
63. mm->addMisc(g3);
64. #endif
65. coldboot("/sys/block");//冷启动，vold错过了一些uevent,重新触发。向sysfs的uevent文件写入”add\n”字符也可以触发sysfs事件，相当执行了一次热插拔。
67. //coldboot("/sys/class/switch");
69. /*
70. *Nowthatwe'reup,wecanrespondtocommands
71. */
72. if(cl->startListener()){
73. SLOGE("UnabletostartCommandListener(%s)",strerror(errno));
74. exit(1);
75. }
77. //Eventuallywe'llbecomethemonitoringthread
78. while(1){
79. sleep(1000);
80. }
82. SLOGI("Voldexiting");
83. exit(0);
84. }

NetlinkManager的家族关系如下所示：

上图中的虚线为启动是的调用流程。
(1) class NetlinkManager(在其start函数中创建了NetlinkHandler对象，并把创建的socket作为参数)

(2)class NetlinkHandler: public NetlinkListener(实现了onEvent)
(3) class NetlinkListener : public SocketListener (实现了onDataAvailable)
(4) class SocketListener(实现了runListener，在一个线程中通过select查看哪些socket有数据，通过调用onDataAvailable来读取数据)

2. NetlinkManager::start()

[cpp] view plain copy

1. intNetlinkManager::start(){
2. structsockaddr_nlnladdr;
3. intsz=64*1024;
4. inton=1;
6. memset(&nladdr,0,sizeof(nladdr));
7. nladdr.nl_family=AF_NETLINK;
8. nladdr.nl_pid=getpid();
9. nladdr.nl_groups=0xffffffff;
10. //创建一个socket用于内核空间和用户空间的异步通信，监控系统的hotplug事件
11. if((mSock=socket(PF_NETLINK,
12. SOCK_DGRAM,NETLINK_KOBJECT_UEVENT))<0){
13. SLOGE("Unabletocreateueventsocket:%s",strerror(errno));
14. return-1;
15. }
17. if(setsockopt(mSock,SOL_SOCKET,SO_RCVBUFFORCE,&sz,sizeof(sz))<0){
18. SLOGE("UnabletosetueventsocketSO_RECBUFFORCEoption:%s",strerror(errno));
19. return-1;
20. }
22. if(setsockopt(mSock,SOL_SOCKET,SO_PASSCRED,&on,sizeof(on))<0){
23. SLOGE("UnabletosetueventsocketSO_PASSCREDoption:%s",strerror(errno));
24. return-1;
25. }
27. if(bind(mSock,(structsockaddr*)&nladdr,sizeof(nladdr))<0){
28. SLOGE("Unabletobindueventsocket:%s",strerror(errno));
29. return-1;
30. }
31. //利用新创建的socket实例化一个NetlinkHandler类对象，NetlinkHandler继承了类NetlinkListener，
32. //NetlinkListener又继承了类SocketListener
33. mHandler=newNetlinkHandler(mSock);
34. if(mHandler->start()){//启动NetlinkHandler
35. SLOGE("UnabletostartNetlinkHandler:%s",strerror(errno));
36. return-1;
37. }
38. return0;
39. }

把socket作为参数创建了NetlinkHandler对象，然后启动NetlinkHandler。

[cpp] view plain copy

1. intNetlinkHandler::start(){
2. returnthis->startListener();
3. }
5. intSocketListener::startListener(){
7. if(!mSocketName&&mSock==-1){
8. SLOGE("Failedtostartunboundlistener");
9. errno=EINVAL;
10. return-1;
11. }elseif(mSocketName){
12. if((mSock=android_get_control_socket(mSocketName))<0){
13. SLOGE("Obtainingfiledescriptorsocket'%s'failed:%s",
14. mSocketName,strerror(errno));
15. return-1;
16. }
17. }
19. if(mListen&&listen(mSock,4)<0){
20. SLOGE("Unabletolistenonsocket(%s)",strerror(errno));
21. return-1;
22. }elseif(!mListen)
23. mClients->push_back(newSocketClient(mSock,false));
25. if(pipe(mCtrlPipe)){
26. SLOGE("pipefailed(%s)",strerror(errno));
27. return-1;
28. }
30. if(pthread_create(&mThread,NULL,SocketListener::threadStart,this)){
31. SLOGE("pthread_create(%s)",strerror(errno));
32. return-1;
33. }
35. return0;
36. }
38. void*SocketListener::threadStart(void*obj){
39. SocketListener*me=reinterpret_cast<SocketListener*>(obj);
41. me->runListener();
42. pthread_exit(NULL);
43. returnNULL;
44. }
46. voidSocketListener::runListener(){
48. SocketClientCollection*pendingList=newSocketClientCollection();
50. while(1){//死循环，一直监听
51. SocketClientCollection::iteratorit;
52. fd_setread_fds;
53. intrc=0;
54. intmax=-1;
56. FD_ZERO(&read_fds);//清空文件描述符集read_fds
58. if(mListen){
59. max=mSock;
60. FD_SET(mSock,&read_fds);//添加文件描述符到文件描述符集read_fds
61. }
63. FD_SET(mCtrlPipe[0],&read_fds);//添加管道的读取端文件描述符到read_fds
64. if(mCtrlPipe[0]>max)
65. max=mCtrlPipe[0];
67. pthread_mutex_lock(&mClientsLock);//对容器mClients的操作需要加锁
68. for(it=mClients->begin();it!=mClients->end();++it){
69. intfd=(*it)->getSocket();
70. FD_SET(fd,&read_fds);////遍历容器mClients的所有成员，调用内联函数getSocket()获取文件描述符，并添加到文件描述符集read_fds
71. if(fd>max)
72. max=fd;
73. }
74. pthread_mutex_unlock(&mClientsLock);
75. //等待文件描述符中某一文件描述符或者说socket有数据到来
76. if((rc=select(max+1,&read_fds,NULL,NULL,NULL))<0){
77. if(errno==EINTR)
78. continue;
79. SLOGE("selectfailed(%s)",strerror(errno));
80. sleep(1);
81. continue;
82. }elseif(!rc)
83. continue;
85. if(FD_ISSET(mCtrlPipe[0],&read_fds))
86. break;
87. if(mListen&&FD_ISSET(mSock,&read_fds)){//监听套接字处理
88. structsockaddraddr;
89. socklen_talen;
90. intc;
92. do{
93. alen=sizeof(addr);
94. c=accept(mSock,&addr,&alen);//接收链接请求，建立连接，如果成功c即为建立链接后的数据交换套接字,将其添加到mClient容器
95. }while(c<0&&errno==EINTR);
96. if(c<0){
97. SLOGE("acceptfailed(%s)",strerror(errno));
98. sleep(1);
99. continue;
100. }
101. pthread_mutex_lock(&mClientsLock);
102. mClients->push_back(newSocketClient(c,true));
103. pthread_mutex_unlock(&mClientsLock);
104. }
106. /*Addallactiveclientstothependinglistfirst*/
107. pendingList->clear();
108. pthread_mutex_lock(&mClientsLock);
109. for(it=mClients->begin();it!=mClients->end();++it){
110. intfd=(*it)->getSocket();
111. if(FD_ISSET(fd,&read_fds)){
112. pendingList->push_back(*it);
113. }
114. }
115. pthread_mutex_unlock(&mClientsLock);
117. /*Processthependinglist,sinceitisownedbythethread,
118. *thereisnoneedtolockit*/
119. while(!pendingList->empty()){//非监听套接字处理
120. /*Popthefirstitemfromthelist*/
121. it=pendingList->begin();
122. SocketClient*c=*it;
123. pendingList->erase(it);
124. /*Processit,iffalseisreturnedandoursocketsare
125. *connection-based,removeanddestroyit*/
126. //******onDataAvailable在NetlinkListener中实现*********
127. if(!onDataAvailable(c)&&mListen){
128. /*Removetheclientfromourarray*/
129. pthread_mutex_lock(&mClientsLock);
130. for(it=mClients->begin();it!=mClients->end();++it){
131. if(*it==c){
132. mClients->erase(it);
133. break;
134. }
135. }
136. pthread_mutex_unlock(&mClientsLock);
137. /*Removeourreferencetotheclient*/
138. c->decRef();
139. }
140. }
141. }
142. deletependingList;
143. }

SocketListener::runListener是线程真正执行的函数：mListen成员用来判定是否监听套接字，Netlink套接字属于udp套接字，非监听套接字，该函数的主要功能体现在，如果该套接字有数据到来，就调用函数onDataAvailable读取数据。

3. NetlinkListener::onDataAvailable

[cpp] view plain copy

1. boolNetlinkListener::onDataAvailable(SocketClient*cli)
2. {
3. intsocket=cli->getSocket();
4. ssize_tcount;
6. //从socket中读取kernel发送来的uevent消息
7. count=TEMP_FAILURE_RETRY(uevent_kernel_multicast_recv(socket,mBuffer,sizeof(mBuffer)));
8. if(count<0){
9. SLOGE("recvmsgfailed(%s)",strerror(errno));
10. returnfalse;
11. }
13. NetlinkEvent*evt=newNetlinkEvent();
14. if(!evt->decode(mBuffer,count,mFormat)){
15. SLOGE("ErrordecodingNetlinkEvent");
16. }else{
17. onEvent(evt);//在NetlinkHandler中实现
18. }
20. deleteevt;
21. returntrue;
22. }

4. NetlinkHandler::onEvent

[cpp] view plain copy

1. voidNetlinkHandler::onEvent(NetlinkEvent*evt){
2. VolumeManager*vm=VolumeManager::Instance();
3. constchar*subsys=evt->getSubsystem();
5. if(!subsys){
6. SLOGW("Nosubsystemfoundinnetlinkevent");
7. return;
8. }
10. if(!strcmp(subsys,"block")){
11. if(uEventOnOffFlag)
12. {
13. SLOGW("####netlinkeventblock####");
14. evt->dump();
15. }
16. vm->handleBlockEvent(evt);
17. #ifdefUSE_USB_MODE_SWITCH
18. }elseif(!strcmp(subsys,"usb")
19. ||!strcmp(subsys,"scsi_device")){
20. SLOGW("subsystemfoundinnetlinkevent");
21. MiscManager*mm=MiscManager::Instance();
22. mm->handleEvent(evt);
23. #endif
24. }
25. }

5. uevent_kernel_multicast_recv

[cpp] view plain copy

1. /**
2. *Likerecv(),butchecksthatmessagesactuallyoriginatefromthekernel.
3. */
4. ssize_tuevent_kernel_multicast_recv(intsocket,void*buffer,size_tlength){
5. structioveciov={buffer,length};
6. structsockaddr_nladdr;
7. charcontrol[CMSG_SPACE(sizeof(structucred))];
8. structmsghdrhdr={
9. &addr,
10. sizeof(addr),
11. &iov,
12. 1,
13. control,
14. sizeof(control),
15. 0,
16. };
18. ssize_tn=recvmsg(socket,&hdr,0);
19. if(n<=0){
20. returnn;
21. }
23. if(addr.nl_groups==0||addr.nl_pid!=0){
24. /*ignoringnon-kernelorunicastnetlinkmessage*/
25. gotoout;
26. }
28. structcmsghdr*cmsg=CMSG_FIRSTHDR(&hdr);
29. if(cmsg==NULL||cmsg->cmsg_type!=SCM_CREDENTIALS){
30. /*ignoringnetlinkmessagewithnosendercredentials*/
31. gotoout;
32. }
34. structucred*cred=(structucred*)CMSG_DATA(cmsg);
35. if(cred->uid!=0){
36. /*ignoringnetlinkmessagefromnon-rootuser*/
37. gotoout;
38. }
40. returnn;
42. out:
43. /*clearresidualpotentiallymaliciousdata*/
44. bzero(buffer,length);
45. errno=EIO;
46. return-1;
47. }

六、与Vold相关的Kernel态

• 用户态创建的netlink sock被kernel保存在：nl_table[sk->sk_protocol].mc_list
• Kernel态创建的netlink sock被kernel保存在：uevent_sock_list，上面的sk->sk_protocol为uevent_sock_list的协议, 二者只有协议一致才可以发送。

1. 创建kernel态sock

• 在用户态的socket创建方式（/system/vold/NetlinkManager.cpp）：
  

[cpp] view plain copy

1. if((mSock=socket(PF_NETLINK,
2. SOCK_DGRAM,NETLINK_KOBJECT_UEVENT))<0){
3. SLOGE("Unabletocreateueventsocket:%s",strerror(errno));
4. return-1;
5. }

• 在Kernel的socket创建方式(/kernel/lib/kobject_uevent.c)：

[cpp] view plain copy

1. staticintuevent_net_init(structnet*net)
2. {
3. structuevent_sock*ue_sk;
5. ue_sk=kzalloc(sizeof(*ue_sk),GFP_KERNEL);
6. if(!ue_sk)
7. return-ENOMEM;
9. ue_sk->sk=netlink_kernel_create(net,NETLINK_KOBJECT_UEVENT,
10. 1,NULL,NULL,THIS_MODULE);
11. if(!ue_sk->sk){
12. printk(KERN_ERR
13. "kobject_uevent:unabletocreatenetlinksocket!\n");
14. kfree(ue_sk);
15. return-ENODEV;
16. }
17. mutex_lock(&uevent_sock_mutex);
18. list_add_tail(&ue_sk->list,&uevent_sock_list);
19. mutex_unlock(&uevent_sock_mutex);
20. return0;
21. }

从上面的代码可知，此sock被创建之后，被增加到全局变量uevent_sock_list列表中，下面的分析围绕此列表进行。

• netlink_kernel_create函数原型：

[cpp] view plain copy

1. structsock*netlink_kernel_create(structnet*net,intunit,unsignedintgroups,
2. void(*input)(structsk_buff*skb),
3. structmutex*cb_mutex,structmodule*module)

1)struct net *net:是一个网络名字空间namespace，在不同的名字空间里面可以有自己的转发信息库，有自己的一套net_device等等。默认情况下都是使用init_net这个全局变量

2)int unit:表示netlink协议类型，如 NETLINK_KOBJECT_UEVENT

3)unsigned int groups: 组类型

4)void (*input)(struct sk_buff *skb):参数input则为内核模块定义的netlink消息处理函数，当有消息到达这个netlink socket时，该input函数指针就会被调用。函数指针input的参数skb实际上就是函数netlink_kernel_create返回的 struct sock指针，sock实际是socket的一个内核表示数据结构，用户态应用创建的socket在内核中也会有一个struct sock结构来表示。

5) struct mutex *cb_mutex: 互斥销

6) struct module *module: 一般为THIS_MODULE

• struct sock

用户态socket在kernel中的表示。

2.相关数据结构

相关数据结构如下图所示：

3.发送消息给用户空间

3.1 发送消息流程图

3.2 kobject_uevent_env

[cpp] view plain copy

1. /**
2. *kobject_uevent_env-sendanueventwithenvironmentaldata
3. *
4. *@action:actionthatishappening
5. *@kobj:structkobjectthattheactionishappeningto
6. *@envp_ext:pointertoenvironmentaldata
7. *
8. *Returns0ifkobject_uevent_env()iscompletedwithsuccessorthe
9. *correspondingerrorwhenitfails.
10. */
11. intkobject_uevent_env(structkobject*kobj,enumkobject_actionaction,
12. char*envp_ext[])
13. {
14. structkobj_uevent_env*env;
15. constchar*action_string=kobject_actions[action];
16. constchar*devpath=NULL;
17. constchar*subsystem;
18. structkobject*top_kobj;
19. structkset*kset;
20. conststructkset_uevent_ops*uevent_ops;
21. u64seq;
22. inti=0;
23. intretval=0;
24. #ifdefCONFIG_NET
25. structuevent_sock*ue_sk;
26. #endif
28. pr_debug("kobject:'%s'(%p):%s\n",
29. kobject_name(kobj),kobj,__func__);
31. /*searchtheksetwebelongto*/
32. top_kobj=kobj;
33. while(!top_kobj->kset&&top_kobj->parent)
34. top_kobj=top_kobj->parent;
36. if(!top_kobj->kset){
37. pr_debug("kobject:'%s'(%p):%s:attemptedtosenduevent"
38. "withoutkset!\n",kobject_name(kobj),kobj,
39. __func__);
40. return-EINVAL;
41. }
43. kset=top_kobj->kset;
44. uevent_ops=kset->uevent_ops;
46. /*skiptheevent,ifuevent_suppressisset*/
47. if(kobj->uevent_suppress){
48. pr_debug("kobject:'%s'(%p):%s:uevent_suppress"
49. "causedtheeventtodrop!\n",
50. kobject_name(kobj),kobj,__func__);
51. return0;
52. }
53. /*skiptheevent,ifthefilterreturnszero.*/
54. if(uevent_ops&&uevent_ops->filter)
55. if(!uevent_ops->filter(kset,kobj)){
56. pr_debug("kobject:'%s'(%p):%s:filterfunction"
57. "causedtheeventtodrop!\n",
58. kobject_name(kobj),kobj,__func__);
59. return0;
60. }
62. /*originatingsubsystem*/
63. if(uevent_ops&&uevent_ops->name)
64. subsystem=uevent_ops->name(kset,kobj);
65. else
66. subsystem=kobject_name(&kset->kobj);
67. if(!subsystem){
68. pr_debug("kobject:'%s'(%p):%s:unsetsubsystemcausedthe"
69. "eventtodrop!\n",kobject_name(kobj),kobj,
70. __func__);
71. return0;
72. }
74. /*environmentbuffer*/
75. env=kzalloc(sizeof(structkobj_uevent_env),GFP_KERNEL);
76. if(!env)
77. return-ENOMEM;
79. /*completeobjectpath*/
80. devpath=kobject_get_path(kobj,GFP_KERNEL);
81. if(!devpath){
82. retval=-ENOENT;
83. gotoexit;
84. }
86. /*defaultkeys*/
87. retval=add_uevent_var(env,"ACTION=%s",action_string);
88. if(retval)
89. gotoexit;
90. retval=add_uevent_var(env,"DEVPATH=%s",devpath);
91. if(retval)
92. gotoexit;
93. retval=add_uevent_var(env,"SUBSYSTEM=%s",subsystem);
94. if(retval)
95. gotoexit;
97. /*keyspassedinfromthecaller*/
98. if(envp_ext){
99. for(i=0;envp_ext[i];i++){
100. retval=add_uevent_var(env,"%s",envp_ext[i]);
101. if(retval)
102. gotoexit;
103. }
104. }
106. /*lettheksetspecificfunctionadditsstuff*/
107. if(uevent_ops&&uevent_ops->uevent){
108. retval=uevent_ops->uevent(kset,kobj,env);
109. if(retval){
110. pr_debug("kobject:'%s'(%p):%s:uevent()returned"
111. "%d\n",kobject_name(kobj),kobj,
112. __func__,retval);
113. gotoexit;
114. }
115. }
117. /*
118. *Mark"add"and"remove"eventsintheobjecttoensureproper
119. *eventstouserspaceduringautomaticcleanup.Iftheobjectdid
120. *sendan"add"event,"remove"willautomaticallygeneratedby
121. *thecore,ifnotalreadydonebythecaller.
122. */
123. if(action==KOBJ_ADD)
124. kobj->state_add_uevent_sent=1;
125. elseif(action==KOBJ_REMOVE)
126. kobj->state_remove_uevent_sent=1;
128. /*wewillsendanevent,sorequestanewsequencenumber*/
129. spin_lock(&sequence_lock);
130. seq=++uevent_seqnum;
131. spin_unlock(&sequence_lock);
132. retval=add_uevent_var(env,"SEQNUM=%llu",(unsignedlonglong)seq);
133. if(retval)
134. gotoexit;
136. #ifdefined(CONFIG_NET)
137. /*sendnetlinkmessage*/
138. mutex_lock(&uevent_sock_mutex);
139. list_for_each_entry(ue_sk,&uevent_sock_list,list){
140. structsock*uevent_sock=ue_sk->sk;
141. structsk_buff*skb;
142. size_tlen;
144. /*allocatemessagewiththemaximumpossiblesize*/
145. len=strlen(action_string)+strlen(devpath)+2;
146. skb=alloc_skb(len+env->buflen,GFP_KERNEL);
147. if(skb){
148. char*scratch;
150. /*addheader*/
151. scratch=skb_put(skb,len);
152. sprintf(scratch,"%s@%s",action_string,devpath);//action_string+devpath
154. /*copykeystoourcontinuouseventpayloadbuffer*/
155. for(i=0;i<env->envp_idx;i++){
156. len=strlen(env->envp[i])+1;
157. scratch=skb_put(skb,len);
158. strcpy(scratch,env->envp[i]);
159. }
161. NETLINK_CB(skb).dst_group=1;
162. retval=netlink_broadcast_filtered(uevent_sock,skb,
163. 0,1,GFP_KERNEL,
164. kobj_bcast_filter,
165. kobj);
166. /*ENOBUFSshouldbehandledinuserspace*/
167. if(retval==-ENOBUFS)
168. retval=0;
169. }else
170. retval=-ENOMEM;
171. }
172. mutex_unlock(&uevent_sock_mutex);
173. #endif
175. /*calluevent_helper,usuallyonlyenabledduringearlyboot*/
176. if(uevent_helper[0]&&!kobj_usermode_filter(kobj)){
177. char*argv[3];
179. argv[0]=uevent_helper;
180. argv[1]=(char*)subsystem;
181. argv[2]=NULL;
182. retval=add_uevent_var(env,"HOME=/");
183. if(retval)
184. gotoexit;
185. retval=add_uevent_var(env,
186. "PATH=/sbin:/bin:/usr/sbin:/usr/bin");
187. if(retval)
188. gotoexit;
190. retval=call_usermodehelper(argv[0],argv,
191. env->envp,UMH_WAIT_EXEC);
192. }
194. exit:
195. kfree(devpath);
196. kfree(env);
197. returnretval;
198. }

[cpp] view plain copy

1. /**
2. *kobject_uevent-notifyuserspacebysendinganuevent
3. *
4. *@action:actionthatishappening
5. *@kobj:structkobjectthattheactionishappeningto
6. *
7. *Returns0ifkobject_uevent()iscompletedwithsuccessorthe
8. *correspondingerrorwhenitfails.
9. */
10. intkobject_uevent(structkobject*kobj,enumkobject_actionaction)
11. {
12. returnkobject_uevent_env(kobj,action,NULL);
13. }

3.3 netlink_broadcast_filtered

[cpp] view plain copy

1. intnetlink_broadcast_filtered(structsock*ssk,structsk_buff*skb,u32pid,
2. u32group,gfp_tallocation,
3. int(*filter)(structsock*dsk,structsk_buff*skb,void*data),
4. void*filter_data)
5. {
6. structnet*net=sock_net(ssk);
7. structnetlink_broadcast_datainfo;
8. structhlist_node*node;
9. structsock*sk;
11. skb=netlink_trim(skb,allocation);
13. info.exclude_sk=ssk;
14. info.net=net;
15. info.pid=pid;
16. info.group=group;
17. info.failure=0;
18. info.delivery_failure=0;
19. info.congested=0;
20. info.delivered=0;
21. info.allocation=allocation;
22. info.skb=skb;
23. info.skb2=NULL;
24. info.tx_filter=filter;
25. info.tx_data=filter_data;
27. /*Whilewesleepinclone,donotallowtochangesocketlist*/
29. netlink_lock_table();
30. //向nl_table[ssk->sk_protocol].mc_list中的每个sock发送此netlink消息
31. sk_for_each_bound(sk,node,&nl_table[ssk->sk_protocol].mc_list)
32. do_one_broadcast(sk,&info);
34. consume_skb(skb);
36. netlink_unlock_table();
38. if(info.delivery_failure){
39. kfree_skb(info.skb2);
40. return-ENOBUFS;
41. }else
42. consume_skb(info.skb2);
44. if(info.delivered){
45. if(info.congested&&(allocation&__GFP_WAIT))
46. yield();
47. return0;
48. }
49. return-ESRCH;
50. }

static struct netlink_table *nl_table；是全局变量，它维护了用户态创建的所有netlink sock，按协议分类，每种协议一个链表mc_list。它在函数netlink_proto_init中被初始化，向nl_table[sk->sk_protocol].mc_list中增加sock的调用流程如下(kernel/net/netlink/af_netlink.c)：

3.4 do_one_broadcast

[cpp] view plain copy

1. staticinlineintdo_one_broadcast(structsock*sk,
2. structnetlink_broadcast_data*p)
3. {
4. structnetlink_sock*nlk=nlk_sk(sk);
5. intval;
7. if(p->exclude_sk==sk)
8. gotoout;
10. if(nlk->pid==p->pid||p->group-1>=nlk->ngroups||
11. !test_bit(p->group-1,nlk->groups))
12. gotoout;
14. if(!net_eq(sock_net(sk),p->net))
15. gotoout;
17. if(p->failure){
18. netlink_overrun(sk);
19. gotoout;
20. }
22. sock_hold(sk);
23. if(p->skb2==NULL){
24. if(skb_shared(p->skb)){
25. p->skb2=skb_clone(p->skb,p->allocation);
26. }else{
27. p->skb2=skb_get(p->skb);
28. /*
29. *skbownershipmayhavebeensetwhen
30. *deliveredtoaprevioussocket.
31. */
32. skb_orphan(p->skb2);
33. }
34. }
35. if(p->skb2==NULL){
36. netlink_overrun(sk);
37. /*Clonefailed.NotifyALLlisteners.*/
38. p->failure=1;
39. if(nlk->flags&NETLINK_BROADCAST_SEND_ERROR)
40. p->delivery_failure=1;
41. }elseif(p->tx_filter&&p->tx_filter(sk,p->skb2,p->tx_data)){
42. kfree_skb(p->skb2);
43. p->skb2=NULL;
44. }elseif(sk_filter(sk,p->skb2)){
45. kfree_skb(p->skb2);
46. p->skb2=NULL;
47. }elseif((val=netlink_broadcast_deliver(sk,p->skb2))<0){
48. netlink_overrun(sk);
49. if(nlk->flags&NETLINK_BROADCAST_SEND_ERROR)
50. p->delivery_failure=1;
51. }else{
52. p->congested|=val;
53. p->delivered=1;
54. p->skb2=NULL;
55. }
56. sock_put(sk);
58. out:
59. return0;
60. }

3.5 netlink_broadcast_deliver

[cpp] view plain copy

1. staticinlineintnetlink_broadcast_deliver(structsock*sk,
2. structsk_buff*skb)
3. {
4. structnetlink_sock*nlk=nlk_sk(sk);
6. if(atomic_read(&sk->sk_rmem_alloc)<=sk->sk_rcvbuf&&
7. !test_bit(0,&nlk->state)){
8. skb_set_owner_r(skb,sk);
9. skb_queue_tail(&sk->sk_receive_queue,skb);
10. sk->sk_data_ready(sk,skb->len);
11. returnatomic_read(&sk->sk_rmem_alloc)>sk->sk_rcvbuf;
12. }
13. return-1;
14. }

更多相关文章

1. Android(安卓)Canvas drawArc方法介绍
2. android源码解析--switch
3. Android(安卓)监听EditText文本输入 EditText监听事和输入事件
4. Android(安卓)ConstraintLayout 约束布局
5. Android(安卓)AM命令行启动程序的方法
6. Android(安卓)JNI入门第六篇——C调用Java
7. 2011.09.15 ——— android 桌面添加快捷方式之判断是否存在无效
8. 浅谈Java中Collections.sort对List排序的两种方法
9. Python list sort方法的具体使用

随机推荐

1. Android调用系统自带的下载程序进行下载
2. Android 为【apk】文件签名，增加修改系统
3. Android 控件大全
4. Android应用架构之MVP模式
5. Android Service总结02 service介绍
6. EditText android:editable is deprecate
7. Android学习笔记进阶1之MediaPlayer
8. Android关于drawable和drawable-v24，mipma
9. Android平台OpenMax多媒体引擎介绍
10. Android模块化和组件化开发简单理解（一）