如何应对Android面试官-＞进程通信，启动与获取SM服务

最新推荐文章于 2024-12-02 23:35:47 发布

老A说

最新推荐文章于 2024-12-02 23:35:47 发布

阅读量1.1k

点赞数 21

文章标签： android

本文链接：https://blog.youkuaiyun.com/IT_Android/article/details/136978286

版权

前言

本章主要围绕 ServiceManager 进行讲解，通过注册、启动等流程，玩转 ServiceManager；

ServiceManager 是什么？

客户端想要调用系统的 AMS 或者 PMS，但是客户端直接调用不到，只能获取到 AMS-IBinder 对象，AMS 在启动的时候就会把 AMS-IBinder 对象注册到 ServiceManager 中，客户端只要找到 ServiceManager 之后，就可以把 AMS-IBinder 对象返回给客户端，客户端就可以通过 AMS-IBinder 同 AMS 进行通信；

ServiceManager 它也是一个服务，但是它的句柄是确认的，也就是 handle = 0，而我们客户端在调用系统服务的时候，只需要调用这个已知道的 handle = 0 的服务就可以获取到 ServiceManager 的代理对象，然后就可以同其他系统服务通信了；

ServiceManager 服务是如何注册的？

那么 ServiceManager 是怎么注册的呢？我们进入源码看一下，它的注册就在 init.rc 中：

// 打开 ServiceManager 这个程序，就会 调用 ServiceManager 的 main 方法
service servicemanager /system/bin/servicemanager
    class core
    user system
    group system
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart drm

打开 ServiceManager 这个程序，就会调用 servicemanager.c 的 main 方法，我们进入 main 方法看下：

int main(int argc, char **argv)
{
    struct binder_state *bs;
    // 这个方法做了两件事情，一是 open 方法，打开 binder 驱动，二是 mmap 方法，建立映射关系
    bs = binder_open(128*1024);
    if (!bs) {
        ALOGE("failed to open binder driver\n");
        return -1;
    }
    // 把 ServiceManager 设置成服务大管家
    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;
}

binder_open 这个方法做了两件事情，一是 open(128*1024) 方法，打开 binder 驱动，二是 mmap 方法，建立映射关系；

binder_become_context_manager 把 ServiceManager 设置成服务大管家；

binder_loop 循环监听有没有其他服务访问；

我们进入 binder_become_context_manager 这个方法看下，它是如何成为大管家的

int binder_become_context_manager(struct binder_state *bs)
{
    return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);
}

直接调用的 ioctl 方法，传入的参数是 BINDER_SET_CONTEXT_MGR，而这个方法最终调用到 binder_ioctl 中，我们进入 BINDER_SET_CONTEXT_MGR 这个 case 看下：

case BINDER_SET_CONTEXT_MGR:
    ret = binder_ioctl_set_ctx_mgr(filp);
    if (ret)
	goto err;
    break;

这个 case 中调用的是 binder_ioctl_set_ctx_mgr，我们进入这个方法看下：

static int binder_ioctl_set_ctx_mgr(struct file *filp)
{
	int ret = 0;
	struct binder_proc *proc = filp->private_data;
	struct binder_context *context = proc->context;

	kuid_t curr_euid = current_euid();
   // 先判断是不是已经存在了，存在则直接返回
	if (context->binder_context_mgr_node) {
		pr_err("BINDER_SET_CONTEXT_MGR already set\n");
		ret = -EBUSY;
		goto out;
	}
	ret = security_binder_set_context_mgr(proc->tsk);
	if (ret < 0)
		goto out;
   // 判断 sm 的 uid 是否是有效的，第一次肯定是无效的，所以直接进入 else
	if (uid_valid(context->binder_context_mgr_uid)) {
		if (!uid_eq(context->binder_context_mgr_uid, curr_euid)) {
			pr_err("BINDER_SET_CONTEXT_MGR bad uid %d != %d\n",
			       from_kuid(&init_user_ns, curr_euid),
			       from_kuid(&init_user_ns,
					 context->binder_context_mgr_uid));
			ret = -EPERM;
			goto out;
		}
	} else {
            // 设置 uid
            context->binder_context_mgr_uid = curr_euid;
	}
        // 通过 binder_new_node 创建 SM 的 binder_context_mgr_node 结构体
	context->binder_context_mgr_node = binder_new_node(proc, 0, 0);
	if (!context->binder_context_mgr_node) {
		ret = -ENOMEM;
		goto out;
	}
	context->binder_context_mgr_node->local_weak_refs++;
	context->binder_context_mgr_node->local_strong_refs++;
	context->binder_context_mgr_node->has_strong_ref = 1;
	context->binder_context_mgr_node->has_weak_ref = 1;
out:
	return ret;
}

