android vold架构详解（2）_Kernel层向上发送消息处理流程

最新推荐文章于 2022-07-13 09:00:32 发布
最新推荐文章于 2022-07-13 09:00:32 发布
阅读量358 收藏 4
点赞数
分类专栏： Android Framework 文章标签： 移动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wf125399199/article/details/84689064
版权
学习罗老师，先上一张Kernel层向上发送消息处理流程的序列图，下面一点一点分析。

[img]http://dl2.iteye.com/upload/attachment/0103/9382/1136d30a-f594-3581-b1a0-b0edae49ed0a.png[/img]

Step.17以前都在上一篇分析文章里，不在说明了。从Step.17开始分析。
Step.17 在main方法中，nm->start()方法里，开启Socket，监听Kernel层向上发送的消息 

int NetlinkManager::start() {
    struct sockaddr_nl nladdr;
    int sz = 64 * 1024;
    int on = 1;

    memset(&nladdr, 0, sizeof(nladdr));
    nladdr.nl_family = AF_NETLINK;
    nladdr.nl_pid = getpid();
    nladdr.nl_groups = 0xffffffff;

    // 创建协议族为PF_NETLINK，类型为SOCK_DGRAM的socket，返回该socket套接字的文件描述符
    if ((mSock = socket(PF_NETLINK,
                        SOCK_DGRAM,NETLINK_KOBJECT_UEVENT)) < 0) {
        SLOGE("Unable to create uevent socket: %s", strerror(errno));
        return -1;
    }

    if (setsockopt(mSock, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz)) < 0) {
        SLOGE("Unable to set uevent socket SO_RECBUFFORCE option: %s", strerror(errno));
        return -1;
    }

    if (setsockopt(mSock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on)) < 0) {
        SLOGE("Unable to set uevent socket SO_PASSCRED option: %s", strerror(errno));
        return -1;
    }

    if (bind(mSock, (struct sockaddr *) &nladdr, sizeof(nladdr)) < 0) {
        SLOGE("Unable to bind uevent socket: %s", strerror(errno));
        return -1;
    }

    mHandler = new NetlinkHandler(mSock);
    if (mHandler->start()) {
        SLOGE("Unable to start NetlinkHandler: %s", strerror(errno));
        return -1;
    }
    return 0;
}


Step.18～26 NetlinkHandler的继承关系,NetlinkHandler→NetlinkListener→SocketListener。依次创建NetlinkHandler、NetlinkListener、SocketListener的实例
NetlinkHandler的构造函数 

NetlinkHandler::NetlinkHandler(int listenerSocket) :
                NetlinkListener(listenerSocket) {
}


NetlinkListener的构造函数 

NetlinkListener::NetlinkListener(int socket) :
                            SocketListener(socket, false) {
    mFormat = NETLINK_FORMAT_ASCII;
}


SocketListener的构造函数 

SocketListener::SocketListener(int socketFd, bool listen) {
    mListen = listen;
    mSocketName = NULL;
    mSock = socketFd;
    pthread_mutex_init(&mClientsLock, NULL);
    mClients = new SocketClientCollection();
}

最后实例化了一个SocketClientCollection。

Step.27 接着看看start()方法都干了什么。
NetlinkHandler.start 

int NetlinkHandler::start() {
	// 调用父类startListener()方法
    return this->startListener();
}


Step.28 SocketListener的startListener()方法 

int SocketListener::startListener() {

    if (!mSocketName && mSock == -1) {
        SLOGE("Failed to start unbound listener");
        errno = EINVAL;
        return -1;
    } else if (mSocketName) {
        if ((mSock = android_get_control_socket(mSocketName)) < 0) {
            SLOGE("Obtaining file descriptor socket '%s' failed: %s",
                 mSocketName, strerror(errno));
            return -1;
        }
    }
    // 将mSock套接字（NetlinkManager::start()中创建的）变为被连接套接口，
    // 使得一个进程可以接受其它进程的请求，从而成为一个服务器进程
    if (mListen && listen(mSock, 4) < 0) {
        SLOGE("Unable to listen on socket (%s)", strerror(errno));
        return -1;
    } else if (!mListen)
    	// 创建SocketClient实例，并添加到前面构造函数中实例化的SocketClientCollection中
        mClients->push_back(new SocketClient(mSock, false));

    // 建立管道，得到管道的读取端和写入端
    if (pipe(mCtrlPipe)) {
        SLOGE("pipe failed (%s)", strerror(errno));
        return -1;
    }

    // 启动线程，指定线程的开始执行的函数threadStart，并进入该方法，继续分析
    if (pthread_create(&mThread, NULL, SocketListener::threadStart, this)) {
        SLOGE("pthread_create (%s)", strerror(errno));
        return -1;
    }

    return 0;
}


