android -- WatchDog看门狗分析

在由单片机构成的微型计算机系统中,由于单片机的工作常常会受到来自外界电磁场的干扰,造成程序的跑飞,而陷入死循环,程序的正常运行被打断,由单片机控制的系统无法继续工作,会造成整个系统的陷入停滞状态,发生不可预料的后果,所以出于对单片机运行状态进行实时监测的考虑,便产生了一种专门用于监测单片机程序运行状态的芯片,俗称"看门狗"。





在Android系统中也需要看好几个重要的Service门，用于发现出了问题的Service杀掉SystemServer进程，所以有必要了解并分析其系统问题。



那么被监控的有哪些Service呢？



ActivityManagerService.java :frameworks\base\services\java\com\android\server\am

PowerManagerService.java    :frameworks\base\services\java\com\android\server

WindowManagerService.java   :frameworks\base\services\java\com\android\server





下面就依次分析一下其整个处理流程：



1、初始化

run @ SysemServer.java

      Slog.i(TAG, "Init Watchdog");

      Watchdog.getInstance().init(context, battery, power, alarm,

              ActivityManagerService.self());





这里使用单例模式创建：

    public static Watchdog getInstance() {

        if (sWatchdog == null) {

            sWatchdog = new Watchdog();

        }

        return sWatchdog;

    }



    public void init(Context context, BatteryService battery,

            PowerManagerService power, AlarmManagerService alarm,

            ActivityManagerService activity) {

        // 上下文环境变量

        mResolver = context.getContentResolver();

        mBattery = battery;

        mPower = power;

        mAlarm = alarm;

        mActivity = activity;

// 登记 RebootReceiver() 接收，用于reboot广播接收使用

context.registerReceiver(new RebootReceiver(),

new IntentFilter(REBOOT_ACTION));

...

// 系统启动时间

mBootTime = System.currentTimeMillis();

    }





ok,调用init函数启动完毕



2、运行中

run @ SysemServer.java

调用 Watchdog.getInstance().start(); 启动看门狗



首先看下 Watchdog 类定义：

/** This class calls its monitor every minute. Killing this process if they don't return **/

public class Watchdog extends Thread {

}



从线程类中继承，即会在一个单独线程中运行，调用thrrad.start()即调用 Watchdog.java 中的 run() 函数



    public void run() {

        boolean waitedHalf = false;





        while (true) {

            mCompleted = false;

            

            // 1、给mHandler发送 MONITOR 消息，用于请求检查 Service是否工作正常

            mHandler.sendEmptyMessage(MONITOR);





            synchronized (this) {

// 2、进行 wait 等待 timeout 时间确认是否退出循环

long timeout = TIME_TO_WAIT;                

                // NOTE: We use uptimeMillis() here because we do not want to increment the time we

                // wait while asleep. If the device is asleep then the thing that we are waiting

                // to timeout on is asleep as well and won't have a chance to run, causing a false

                // positive on when to kill things.

                long start = SystemClock.uptimeMillis();

                while (timeout > 0 && !mForceKillSystem) {

                    try {

                        wait(timeout);  // notifyAll() is called when mForceKillSystem is set

                    } catch (InterruptedException e) {

                        Log.wtf(TAG, e);

                    }

                    timeout = TIME_TO_WAIT - (SystemClock.uptimeMillis() - start);

                }

// 3、如果 mCompleted 为真表示service一切正常，后面会再讲到

if (mCompleted && !mForceKillSystem) {

                    // The monitors have returned.

                    waitedHalf = false;

                    continue;

                }

// 4、表明检测到了有 deadlock-detection 条件发生，利用 dumpStackTraces 打印堆栈依信息

if (!waitedHalf) {

                    // We've waited half the deadlock-detection interval.  Pull a stack

                    // trace and wait another half.

                    ArrayList<Integer> pids = new ArrayList<Integer>();

                    pids.add(Process.myPid());

                    ActivityManagerService.dumpStackTraces(true, pids, null, null);

                    waitedHalf = true;

                    continue; // 不过这里会再次检测一次

                }

}



SystemClock.sleep(2000);

            

            // 5、打印内核栈调用关系

            // Pull our own kernel thread stacks as well if we're configured for that

            if (RECORD_KERNEL_THREADS) {

                dumpKernelStackTraces();

            }

// 6、ok,系统出问题了，检测到某个 Service 出现死锁情况，杀死SystemServer进程

// Only kill the process if the debugger is not attached.

            if (!Debug.isDebuggerConnected()) {

                Slog.w(TAG, "*** WATCHDOG KILLING SYSTEM PROCESS: " + name);

                Process.killProcess(Process.myPid());

                System.exit(10);

            } else {

                Slog.w(TAG, "Debugger connected: Watchdog is *not* killing the system process");

            }





            waitedHalf = false;

        }

    }





主要工作逻辑：监控线程每隔一段时间发送一条 MONITOR 线另外一个线程，另个一个线程会检查各个 Service 是否正常运行，看门狗就不停的检查并等待结果，失败则杀死SystemServer.





3、Service 检查线程



    /**

     * Used for scheduling monitor callbacks and checking memory usage.

     */

    final class HeartbeatHandler extends Handler {

@Override
 

    public void handleMessage(Message msg) {  // Looper 消息处理函数

            switch (msg.what) {

            

                case MONITOR: {

// 依次检测各个服务，即调用 monitor() 函数

final int size = mMonitors.size();

for (int i = 0 ; i < size ; i++) {

                        mCurrentMonitor = mMonitors.get(i);

                        mCurrentMonitor.monitor();

                    }

// 检测成功则设置 mCompleted 变量为 true

synchronized (Watchdog.this) {

                        mCompleted = true;

                        mCurrentMonitor = null;

                    }



下面我们来看一下各个Service如何确定自已运行ok呢？以 ActivityManagerService 为例：



首先加入检查队列：

private ActivityManagerService() {

        // Add ourself to the Watchdog monitors.

        Watchdog.getInstance().addMonitor(this);

}





然后实现 monitor() 函数：

    /** In this method we try to acquire our lock to make sure that we have not deadlocked */

    public void monitor() {

        synchronized (this) { }

    }

明白了吧，其实就是检查这个 Service 是否发生了死锁，对于此情况就只能kill SystemServer系统了。对于死锁的产生原因非常多，但有个情况需要注意：java层死锁可能发生在调用native函数，而native函数可能与硬件交互导致时间过长而没有返回，从而导致长时间占用导致问题。



4、内存使用检测

消息发送

final class GlobalPssCollected implements Runnable {

public void run() {

            mHandler.sendEmptyMessage(GLOBAL_PSS);

        }

    }

    

    检测内存处理函数：

    final class HeartbeatHandler extends Handler {

        @Override

        public void handleMessage(Message msg) {

            switch (msg.what) {

                case GLOBAL_PSS: {

                    if (mHaveGlobalPss) {

                        // During the last pass we collected pss information, so

                        // now it is time to report it.

                        mHaveGlobalPss = false;

                        if (localLOGV) Slog.v(TAG, "Received global pss, logging.");

logGlobalMemory();

}

                } break;

                

        

        其主要功能如下,统计pSS状况及读取相关linux内核中内存信息：

        void logGlobalMemory() {        

        mActivity.collectPss(stats);

        

        Process.readProcLines("/proc/meminfo",
mMemInfoFields, mMemInfoSizes);

        

        Process.readProcLines("/proc/vmstat",
mVMStatFields, mVMStatSizes);

}