到这里，就把 ServiceManager 设置成了大管家；

我们接下来看下 binder_loop 这个方法：

void binder_loop(struct binder_state *bs, binder_handler func)
{
    int res;
    // 结构体，这个结构体中有读和写，以及buffer
    struct binder_write_read bwr;
    uint32_t readbuf[32];

    bwr.write_size = 0;
    bwr.write_consumed = 0;
    bwr.write_buffer = 0;
    // BC_ENTER_LOOPER 是一个命令，进入循环的命令
    readbuf[0] = BC_ENTER_LOOPER;
    // 执行 binder_write 把 buffer 放进去，内部执行 ioctl 方法，最终调用到 binder_ioctl_write_read 方法
    binder_write(bs, readbuf, sizeof(uint32_t));

    for (;;) {
        bwr.read_size = sizeof(readbuf);
        bwr.read_consumed = 0;
        bwr.read_buffer = (uintptr_t) 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;
        }
    }
}

// 执行 binder_write 把 buffer 放进去，内部执行 ioctl 方法，最终调用到 binder_ioctl_write_read 方法，我们进入这个方法看下：

static int binder_ioctl_write_read(struct file *filp,
				unsigned int cmd, unsigned long arg,
				struct binder_thread *thread)
{
	int ret = 0;
	struct binder_proc *proc = filp->private_data;
	unsigned int size = _IOC_SIZE(cmd);
	void __user *ubuf = (void __user *)arg;
	struct binder_write_read bwr;

	if (size != sizeof(struct binder_write_read)) {
		ret = -EINVAL;
		goto out;
	}
	if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
		ret = -EFAULT;
		goto out;
	}
	binder_debug(BINDER_DEBUG_READ_WRITE,
		     "%d:%d write %lld at %016llx, read %lld at %016llx\n",
		     proc->pid, thread->pid,
		     (u64)bwr.write_size, (u64)bwr.write_buffer,
		     (u64)bwr.read_size, (u64)bwr.read_buffer);
    // 两个 if 来判断是要执行 read 还是 write 方法
	if (bwr.write_size > 0) {
		ret = binder_thread_write(proc, thread,
					  bwr.write_buffer,
					  bwr.write_size,
					  &bwr.write_consumed);
		trace_binder_write_done(ret);
		if (ret < 0) {
			bwr.read_consumed = 0;
			if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
				ret = -EFAULT;
			goto out;
		}
	}
	if (bwr.read_size > 0) {
		ret = binder_thread_read(proc, thread, bwr.read_buffer,
					 bwr.read_size,
					 &bwr.read_consumed,
					 filp->f_flags & O_NONBLOCK);
		trace_binder_read_done(ret);
		if (!list_empty(&proc->todo))
			wake_up_interruptible(&proc->wait);
		if (ret < 0) {
			if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
				ret = -EFAULT;
			goto out;
		}
	}
	binder_debug(BINDER_DEBUG_READ_WRITE,
		     "%d:%d wrote %lld of %lld, read return %lld of %lld\n",
		     proc->pid, thread->pid,
		     (u64)bwr.write_consumed, (u64)bwr.write_size,
		     (u64)bwr.read_consumed, (u64)bwr.read_size);
	if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {
		ret = -EFAULT;
		goto out;
	}
out:
	return ret;
}

bwr.write_size > 0 执行 write 或者 bwr.read_size > 0 执行 read 操作，我们进入 write 的操作看下，这个方法最终执行的命令是我们前面看到的 BC_ENTER_LOOPER 这个命令，我们直接进入这个 case 看下

case BC_ENTER_LOOPER:
    binder_debug(BINDER_DEBUG_THREADS,
				     "%d:%d BC_ENTER_LOOPER\n",
				     proc->pid, thread->pid);
    if (thread->looper & BINDER_LOOPER_STATE_REGISTERED) {
        thread->looper |= BINDER_LOOPER_STATE_INVALID;
	binder_user_error("%d:%d ERROR: BC_ENTER_LOOPER called after BC_REGISTER_LOOPER\n",
	proc->pid, thread->pid);
    }
    // 其实就做了一件事情，给当前 thread 的 looper 设置了一个状态
    thread->looper |= BINDER_LOOPER_STATE_ENTERED;
    break;

其实就做了一件事情，给当前 thread 的 looper 设置了一个状态；