Step.32 SocketListener的threadStart方法 

void *SocketListener::threadStart(void *obj) {
    SocketListener *me = reinterpret_cast<SocketListener *>(obj);
    // 继续调用自己的runListener（）方法，
    // 马上进入最最重要的部分
    me->runListener();
    pthread_exit(NULL);
    return NULL;
}



Strp.33 runListener（）方法 

void SocketListener::runListener() {

	// 创建一个SocketClientCollection，用来保存待处理的SocketClient，其实就是接受到Kernel层消息的SocketClient。
    SocketClientCollection *pendingList = new SocketClientCollection();

    // 开始while循环，时刻监听kernel的消息
    while(1) {
        SocketClientCollection::iterator iterator;
        fd_set read_fds;
        int rc = 0;
        int max = -1;

        // 一连串对套接字的更新，重置，检查等处理
        FD_ZERO(&read_fds);

        if (mListen) {
            max = mSock;
            FD_SET(mSock, &read_fds);
        }

        FD_SET(mCtrlPipe[0], &read_fds);
        if (mCtrlPipe[0] > max)
            max = mCtrlPipe[0];

        pthread_mutex_lock(&mClientsLock);
        for (it = mClients->begin(); it != mClients->end(); ++it) {
            int fd = (*it)->getSocket();
            FD_SET(fd, &read_fds);
            if (fd > max)
                max = fd;
        }
        pthread_mutex_unlock(&mClientsLock);

        if ((rc = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {
            if (errno == EINTR)
                continue;
            SLOGE("select failed (%s)", strerror(errno));
            sleep(1);
            continue;
        } else if (!rc)
            continue;

        if (FD_ISSET(mCtrlPipe[0], &read_fds))
            break;
        if (mListen && FD_ISSET(mSock, &read_fds)) {
            struct sockaddr addr;
            socklen_t alen;
            int c;

            do {
                alen = sizeof(addr);
                c = accept(mSock, &addr, &alen);
            } while (c < 0 && errno == EINTR);
            if (c < 0) {
                SLOGE("accept failed (%s)", strerror(errno));
                sleep(1);
                continue;
            }
            pthread_mutex_lock(&mClientsLock);
            mClients->push_back(new SocketClient(c, true));
            pthread_mutex_unlock(&mClientsLock);
        }

        /* Add all active clients to the pending list first */
        pendingList->clear();
        pthread_mutex_lock(&mClientsLock);
        for (it = mClients->begin(); it != mClients->end(); ++it) {
            int fd = (*it)->getSocket();
            if (FD_ISSET(fd, &read_fds)) {
            	// 如果有消息，将当前SocketClient添加到pendingList中
                pendingList->push_back(*it);
            }
        }
        pthread_mutex_unlock(&mClientsLock);

        /* Process the pending list, since it is owned by the thread,
         * there is no need to lock it */
        // 遍历pendingList，判断是否不为空。
        // 不为空表示，有kernel层发送过来的消息需要处理
        // 调用onDataAvailable处理消息
        while (!pendingList->empty()) {
            /* Pop the first item from the list */
            it = pendingList->begin();
            SocketClient* c = *it;
            pendingList->erase(it);
            /* Process it, if false is returned and our sockets are
             * connection-based, remove and destroy it */
            if (!onDataAvailable(c) && mListen) {
                /* Remove the client from our array */
                pthread_mutex_lock(&mClientsLock);
                for (it = mClients->begin(); it != mClients->end(); ++it) {
                    if (*it == c) {
                        mClients->erase(it);
                        break;
                    }
                }
                pthread_mutex_unlock(&mClientsLock);
                /* Remove our reference to the client */
                c->decRef();
            }
        }
    }
    delete pendingList;
}


Step.34 取到Kernel的消息后，接下来处理该消息
NetlinkListener的onDataAvailable方法 

bool NetlinkListener::onDataAvailable(SocketClient *cli)
{
    int socket = cli->getSocket();
    ssize_t count;

    count = TEMP_FAILURE_RETRY(uevent_kernel_multicast_recv(socket, mBuffer, sizeof(mBuffer)));
    if (count < 0) {
        SLOGE("recvmsg failed (%s)", strerror(errno));
        return false;
    }

    NetlinkEvent *evt = new NetlinkEvent();
    if (!evt->decode(mBuffer, count, mFormat)) {
        SLOGE("Error decoding NetlinkEvent");
    } else {
    	// 开始处理从kernel层接受到的消息
        onEvent(evt);
    }

    delete evt;
    return true;
}


Step.35 NetlinkHandler的onEvent方法，将消息解析后，传给ValumeManager来处理 

void NetlinkHandler::onEvent(NetlinkEvent *evt) {
    VolumeManager *vm = VolumeManager::Instance();
    const char *subsys = evt->getSubsystem();

    if (!subsys) {
        SLOGW("No subsystem found in netlink event");
        return;
    }

    if (!strcmp(subsys, "block")) {
        vm->handleBlockEvent(evt);
    }
}


Step.36～41
消息经过各种Check后，将消息发到vold Socket中. 

----------------------------
void VolumeManager::handleBlockEvent(NetlinkEvent *evt) {
    const char *devpath = evt->findParam("DEVPATH");

    /* Lookup a volume to handle this device */
    VolumeCollection::iterator it;
    bool hit = false;
    for (it = mVolumes->begin(); it != mVolumes->end(); ++it) {
        if (!(*it)->handleBlockEvent(evt)) {
#ifdef NETLINK_DEBUG
            SLOGD("Device '%s' event handled by volume %s\n", devpath, (*it)->getLabel());
#endif
            hit = true;
            break;
        }
    }

    if (!hit) {
#ifdef NETLINK_DEBUG
        SLOGW("No volumes handled block event for '%s'", devpath);
#endif
    }
}
----------------------------

----------------------------
int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {
    const char *dp = evt->findParam("DEVPATH");

    PathCollection::iterator  it;
    for (it = mPaths->begin(); it != mPaths->end(); ++it) {
        if (!strncmp(dp, *it, strlen(*it))) {
            /* We can handle this disk */
            int action = evt->getAction();
            const char *devtype = evt->findParam("DEVTYPE");

            if (action == NetlinkEvent::NlActionAdd) {
                int major = atoi(evt->findParam("MAJOR"));
                int minor = atoi(evt->findParam("MINOR"));
                char nodepath[255];

                snprintf(nodepath,
                         sizeof(nodepath), "/dev/block/vold/%d:%d",
                         major, minor);
                if (createDeviceNode(nodepath, major, minor)) {
                    SLOGE("Error making device node '%s' (%s)", nodepath,
                                                               strerror(errno));
                }
                if (!strcmp(devtype, "disk")) {
                    handleDiskAdded(dp, evt);
                } else {
                    handlePartitionAdded(dp, evt);
                }
            } else if (action == NetlinkEvent::NlActionRemove) {
                if (!strcmp(devtype, "disk")) {
                    handleDiskRemoved(dp, evt);
                } else {
                    handlePartitionRemoved(dp, evt);
                }
            } else if (action == NetlinkEvent::NlActionChange) {
                if (!strcmp(devtype, "disk")) {
                    handleDiskChanged(dp, evt);
                } else {
                    handlePartitionChanged(dp, evt);
                }
            } else {
                    SLOGW("Ignoring non add/remove/change event");
            }

            return 0;
        }
    }
    errno = ENODEV;
    return -1;
}
----------------------------

----------------------------
void DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt) {
    mDiskMajor = atoi(evt->findParam("MAJOR"));
    mDiskMinor = atoi(evt->findParam("MINOR"));

    const char *tmp = evt->findParam("NPARTS");
    if (tmp) {
        mDiskNumParts = atoi(tmp);
    } else {
        SLOGW("Kernel block uevent missing 'NPARTS'");
        mDiskNumParts = 1;
    }

// FUJITSU TEN:2014-01-14 #55703 start
    snprintf(mDevPath, 1024, "/sys/%s", evt->findParam("DEVPATH"));
// FUJITSU TEN:2014-01-14 #55703 end

    char msg[255];

    int partmask = 0;
    int i;
    for (i = 1; i <= mDiskNumParts; i++) {
        partmask |= (1 << i);
    }
    mPendingPartMap = partmask;

    if (mDiskNumParts == 0) {
#ifdef PARTITION_DEBUG
        SLOGD("Dv::diskIns - No partitions - good to go son!");
#endif
        setState(Volume::State_Idle);
    } else {
#ifdef PARTITION_DEBUG
        SLOGD("Dv::diskIns - waiting for %d partitions (mask 0x%x)",
             mDiskNumParts, mPendingPartMap);
#endif
        setState(Volume::State_Pending);
    }

    snprintf(msg, sizeof(msg), "Volume %s %s disk inserted (%d:%d)",
             getLabel(), getMountpoint(), mDiskMajor, mDiskMinor);
    mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,
                                             msg, false);
}
----------------------------

