Android源码阅读---Service Manager进程

最新推荐文章于 2024-05-02 19:57:38 发布
最新推荐文章于 2024-05-02 19:57:38 发布
阅读量701 收藏
点赞数
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cw102055234/article/details/104503205
版权

Android源码阅读—Service Manager进程

文章目录


ServiceManager 是 android中IPC机制的关键组件，它是一个bin可执行程序，由init进程开启并作为一个系统服务一直运行，主要为各个bind客户端提供服务查询、为binder服务端提供注册等功能，如果没有该该服务， android的binder机制将无法正常工作。

1. 编译命令

include $(CLEAR_VARS)
LOCAL_SHARED_LIBRARIES := liblog libcutils libselinux
LOCAL_SRC_FILES := service_manager.c binder.c
LOCAL_CFLAGS += $(svc_c_flags)
LOCAL_MODULE := servicemanager
LOCAL_INIT_RC := servicemanager.rc
include $(BUILD_EXECUTABLE)

从这个编译命令来看，这个bin程序涉及到的源文件并不多，主要有service_manager.c和binder.c，然后它的配置文件单独拿出来，存放在编译文件同级目录下

service servicemanager /system/bin/servicemanager
    class core
    user system
    group system readproc
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart audioserver
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart inputflinger
    onrestart restart drm
    onrestart restart cameraserver
    writepid /dev/cpuset/system-background/tasks
    onrestart restart filelock

从配置文件可以看出，该servicemanager 属于core组，一旦该服务重启，其他系统服务如healthd、zygote、audioserver等也会restart
然后在init.rc中,在boot触发阶段有一个class_start core的 command, 它对应的函数static int do_class_start(const std::vector<std::string>& args)将会start服务块链表中class为core的service，因为servicemanager 也属于core组，所以在boot触发阶段，init进程也会开启一个子进程，然后让子进程开始运行servicemanager。

on boot
    # basic network init
    ifup lo
    hostname localhost
    domainname localdomain

    # Memory management. Basic kernel parameters, and allow the high
    # level system server to be able to adjust the kernel OOM driver
    # parameters to match how it is managing things.
    write /proc/sys/vm/overcommit_memory 1
/*省略*/
    # Define default initial receive window size in segments.
    setprop net.tcp.default_init_rwnd 60
    class_start core

2. main函数流程

分析一个bin进程，首先看看它的 main函数，在该main函数中主要做了：

  1. 使用函数binder_open打开binder设备
  2. 将自己设置为binder
  3. binder_loop循环
int main()
{
    struct binder_state *bs;
    bs = binder_open(128*1024);/*128k*/
    if (!bs) {
        ALOGE("failed to open binder driver\n");
        return -1;
    }
    if (binder_become_context_manager(bs)) {
        ALOGE("cannot become context manager (%s)\n", strerror(errno));
        return -1;
    }
    selinux_enabled = is_selinux_enabled();
    sehandle = selinux_android_service_context_handle();
    selinux_status_open(true);
    if (selinux_enabled > 0) {
        if (sehandle == NULL) {
            ALOGE("SELinux: Failed to acquire sehandle. Aborting.\n");
            abort();
        }
        if (getcon(&service_manager_context) != 0) {
            ALOGE("SELinux: Failed to acquire service_manager context. Aborting.\n");
            abort();
        }
    }
    union selinux_callback cb;
    cb.func_audit = audit_callback;
    selinux_set_callback(SELINUX_CB_AUDIT, cb);
    cb.func_log = selinux_log_callback;
    selinux_set_callback(SELINUX_CB_LOG, cb);
    binder_loop(bs, svcmgr_handler);
    return 0;
}

3. 打开binder设备

binder_open主要是做一个内存映射的工作，核心在函数mmap中,

struct binder_state
{
    int fd;
    void *mapped;
    size_t mapsize;
};
struct binder_state *binder_open(size_t mapsize)
{
    struct binder_state *bs;
    struct binder_version vers;
    bs = malloc(sizeof(*bs));/*为结构体binder_state 分配空间,该结构体中记录了关于binder的信息*/
    if (!bs) {
        errno = ENOMEM;
        return NULL;
    }
    bs->fd = open("/dev/binder", O_RDWR | O_CLOEXEC);/*打开驱动节点*/
    if (bs->fd < 0) {
        fprintf(stderr,"binder: cannot open device (%s)\n",
                strerror(errno));
        goto fail_open;
    }
    if ((ioctl(bs->fd, BINDER_VERSION, &vers) == -1) ||  (vers.protocol_version != BINDER_CURRENT_PROTOCOL_VERSION)) {
        fprintf(stderr,
                "binder: kernel driver version (%d) differs from user space version (%d)\n",
                vers.protocol_version, BINDER_CURRENT_PROTOCOL_VERSION);
        goto fail_open;
    }
    bs->mapsize = mapsize;/* 设定的为128k*/
    bs->mapped = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, bs->fd, 0);/*到此，结构体binder_state 填充完成*/
    if (bs->mapped == MAP_FAILED) {
        fprintf(stderr,"binder: cannot map device (%s)\n",
                strerror(errno));
        goto fail_map;
    }
    return bs;