我们接着回到 binder_loop 方法往下看，下面一个是 for(;😉 无限循环，这里依然调用的是 res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr); 这个方法，只是 case 传递了 BINDER_WRITE_READ，我们继续进入这个方法看下，最终进入的是 binder_thread_read 方法，这个方法最终调用到 ret = wait_event_freezable_exclusive(proc->wait, binder_has_proc_work(proc, thread)); 进入等待状态了

if (wait_for_proc_work) {
	if (!(thread->looper & (BINDER_LOOPER_STATE_REGISTERED |
					BINDER_LOOPER_STATE_ENTERED))) {
			binder_user_error("%d:%d ERROR: Thread waiting for process work before calling BC_REGISTER_LOOPER or BC_ENTER_LOOPER (state %x)\n",
				proc->pid, thread->pid, thread->looper);
			wait_event_interruptible(binder_user_error_wait,
						 binder_stop_on_user_error < 2);
	}
	binder_set_nice(proc->default_priority);
	if (non_block) {
		if (!binder_has_proc_work(proc, thread))
                    ret = -EAGAIN;
	} else {
            // binder 是阻塞的，所以最终进入到这里
           ret = wait_event_freezable_exclusive(proc->wait, binder_has_proc_work(proc, thread));
        }
}

SM 的注册还是比较简单的，一共就三步，第一步是 binder_open，第二步是 binder_become_context_manager(成为大管家，也叫设置为守护进程)，第三步是 binder_loop

整体就是图上 1 、2 、3 三个步骤；

ServiceManager 服务是如何获取的

我们接下来看下 SM 是如何获取的；获取 SM 的情况一般是两种，一种是注册服务到 SM，一种是通过 SM 去获取服务，这两种都需要拿到 SM 才能实现；SM 的 native 层获取一般是在 IServiceManager.cpp 中，我们进入这个文件看下

sp<IServiceManager> defaultServiceManager()
{
    if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
    
    {
        AutoMutex _l(gDefaultServiceManagerLock);
        while (gDefaultServiceManager == NULL) {
            gDefaultServiceManager = interface_cast<IServiceManager>(
                ProcessState::self()->getContextObject(NULL));
            if (gDefaultServiceManager == NULL)
                sleep(1);
        }
    }
    
    return gDefaultServiceManager;
}

native 层的获取 SM 都是从这里执行的，首先是一个单例，然后一个 while 循环来获取 SM，如果获取不到会进行一个休眠等待，主要的获取逻辑在下面这行代码

gDefaultServiceManager = interface_cast<IServiceManager>(
                ProcessState::self()->getContextObject(NULL));

self()

我们来逐步分析这个方法都做了什么，首先我们来看下 ProcessState::self()->getContextObject(NULL) 这个参数都做了什么操作；

首先是 self 方法，我们进入这个 self 方法看下做了什么

sp<ProcessState> ProcessState::self()
{
    Mutex::Autolock _l(gProcessMutex);
    if (gProcess != NULL) {
        return gProcess;
    }
    gProcess = new ProcessState;
    return gProcess;
}

很简单，就是 new ProcessState 并返回，创建这个 ProcessState 的时候做了什么呢？我们进入构造函数看一下

ProcessState::ProcessState()
    : mDriverFD(open_driver())
    , mVMStart(MAP_FAILED)
    , mThreadCountLock(PTHREAD_MUTEX_INITIALIZER)
    , mThreadCountDecrement(PTHREAD_COND_INITIALIZER)
    , mExecutingThreadsCount(0)
    , mMaxThreads(DEFAULT_MAX_BINDER_THREADS)
    , mManagesContexts(false)
    , mBinderContextCheckFunc(NULL)
    , mBinderContextUserData(NULL)
    , mThreadPoolStarted{
        if (mDriverFD >= 0) {
        // XXX Ideally, there should be a specific define for whether we
        // have mmap (or whether we could possibly have the kernel module
        // availabla).
#if !defined(HAVE_WIN32_IPC)
        // mmap the binder, providing a chunk of virtual address space to receive transactions.
        mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
        if (mVMStart == MAP_FAILED) {
            // *sigh*
            ALOGE("Using /dev/binder failed: unable to mmap transaction memory.\n");
            close(mDriverFD);
            mDriverFD = -1;
        }
#else
        mDriverFD = -1;
#endif
    }

    LOG_ALWAYS_FATAL_IF(mDriverFD < 0, "Binder driver could not be opened.  Terminating.");
    }

第一步，是 open_driver() 通过 open 方法打开 binder 设备(驱动)，并通过 maxThreads 设置最大线程数；