----------------------------
void SocketListener::sendBroadcast(int code, const char *msg, bool addErrno) {
    pthread_mutex_lock(&mClientsLock);
    SocketClientCollection::iterator i;

    for (i = mClients->begin(); i != mClients->end(); ++i) {
        if ((*i)->sendMsg(code, msg, addErrno)) {
            SLOGW("Error sending broadcast (%s)", strerror(errno));
        }
    }
    pthread_mutex_unlock(&mClientsLock);
}
----------------------------

----------------------------
int SocketClient::sendMsg(int code, const char *msg, bool addErrno) {
    char *buf;
    const char* arg;
    const char* fmt;
    char tmp[1];
    int  len;

    if (addErrno) {
        fmt = "%.3d %s (%s)";
        arg = strerror(errno);
    } else {
        fmt = "%.3d %s";
        arg = NULL;
    }
    /* Measure length of required buffer */
    len = snprintf(tmp, sizeof tmp, fmt, code, msg, arg);
    /* Allocate in the stack, then write to it */
    buf = (char*)alloca(len+1);
    snprintf(buf, len+1, fmt, code, msg, arg);
    /* Send the zero-terminated message */
    return sendMsg(buf);
}

int SocketClient::sendMsg(const char *msg) {
    if (mSocket < 0) {
        errno = EHOSTUNREACH;
        return -1;
    }

    // Send the message including null character
    if (sendData(msg, strlen(msg) + 1) != 0) {
        SLOGW("Unable to send msg '%s'", msg);
        return -1;
    }
    return 0;
}