fail_map:
    close(bs->fd);
fail_open:
    free(bs);
    return NULL;
}

4. 将自己设置为binder

int binder_become_context_manager(struct binder_state *bs)
{
    return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);/*使用命令BINDER_SET_CONTEXT_MGR将自己设置为 binder 管家*/
}

5. loop循环

循环的做下面2步操作

  • 对binder驱动执行读信息
  • 将拿到的信息进行处理
void binder_loop(struct binder_state *bs, binder_handler func)
{
    int res;
    struct binder_write_read bwr; /*binder读写需要的格式*/
/*
struct binder_write_read {
  binder_size_t write_size;
 binder_size_t write_consumed;
// WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS 
  binder_uintptr_t write_buffer;
  binder_size_t read_size;
 binder_size_t read_consumed;
 binder_uintptr_t read_buffer;
// WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS 
};
*/
    uint32_t readbuf[32]; /* 数据读取的缓冲空间*/

    bwr.write_size = 0;
    bwr.write_consumed = 0;
    bwr.write_buffer = 0;

    readbuf[0] = BC_ENTER_LOOPER;
    binder_write(bs, readbuf, sizeof(uint32_t));/*会把readbuf数据写到binder驱动中中*/
/*开始循环*/
    for (;;) {
        bwr.read_size = sizeof(readbuf);
        bwr.read_consumed = 0;
        bwr.read_buffer = (uintptr_t) readbuf;/*会把数据读到readbuf中*/
        res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);/*执行读信息操作*/
        if (res < 0) {
            ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
            break;
        }
/*将读取到的信息开始解析*/
        res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
        if (res == 0) {
            ALOGE("binder_loop: unexpected reply?!\n");
            break;
        }
        if (res < 0) {
            ALOGE("binder_loop: io error %d %s\n", res, strerror(errno));
            break;
        }
    }/*for 循环结束*/
}

5.1 从binder中读数据

从binder中支持 ioctl(bs->fd, BINDER_WRITE_READ, &bwr)读取操作并把数据写入到readbuf中

5.2 解析数据

将第一步读取到的数据进行解析,具体实现在函数binder_parse中执行
首先，将数据中的第一个uint32_t 作为一个cmd命令
然后，根据cmd命令来判断执行各种的逻辑

int binder_parse(struct binder_state *bs, struct binder_io *bio,
                 uintptr_t ptr, size_t size, binder_handler func)
{
    int r = 1;
    uintptr_t end = ptr + (uintptr_t) size;/*数据的结束地址*/
    while (ptr < end) {
        uint32_t cmd = *(uint32_t *) ptr;/*将第一个uint32_t   取出来 存到临时变量cmd 中,后续根据这个cmd 指令觉定走哪个switch语句*/
        ptr += sizeof(uint32_t);/*然后指针向下移动一个uint32_t*/
        switch(cmd) {
        case BR_NOOP:
            break;
        case BR_TRANSACTION_COMPLETE:
            break;
        case BR_INCREFS:
        case BR_ACQUIRE:
        case BR_RELEASE:
        case BR_DECREFS:
            ptr += sizeof(struct binder_ptr_cookie);
            break;
        case BR_TRANSACTION: {
            struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
            if ((end - ptr) < sizeof(*txn)) {
                ALOGE("parse: txn too small!\n");
                return -1;
            }
            binder_dump_txn(txn);
            if (func) {
                unsigned rdata[256/4];
                struct binder_io msg;
                struct binder_io reply;
                int res;

                bio_init(&reply, rdata, sizeof(rdata), 4);
                bio_init_from_txn(&msg, txn);
                res = func(bs, txn, &msg, &reply);
                if (txn->flags & TF_ONE_WAY) {
                    binder_free_buffer(bs, txn->data.ptr.buffer);
                } else {
                    binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
                }
            }
            ptr += sizeof(*txn);
            break;
        }
        case BR_REPLY: {
            struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
            if ((end - ptr) < sizeof(*txn)) {
                ALOGE("parse: reply too small!\n");
                return -1;
            }
            binder_dump_txn(txn);
            if (bio) {
                bio_init_from_txn(bio, txn);
                bio = 0;
            } else {
                /* todo FREE BUFFER */
            }
            ptr += sizeof(*txn);
            r = 0;
            break;
        }
        case BR_DEAD_BINDER: {
            struct binder_death *death = (struct binder_death *)(uintptr_t) *(binder_uintptr_t *)ptr;
            ptr += sizeof(binder_uintptr_t);
            death->func(bs, death->ptr);
            break;
        }
        case BR_FAILED_REPLY:
            r = -1;
            break;
        case BR_DEAD_REPLY:
            r = -1;
            break;
        default:
            ALOGE("parse: OOPS %d\n", cmd);
            return -1;
        }
    }
    return r;
}