static int open_driver()
{
    int fd = open("/dev/binder", O_RDWR);
    if (fd >= 0) {
        fcntl(fd, F_SETFD, FD_CLOEXEC);
        int vers = 0;
        status_t result = ioctl(fd, BINDER_VERSION, &vers);
        if (result == -1) {
            ALOGE("Binder ioctl to obtain version failed: %s", strerror(errno));
            close(fd);
            fd = -1;
        }
        if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) {
            ALOGE("Binder driver protocol does not match user space protocol!");
            close(fd);
            fd = -1;
        }
        size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;
        result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
        if (result == -1) {
            ALOGE("Binder ioctl to set max threads failed: %s", strerror(errno));
        }
    } else {
        ALOGW("Opening '/dev/binder' failed: %s\n", strerror(errno));
    }
    return fd;
}

我们接着看创建的逻辑，

mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);

通过 mmap 设置共享内存， 1M-8K（普通服务的大小）；可以看到有一个常量参数 BINDER_VM_SIZE 它的值就是 #define BINDER_VM_SIZE ((110241024) - (4096 *2))；

所以这个 self() 方法做了三件事情，分别是：

打开驱动，open_driver() 方法；
设置最大线程数据，15；
mmap，设置共享内存大小，1M-8K；

getContextObject(NULL)

我们接下来看下 getContextObject(NULL) 做了些什么？这个方法直接调用了

sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
    return getStrongProxyForHandle(0);
}

这个方法直接调用了 getStrongProxyForHandle(0) 传入了 0；我们进入这个方法看下都发生了什么？

sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
    sp<IBinder> result;

    AutoMutex _l(mLock);
    // 查找 handle 对应的资源线
    handle_entry* e = lookupHandleLocked(handle);

    if (e != NULL) {
        IBinder* b = e->binder;
        if (b == NULL || !e->refs->attemptIncWeak(this)) {
            if (handle == 0) {
                Parcel data;
                // 测试 binder 是否已经准备就绪
                status_t status = IPCThreadState::self()->transact(
                        0, IBinder::PING_TRANSACTION, data, NULL, 0);
                if (status == DEAD_OBJECT)
                   return NULL;
            }
            // 创建 BpBinder 并返回；
            b = new BpBinder(handle); 
            e->binder = b;
            if (b) e->refs = b->getWeakRefs();
            result = b;
        } else {
            result.force_set(b);
            e->refs->decWeak(this);
        }
    }

    return result;
}

这个方法就做了一件事情，就是创建 BpBinder，我们可以看下，在创建这个 BpBinider 的时候做了什么？

BpBinder

BpBinder::BpBinder(int32_t handle)
    : mHandle(handle)
    , mAlive(1)
    , mObitsSent(0)
    , mObituaries(NULL)
{
    ALOGV("Creating BpBinder %p handle %d\n", this, mHandle);

    extendObjectLifetime(OBJECT_LIFETIME_WEAK);
    // 主要是调用 incWeakHandle 做一个弱引用的计数
    IPCThreadState::self()->incWeakHandle(handle);
}

所以 ProcessState::self()->getContextObject(NULL) 这个参数本质就是返回 BpBinder 对象；这个 BpBinder 对象就是指向服务端的代理对象，我们在这里就可以认为是 ServiceManager；

BpBinder 是 BBinder 的代理对象，这里可以认为它俩是一样的；

Java 层和 Native 层通信的时候，需要一个 BinderProxy 和 ServiceManagerProxy，ServiceManagerProxy 里面有一个 BinderProxy，这个 BinderProxy 指向 BpBinder，也就是说 Java 层需要拿到这个 BpBinder 才能通信，Java 通过操作 ServiceManagerProxy，而 ServiceManagerProxy 通过操作 Remote(BinderProxy)，这个时候，这个 BinderProxy 它是 Java 层的，它要指向 Native 层的才能通信，而这个 Native 层的就是 BpBinder，这个 BpBinder 就是代理对象；

Native 层也需要获取 BpBinder，但是它与 Java 层的获取方式不同，它是通过操作 BpServiceManager ，而 BpServiceManager 可以直接操作 BpBinder，这就少了一步，Java 层和 Native 层都是 BpBinder，再由 BpBinder 进行 transac 进行通信

interface_cast

我们接下来看下这个 interface_cast 方法，这个方法传入的参数就是 BpBinder；

template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
    return INTERFACE::asInterface(obj);
}