int SocketClient::sendData(const void* data, int len) {
    int rc = 0;
    const char *p = (const char*) data;
    int brtw = len;

    if (len == 0) {
        return 0;
    }

    pthread_mutex_lock(&mWriteMutex);
    while (brtw > 0) {
        rc = write(mSocket, p, brtw);
        if (rc > 0) {
            p += rc;
            brtw -= rc;
            continue;
        }

        if (rc < 0 && errno == EINTR)
            continue;

        pthread_mutex_unlock(&mWriteMutex);
        if (rc == 0) {
            SLOGW("0 length write :(");
            errno = EIO;
        } else {
            SLOGW("write error (%s)", strerror(errno));
        }
        return -1;
    }
    pthread_mutex_unlock(&mWriteMutex);
    return 0;
}
----------------------------


Library层接受到Kernel层消息，到发送到Application Framework层的处理就到这里了。
后面是Application Framework层如何获取到这个消息

MountService实例化时，创建了一个用来监听vold Socket的Connector 

public MountService(Context context) {
    ......
    /*
     * Create the connection to vold with a maximum queue of twice the
     * amount of containers we'd ever expect to have. This keeps an
     * "asec list" from blocking a thread repeatedly.
     */
    // 创建用来监听vold Socket的Connector
    mConnector = new NativeDaemonConnector(this, "vold", MAX_CONTAINERS * 2, VOLD_TAG);
    mReady = false;
    // 启动mConnector，NativeDaemonConnector的run方法中调用了listenToSocket方法，
    // 开始监听这个vold Socket
    Thread thread = new Thread(mConnector, VOLD_TAG);
    thread.start();
	......
}


NativeDaemonConnector的run方法中调用了listenToSocket方法，开始监听vold Socket 