然后主要看看BR_TRANSACTION、BR_REPLY、BR_DEAD_BINDER这3个命令做了什么操作

5.2.1 BR_TRANSACTION

        case BR_TRANSACTION: {
/*如果smd是BR_TRANSACTION 命令，后面直接当成是binder_transaction_data 类型数据*/
/*
struct binder_transaction_data {
// WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS 
  union { __u32 handle; binder_uintptr_t ptr;} target;
//WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS
  binder_uintptr_t cookie;
  __u32 code;
  __u32 flags;
  pid_t sender_pid;
  uid_t sender_euid;
  binder_size_t data_size;
  binder_size_t offsets_size;
  union { struct {binder_uintptr_t buffer; binder_uintptr_t offsets; } ptr;
    __u8 buf[8];
  } data;
};
*/
            struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
            if ((end - ptr) < sizeof(*txn)) {/*数据大小校验*/
                ALOGE("parse: txn too small!\n");
                return -1;
            }
            binder_dump_txn(txn);
            if (func) {
                unsigned rdata[256/4];
                struct binder_io msg;
                struct binder_io reply;
                int res;
                bio_init(&reply, rdata, sizeof(rdata), 4); /*初始化bio对象*/
                bio_init_from_txn(&msg, txn);
                res = func(bs, txn, &msg, &reply);/*主要使用函数svcmgr_handler来处理txn中的数据,然后结果存在reply中*/
                if (txn->flags & TF_ONE_WAY) {
                    binder_free_buffer(bs, txn->data.ptr.buffer);
                } else {
                    binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
                }
            }
            ptr += sizeof(*txn);/* 再偏移binder_transaction_data 个位置，因为这部分数据已经处理了*/
            break;
        }

svcmgr_handler函数逻辑

int svcmgr_handler(struct binder_state *bs, struct binder_transaction_data *txn,struct binder_io *msg, struct binder_io *reply)
{
    struct svcinfo *si;
    uint16_t *s;
    size_t len;
    uint32_t handle;
    uint32_t strict_policy;
    int allow_isolated;
    if (txn->target.ptr != BINDER_SERVICE_MANAGER)/*如果从binder驱动读到的信息不是发给sm的就退出*/
        return -1;

    if (txn->code == PING_TRANSACTION)
        return 0;

    // Equivalent to Parcel::enforceInterface(), reading the RPC header with the strict mode policy mask and the interface name.
    // Note that we ignore the strict_policy and don't propagate it further (since we do no outbound RPCs anyway).
    strict_policy = bio_get_uint32(msg);
    s = bio_get_string16(msg, &len);
    if (s == NULL) {
        return -1;
    }

    if ((len != (sizeof(svcmgr_id) / 2)) ||
        memcmp(svcmgr_id, s, sizeof(svcmgr_id))) {
        fprintf(stderr,"invalid id %s\n", str8(s, len));
        return -1;
    }
    if (sehandle && selinux_status_updated() > 0) {
        struct selabel_handle *tmp_sehandle = selinux_android_service_context_handle();
        if (tmp_sehandle) {
            selabel_close(sehandle);
            sehandle = tmp_sehandle;
        }
    }
/*然后又根据binder_transaction_data 面的code 执行不同的case
1. SVC_MGR_CHECK_SERVICE和SVC_MGR_GET_SERVICE都是通过字符串s中的名字来得到对应server的handle
2. SVC_MGR_ADD_SERVICE用来注册一个server
3. SVC_MGR_LIST_SERVICES用来获取整个server列表
*/
    switch(txn->code) {
    case SVC_MGR_GET_SERVICE:
    case SVC_MGR_CHECK_SERVICE:
        s = bio_get_string16(msg, &len);
        if (s == NULL) {
            return -1;
        }
        handle = do_find_service(s, len, txn->sender_euid, txn->sender_pid);/*具体的查找函数，根据s来查找对应handle */
        if (!handle)
            break;
        bio_put_ref(reply, handle);/*将handle通过reply返回给上层调用函数*/
        return 0;

    case SVC_MGR_ADD_SERVICE:
        s = bio_get_string16(msg, &len);
        if (s == NULL) {
            return -1;
        }
        handle = bio_get_ref(msg);
        allow_isolated = bio_get_uint32(msg) ? 1 : 0;
        if (do_add_service(bs, s, len, handle, txn->sender_euid,
            allow_isolated, txn->sender_pid))
            return -1;
        break;

    case SVC_MGR_LIST_SERVICES: {
        uint32_t n = bio_get_uint32(msg);

        if (!svc_can_list(txn->sender_pid, txn->sender_euid)) {
            ALOGE("list_service() uid=%d - PERMISSION DENIED\n",
                    txn->sender_euid);
            return -1;
        }
        si = svclist;
        while ((n-- > 0) && si)
            si = si->next;
        if (si) {
            bio_put_string16(reply, si->name);
            return 0;
        }
        return -1;
    }
    default:
        ALOGE("unknown code %d\n", txn->code);
        return -1;
    }

    bio_put_uint32(reply, 0);
    return 0;
}