这个方法调用的是 INTERFACE::asInterface(obj)，这里是一个泛型操作，所以最终调用的是 IServiceManager 的 asInterface(obj) 方法；但是这个方法并不在 IServiceManager 这个文件中，它使用的模板放进行了一个宏定义，我们在找下这个宏定义

#define DECLARE_META_INTERFACE(INTERFACE)                               \
    static const android::String16 descriptor;                          \
    static android::sp<I##INTERFACE> asInterface(                       \
            const android::sp<android::IBinder>& obj);                  \
    virtual const android::String16& getInterfaceDescriptor() const;    \
    I##INTERFACE();                                                     \
    virtual ~I##INTERFACE();

这里通过宏定义之后会进行一个替换，替换之后的 C++ 代码实现如下：

static const android::String16 descriptor;

static android::sp< IServiceManager > asInterface(const

android::sp<android::IBinder>& obj)

virtual const android::String16& getInterfaceDescriptor() const;

IServiceManager ();

virtual ~IServiceManager();

该过程主要是声明asInterface()，getInterfaceDescriptor()方法，所以这里我们不用过多的关心；

我们接着看下面的宏定义以及替换之后的逻辑

#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)                       \
    const android::String16 I##INTERFACE::descriptor(NAME);             \
    const android::String16&                                            \
            I##INTERFACE::getInterfaceDescriptor() const {              \
        return I##INTERFACE::descriptor;                                \
    }                                                                   \
    android::sp<I##INTERFACE> I##INTERFACE::asInterface(                \
            const android::sp<android::IBinder>& obj)                   \
    {                                                                   \
        android::sp<I##INTERFACE> intr;                                 \
        if (obj != NULL) {                                              \
            intr = static_cast<I##INTERFACE*>(                          \
                obj->queryLocalInterface(                               \
                        I##INTERFACE::descriptor).get());               \
            if (intr == NULL) {                                         \
                intr = new Bp##INTERFACE(obj);                          \
            }                                                           \
        }                                                               \
        return intr;                                                    \
    }                                                                   \
    I##INTERFACE::I##INTERFACE() { }                                    \
    I##INTERFACE::~I##INTERFACE() { }                                   \

替换之后的逻辑如下：

const android::String16
IServiceManager::descriptor(“android.os.IServiceManager”);
const android::String16& IServiceManager::getInterfaceDescriptor() const
{
    return IServiceManager::descriptor;
}

android::sp<IServiceManager> IServiceManager::asInterface(const
android::sp<android::IBinder>& obj)
{
    android::sp<IServiceManager> intr;
    if(obj != NULL) {
        intr = static_cast<IServiceManager *>(
        obj->queryLocalInterface(IServiceManager::descriptor).get());
        if (intr == NULL) {
            // 等价于 new BpServiceManager(BpBinder)
            intr = new BpServiceManager(obj);
        }
    }
    return intr;
}

IServiceManager::IServiceManager () {}
IServiceManager::~ IServiceManager() {}

展开之后，我们主要关心的就是 asInterface 方法，这个方法具体做了什么，我们来看下：

这里就是创建了 BpServiceManager，构造方法中传入的 BpBinder，我们来看下它是怎么使用 BpBinder 的；

BpServiceManager

BpServiceManager(const sp<IBinder>& impl)
        : BpInterface<IServiceManager>(impl)
    {
    }

我们来看下 BpInterface

template<typename INTERFACE>
class BpInterface : public INTERFACE, public BpRefBase
{
public:
                                BpInterface(const sp<IBinder>& remote);

protected:
    virtual IBinder*            onAsBinder();
};

这里我们直接看 BpInterface 的继承 BpRefBase

BpRefBase::BpRefBase(const sp<IBinder>& o)
    : mRemote(o.get()), mRefs(NULL), mState(0)
{
    extendObjectLifetime(OBJECT_LIFETIME_WEAK);

    if (mRemote) {
        mRemote->incStrong(this);           // Removed on first IncStrong().
        mRefs = mRemote->createWeak(this);  // Held for our entire lifetime.
    }
}

到此，我们就找到了 mRemote 它来操作 BpBinder，也就是对应的 java 层调用 mRemote.transact() 的时候，就是调用的 BpBinder.transact() 来进行通信；

所以这个方法也是做了三件事情

new BpServiceManager(new BpBinder)
remote.transcat() 远程调用
remote = BpBinder

到此，ServiceManager 的注册与获取就写完了；

下一章预告

进程通信注册与获取服务及线程池讲解

欢迎三连

来都来了，点个关注点个赞吧，你的支持是我最大的动力~~~