private void listenToSocket() throws IOException {
    LocalSocket socket = null;

    try {
        ......

        while (true) {
            int count = inputStream.read(buffer, start, BUFFER_SIZE - start);
            if (count < 0) break;

            // Add our starting point to the count and reset the start.
            count += start;
            start = 0;

            for (int i = 0; i < count; i++) {
                if (buffer[i] == 0) {
                    String event = new String(buffer, start, i - start);
                    if (LOCAL_LOGD) Slog.d(TAG, String.format("RCV <- {%s}", event));

                    String[] tokens = event.split(" ", 2);
                    try {
                        int code = Integer.parseInt(tokens[0]);

                        if (code >= ResponseCode.UnsolicitedInformational) {
                        	// 发送消息到Handler中
                            mCallbackHandler.sendMessage(
                                    mCallbackHandler.obtainMessage(code, event));
                        } else {
                            try {
                                mResponseQueue.put(event);
                            } catch (InterruptedException ex) {
                                Slog.e(TAG, "Failed to put response onto queue", ex);
                            }
                        }
                    } catch (NumberFormatException nfe) {
                        Slog.w(TAG, String.format("Bad msg (%s)", event));
                    }
                    start = i + 1;
                }
            }
            ......
        }
    } 
    ......
}



public boolean handleMessage(Message msg) {
    String event = (String) msg.obj;
    try {
        if (!mCallbacks.onEvent(msg.what, event, event.split(" "))) {
            Slog.w(TAG, String.format(
                    "Unhandled event '%s'", event));
        }
    } catch (Exception e) {
        Slog.e(TAG, String.format(
                "Error handling '%s'", event), e);
    }
    return true;
}


mCallbacks就是NativeDaemonConnector实例化时传递进来的，
它其实就是MountService。所以回到MountService的onEvent方法 

/**
 * Callback from NativeDaemonConnector
 */
public boolean onEvent(int code, String raw, String[] cooked) {
    ......
    if (code == VoldResponseCode.VolumeStateChange) {
       ......
    } else if ((code == VoldResponseCode.VolumeDiskInserted) ||
               (code == VoldResponseCode.VolumeDiskRemoved) ||
               (code == VoldResponseCode.VolumeBadRemoval)) {
        ......
    } else {
        return false;
    }

    return true;
}


OK！！！ 这里就开始分发处理各种消息了。