所以在binder_parse函数中，如果读到的信息中cmd命令是BR_TRANSACTION,表示有他进程在向sm进行服务的查询或者注册等,而sm主要的功能就是对服务的管理，看来sm主要逻辑就是走这个switch分支了。所以到此，整个service manager二进制程序的主要逻辑就了解完了。

5.2.2 BR_REPLY

和service manager程序相关性不大，略

5.23 BR_DEAD_BINDER

和service manager程序相关性不大，略

在这里插入图片描述

参考 《深入理解android内核设计思想》

HelloCWen
关注
专栏目录
Android ServiceManager○
zenmela2011的专栏
02-22 1390
1.ServiceManager ServiceManager在init进程启动后启动，用来管理系统中的Service。 一般开机过程分为三个阶段： ①OS级别，由bootloader载入linux内核后，内核开始初始化，并载入built-in的驱动程序，内核完成开机后，载入init process，切换至user-space后，结束内核的循序过程，进入排成模式。 ②Android-level，由init process开始，读取init.rc，Native服务启动，并启动重要的外部程序，例如ser
Android系统-源码阅读-系统启动流程笔记
03-16
- **Flow**：在`service_manager.c`中，ServiceManager的主要任务是注册和管理Android系统服务，而`main_runtime.cpp`则涉及SystemServer的运行时行为。 4. **ADBD**： - ADBD是Android Debug Bridge的守护进程，...
ServiceManager 进程启动源码分析
xuela-net
06-26 382
Service Manager是整个Binder机制的守护进程，用来管理开发者创建的各种Server，并且向Client提供查询Server远程接口的功能。Service Manager作为本地服务由Init进程启动，在Android Init进程源码分析中详细分析了Init进程是如何启动本地服务的，在Init.rc配置文件中有这么一段配置： service servicemanager...
系统服务管理者：ServiceManager进程
u011118524的专栏
06-26 7595
概述 framework/native/cmds/servicemanager/ service_manager.c binder.c kernel/drivers/ (不同Linux分支路径略有不同) staging/android/binder.c android/binder.c service_manager进程是由是由init进程，通过解析init.rc文件来启动的进程。 s...
浅谈Service Manager成为Android进程间通信（IPC）机制Binder守护进程之路
oraclestudy
07-22 86
上一篇文章Android进程间通信（IPC）机制Binder简要介绍和学习计划简要介绍了Android系统进程间通信机制Binder的总体架构，它由Client、Server、Service Manager和驱动程序Binder四个组件构成。本文着重介绍组件Service Manager，它是整个Binder机制的守护进程，用来管理开发者创建的各种Server，并且向Client提供查询Se...
Android Binder机制(三) ServiceManager守护进程
CCJHDOPC的专栏:
03-08 899
Android Binder机制(三) ServiceManager守护进程 http://wangkuiwu.github.io/2014/09/03/Binder-ServiceManager-Daemon/  首页博客链接关于我留言板 ServiceManager是用户空间的一个守护进程，它一直运行在后台。它的职责是管理Binder机制中的各个Server。当Server启
android-resource-collection:android源码分析源码备份-android
03-24
"android-resource-collection: android源码分析源码备份-android"是一个专为Android源码爱好者和开发者准备的资源集合，它包含了Android系统的部分源码备份，供学习和研究使用。 这个压缩包文件"android-resource-...
androidjava源码-Android-Source-Codes:各种组件的各种Android源代码
05-20
《深入剖析Android Java源码——...无论是对个人开发者还是企业团队，理解并掌握Android源码都是提升产品竞争力的重要途径。通过不断探索和学习，我们可以在这个开源的世界里打造出更加出色的应用程序和系统解决方案。
Android参考源码-强行结束APP进程的方法.zip
03-08
在Android源码中，有多种方式可以实现强制结束APP进程，这些方法通常由系统或者开发者在特定场景下使用。本文将详细讲解如何通过Android的源码来实现这一操作。 首先，我们要理解Android应用的生命周期。每个...
android ActivityManagerService 源码分析----Activity管理
07-20
"Android ActivityManagerService 源码分析----Activity 管理" Android ActivityManagerService 是 Android 系统中负责管理 Activity 生命周期的核心组件之一。它提供了一个 ArrayList mHistory 来管理所有的 ...
Android的守护进程ServiceManager
新时代农民工
08-10 1178
ServiceManager是Android系统中的一个重要守护进程，它负责管理系统服务的注册、查找和启动。
Android ServiceManager
最新发布
liuning1985622的博客
05-02 1028
ServiceManager是Binder的守护进程，在Android上如果service manager挂掉，所有采用Binder通信的进程服务都会挂掉。ServiceManager本身也是一个Binder服务，handle固定为0。提供注册服务，查询服务的功能。应用程序相要通过Binder向一个service发送数据，必须先通过Service Manager获取该service的handle然后才能通过binder驱动与service通信。
启动 ServiceManager 进程
qq_34888036的博客
06-10 411
相关源码文件： /system/core/rootdir/init.rc /frameworks/native/cmds/servicemanager/service_manager.c /frameworks/native/cmds/servicemanager/binder.c ServiceManager 进程是由 init 进程通过解析 init.rc 文件而创建的 service servicemanager /system/bin/servicemanager class core
ServiceManager进程守护
E894348683的专栏
08-23 1993
1、ServiceManager启动         init进程启动后，ServiceManager进程的启动，远比zygote要早，因为在启动zygote进程时需要用到ServiceManager进程的服务。ServiceManager是一个守护进程，它维护着系统服务和客户端的binder通信。       在init.rc中声明ServiceManager作为一个服务启动： servi
Android Binder学习(二)之ServiceManager进程-我想成为管理员
armwind的专栏
06-01 1530
ServiceMange在binder通信中充当一个管理员的角色，后面就称呼它为sm。当系统启动时，各种server进程将自己的service对象和service名字注册到sm中。后面client进程想使用相应的服务时，就可以根据对应服务的名字，在sm中查找到对应服务，找到之后就会在kernel中创建一个binder引用对象，并将引用对象的描述符返回给client，以让它创建一个服务代理对象。这样
【Android】一文总结Android系统服务大管家-ServiceManager
iriczhao的博客
04-08 2446
ServiceManager是一个由C/C++编写的系统服务，源码位于/framework/native/cmds/servicemanager中，本文简要讨论servicemanager的实现和功能。
Android servicemanager进程启动过程
qq_36063677的博客
02-28 1372
servicemanager服务端启动流程，defaultServiceManger()方法实现
Android_Servicemanager的启动流程分析
c++ 中的符号->
10-19 720
之前在SeystemService的使用中有讲到ServiceManager的作用:查找获取和注册添加系统服务,但是由于那篇文章主要是梳理SystemService的使用,就没有对ServiceManager其他方面进行梳理.今天对ServiceManager的相关源码进行梳理; Servicemanager的启动流程 我们从以下几个方面对Servicemanager的启动进行分析 启动进程...
Android Binder 驱动 - 启动 ServiceManager 进程
z240336124的专栏
08-31 2029
相关文章链接： 1. Android FrameWork - 学习启动篇 2. Android FrameWork - 开机启动 Init 进程 3. Android Binder 驱动 - Media 服务的添加过程 相关源码文件： /system/core/rootdir/init.rc /frameworks/native/cmds/servicemanager/service_manage...
Android源码架构深度解析 - eoeAndroid特刊13
- **AndroidFramework框架介绍**：详细解析了框架层的结构，包括ActivityManagerService、PackageManagerService等关键服务，以及如何通过 Binder 机制进行跨进程通信。 - **AndroidFramework的功能介绍**：阐述了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值