明天开始FrameWork层向下发送消息处理流程
wf125399199
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android uevent机制,安卓linux uevent内核上报机制实例
weixin_29189363的博客
05-31 592
uevent可以实现内核通知上层的一种机制，最常见的电池状态的变化就是kernel uevent通知的，每次百分比或者其他的变化通过power_supply_changed通知上层update；每个device下面都有kobj,找到device就可以通过kobject_uevent_env 通知android了；以拔出T卡为例，内核通知上层。这里的T卡是一种sdio设备，普通TF卡是块设备，安卓通...
Android7.0 Vold 进程工作机制分析之由Kernel发起挂载请求
Dennis-Android的博客
11-25 2089
Android7.0 Vold 进程工作机制分析之由Kernel发起挂载请求 一、MountService简介 MountService是一个系统服务,负责与Vold进程通信的,运行在SystemServer进程,当收到Vold的挂载消息后,会通过广播的方式通知上层应用. 它是在SystemServer的startOtherServices方法里启动的 SystemServer路径——
按键如何传递到应用层
weixin_44298997的博客
01-14 195
Key event 分发流程(如何传递到应用层) https://blog.csdn.net/wangkaiblog/article/details/14523045
Android基于MQTT协议利用ActiveMQ发送消息给Android端接收
04-23
Android基于MQTT协议利用ActiveMQ发送消息给Android端接收,属于长连接那种，类似Socket通信
android usb挂载分析---vold处理内核消息
new_abc的专栏
03-29 5789
MountService启动之后 ，一切准备工作都 做好了，就等待碰上u盘插上了，  这里要讲的是内核发信息给vold，我们在 vold启动这篇曾讲到过注册了一个到内核的UEVENT事件，当有u盘插入的时候，我们就能从这个套接字上收到内核所发出的消息了，这样就开始了vold的消息处理。 先看下消息处理的流程： 在SocketListener::runListener()函数 中，
android-vold.rar_android_android vold_vold
09-14
在`android vold.pdf`这个文档中，可能会详细阐述`vold`的工作流程、关键函数解析、如何处理不同的设备类型以及在不同Android版本中的变化。这份资料可能是对`vold`源码的分析，帮助开发者理解如何自定义`vold`行为...
android vold模块详解
04-28
Uevent 简介 NetLink 简介 MountService 功能介绍： MountService 同 StroageManager 的交互 MountService 同 Vold 的交互
android-vold.rar_android
最新发布
09-24
《Android系统Vold深度解析》 在Android操作系统中，Vold（Volume Daemon）是一个至关重要的组件，它负责管理设备的存储系统，包括内部存储、外部SD卡以及各种类型的USB存储设备。Vold作为系统服务运行在特权用户...
Android 9.0 Vold 挂载流程分析
01-21
通过kernel–>vold–>StorageManagerService这样的架构去逐级上报热插拔事件。 一、Vold 入口 --> /system/vold/main.c int main(int argc, char** argv) { atrace_set_tracing_enabled(false); setenv(ANDROID...
vold_android.pdf.tar.gz_android
09-20
《Android系统中的Vold服务详解》 在Android操作系统中，Vold（Volume Daemon）是一个至关重要的组件，它主要负责管理设备的存储系统，包括内部存储和外部存储卡。Vold这个名字来源于“Volume Daemon”，意为“卷...
Kernel源码笔记之文件系统：2. fuse——发送消息
苟浩的博客
07-13 419
主要介绍了fuse的发送消息流程
Android vold启下篇(NetlinkHandler)
dengziliang001的专栏
06-28 1987
本文将以分析源代码的方式来分析vold的实现流程。 一、vold下主流程代码分析 int main() { VolumeManager *vm; // 管理volume的对象 CommandListener *cl; // Framework层通讯的对象 NetlinkManager *nm; // 接收linux内核关于磁盘热插拔
Android—— 4.2 Vold挂载管理_NetlinkManager (四)
jscese
08-16 4472
在前文Android—— 4.2 Vold挂载管理_主体构建main (一)中有结构图表示，Vold是kernel与用户层的一个交互管理模块， Android—— 4.2 Vold挂载管理_VolumeManager (三) 简单介绍了核心VolumeManager的构建，这篇分析从kernel进程沟通到VolumeManager进程的关键：NetlinkManager
在linux kernel中netlink的使用示例
baron-周贺贺-代码改变世界ctw
07-13 3089
文章目录1、在socket.h中，INET协议族的定义2、以PF_ALG为例，注册一个netlink驱动，在af_alg.c中：3、以PF_ALG为例，写一个userspace调用程序 1、在socket.h中，INET协议族的定义 /* Supported address families. */ #define AF_UNSPEC 0 #define AF_UNIX 1 /* Unix domain sockets */ #define AF_LOCAL 1 /* POSIX name for A
Android热插拔事件处理流程--Vold
MyArrow的专栏
12-01 2万+
一、Android热插拔事件处理流程图 Android热插拔事件处理流程如下图所示：   二、组成 1. NetlinkManager:        全称是NetlinkManager.cpp位于Android 4.x 源码位置/system/vold/NetlinkManager.cpp。该类的主要通过引用NetlinkHandler类中的onEvent()方法来接收来自内核的事
Android Uevent 分析，从kernel到framework
热门推荐
小贼哥的技术花园
03-07 2万+
Uevent是内核通知android有状态变化的一种方法，比如USB线插入、拔出，电池电量变化等等。其本质是内核发送（可以通过socket）一个字符串，应用层（android）接收并解释该字符串，获取相应信息。 一、Kernel侧： UEVENT的发起在Kernel端，主要是通过函数 int kobject_uevent_env(struct kobject *kobj, enum kobj
android java层直接和kernel交互的最快的方法
zengkexu的专栏
04-15 2224
android java 和kernel 的交互方式  按照常规的要通过ＪＮＩ实现，　然后jni 调用HAL的IOCTL ，或者类似Vold 中建立netlink 的方式和kernel交互。 实际上这不是一种高效的方式。这样在时间紧迫的情况下，如果您的程序中 java只是要主动和kernel交互的，获取一些信息，或者写入一些，那么可以完全采用如下的方法： 首先驱动随便实现一个的节点：
内核层与应用层通信详解
黄胶鞋和七分裤
07-30 1万+
做驱动开发的肯定会遇到应用层与内核层的通信的问题，首先说内核层与应用层的通信可以大概分为两个方面，第一是应用层向内核层主动传递消息，第二是内核层主动与应用层通信。下面我们将分开来谈两个方面。 我们先来看应用层向内核层传递的方法： BOOL DeviceIoControl ( HANDLE hDevice, // 设备句柄 DWORD dwIoControlCode, // I...
Android Vold模块详解：udev与Vold的设备管理比较
理解Vold的关键在于理解它如何在Android的文件系统架构中工作，以及如何通过与MountService和其他系统服务的交互来提供无缝的设备管理体验。 总结起来，本文主要讲解了Android中的Vold模块如何通过Uevent机制与内核...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值