Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 1 | /** |
| 2 | * Copyright (c) 2020, The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 17 | #ifndef CPP_WATCHDOG_SERVER_SRC_WATCHDOGPROCESSSERVICE_H_ |
| 18 | #define CPP_WATCHDOG_SERVER_SRC_WATCHDOGPROCESSSERVICE_H_ |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 19 | |
Eric Jeong | 6ff82ef | 2021-10-20 22:23:14 -0700 | [diff] [blame^] | 20 | #include <android-base/chrono_utils.h> |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 21 | #include <android-base/result.h> |
Lakshman Annadorai | e405462 | 2020-11-10 14:09:42 -0800 | [diff] [blame] | 22 | #include <android/automotive/watchdog/ICarWatchdogClient.h> |
| 23 | #include <android/automotive/watchdog/internal/ICarWatchdogMonitor.h> |
| 24 | #include <android/automotive/watchdog/internal/ICarWatchdogServiceForSystem.h> |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 25 | #include <android/automotive/watchdog/internal/PowerCycle.h> |
| 26 | #include <android/automotive/watchdog/internal/UserState.h> |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 27 | #include <android/hardware/automotive/vehicle/2.0/IVehicle.h> |
Lakshman Annadorai | 0dfeeeb | 2020-03-13 16:57:12 -0700 | [diff] [blame] | 28 | #include <binder/IBinder.h> |
| 29 | #include <binder/Status.h> |
| 30 | #include <cutils/multiuser.h> |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 31 | #include <utils/Looper.h> |
| 32 | #include <utils/Mutex.h> |
Lakshman Annadorai | 0dfeeeb | 2020-03-13 16:57:12 -0700 | [diff] [blame] | 33 | #include <utils/String16.h> |
| 34 | #include <utils/StrongPointer.h> |
| 35 | #include <utils/Vector.h> |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 36 | |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 37 | #include <unordered_map> |
| 38 | #include <unordered_set> |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 39 | #include <vector> |
| 40 | |
| 41 | namespace android { |
| 42 | namespace automotive { |
| 43 | namespace watchdog { |
| 44 | |
Lakshman Annadorai | ec4d08a | 2021-04-30 08:29:10 -0700 | [diff] [blame] | 45 | class IWatchdogServiceHelper; |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 46 | |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 47 | class WatchdogProcessService : public android::RefBase { |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 48 | public: |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 49 | explicit WatchdogProcessService(const android::sp<Looper>& handlerLooper); |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 50 | ~WatchdogProcessService() { terminate(); } |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 51 | |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 52 | android::base::Result<void> start(); |
| 53 | void terminate(); |
Lakshman Annadorai | 8fae85c | 2021-04-16 14:42:19 -0700 | [diff] [blame] | 54 | virtual android::base::Result<void> dump(int fd, |
| 55 | const android::Vector<android::String16>& args); |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 56 | void doHealthCheck(int what); |
| 57 | |
| 58 | virtual android::base::Result<void> registerWatchdogServiceHelper( |
Lakshman Annadorai | ec4d08a | 2021-04-30 08:29:10 -0700 | [diff] [blame] | 59 | const android::sp<IWatchdogServiceHelper>& helper); |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 60 | |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 61 | virtual android::binder::Status registerClient(const android::sp<ICarWatchdogClient>& client, |
| 62 | TimeoutLength timeout); |
Lakshman Annadorai | e405462 | 2020-11-10 14:09:42 -0800 | [diff] [blame] | 63 | virtual android::binder::Status unregisterClient(const android::sp<ICarWatchdogClient>& client); |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 64 | virtual android::binder::Status registerCarWatchdogService(const android::sp<IBinder>& binder); |
| 65 | virtual void unregisterCarWatchdogService(const android::sp<IBinder>& binder); |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 66 | virtual android::binder::Status registerMonitor( |
Lakshman Annadorai | e405462 | 2020-11-10 14:09:42 -0800 | [diff] [blame] | 67 | const android::sp<android::automotive::watchdog::internal::ICarWatchdogMonitor>& |
| 68 | monitor); |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 69 | virtual android::binder::Status unregisterMonitor( |
Lakshman Annadorai | e405462 | 2020-11-10 14:09:42 -0800 | [diff] [blame] | 70 | const android::sp<android::automotive::watchdog::internal::ICarWatchdogMonitor>& |
| 71 | monitor); |
| 72 | virtual android::binder::Status tellClientAlive(const android::sp<ICarWatchdogClient>& client, |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 73 | int32_t sessionId); |
Lakshman Annadorai | e405462 | 2020-11-10 14:09:42 -0800 | [diff] [blame] | 74 | virtual android::binder::Status tellCarWatchdogServiceAlive( |
| 75 | const android::sp< |
| 76 | android::automotive::watchdog::internal::ICarWatchdogServiceForSystem>& service, |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 77 | const std::vector<int32_t>& clientsNotResponding, int32_t sessionId); |
| 78 | virtual android::binder::Status tellDumpFinished( |
| 79 | const android::sp<android::automotive::watchdog::internal::ICarWatchdogMonitor>& |
| 80 | monitor, |
| 81 | int32_t pid); |
Lakshman Annadorai | 0a0a787 | 2021-06-08 14:55:26 -0700 | [diff] [blame] | 82 | virtual void setEnabled(bool isEnabled); |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 83 | virtual android::binder::Status notifyUserStateChange( |
| 84 | userid_t userId, android::automotive::watchdog::internal::UserState state); |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 85 | |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 86 | private: |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 87 | enum ClientType { |
| 88 | Regular, |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 89 | Service, |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 90 | }; |
| 91 | |
| 92 | struct ClientInfo { |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 93 | ClientInfo(const android::sp<ICarWatchdogClient>& client, pid_t pid, userid_t userId) : |
Eric Jeong | 01a28aa | 2020-03-27 16:43:19 -0700 | [diff] [blame] | 94 | pid(pid), |
| 95 | userId(userId), |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 96 | type(ClientType::Regular), |
| 97 | client(client) {} |
Lakshman Annadorai | ec4d08a | 2021-04-30 08:29:10 -0700 | [diff] [blame] | 98 | ClientInfo(const android::sp<IWatchdogServiceHelper>& helper, |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 99 | const android::sp<android::IBinder>& binder, pid_t pid, userid_t userId) : |
| 100 | pid(pid), |
| 101 | userId(userId), |
| 102 | type(ClientType::Service), |
| 103 | watchdogServiceHelper(helper), |
| 104 | watchdogServiceBinder(binder) {} |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 105 | |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 106 | std::string toString() const; |
| 107 | status_t linkToDeath(const android::sp<android::IBinder::DeathRecipient>& recipient) const; |
| 108 | status_t unlinkToDeath( |
| 109 | const android::wp<android::IBinder::DeathRecipient>& recipient) const; |
| 110 | android::binder::Status checkIfAlive(TimeoutLength timeout) const; |
| 111 | android::binder::Status prepareProcessTermination() const; |
| 112 | bool operator!=(const ClientInfo& clientInfo) const { |
| 113 | return getBinder() != clientInfo.getBinder() || type != clientInfo.type; |
| 114 | } |
| 115 | bool matchesBinder(const android::sp<android::IBinder>& binder) const { |
| 116 | return binder == getBinder(); |
| 117 | } |
| 118 | |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 119 | pid_t pid; |
Eric Jeong | 01a28aa | 2020-03-27 16:43:19 -0700 | [diff] [blame] | 120 | userid_t userId; |
Eric Jeong | 27a178f | 2020-03-24 16:39:39 -0700 | [diff] [blame] | 121 | int sessionId; |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 122 | |
| 123 | private: |
| 124 | android::sp<android::IBinder> getBinder() const; |
| 125 | |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 126 | ClientType type; |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 127 | android::sp<ICarWatchdogClient> client = nullptr; |
Lakshman Annadorai | ec4d08a | 2021-04-30 08:29:10 -0700 | [diff] [blame] | 128 | android::sp<IWatchdogServiceHelper> watchdogServiceHelper = nullptr; |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 129 | android::sp<IBinder> watchdogServiceBinder = nullptr; |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 130 | }; |
| 131 | |
Eric Jeong | 2ac089c | 2020-08-27 17:50:38 -0700 | [diff] [blame] | 132 | struct HeartBeat { |
| 133 | int64_t eventTime; |
| 134 | int64_t value; |
| 135 | }; |
| 136 | |
Eric Jeong | 27a178f | 2020-03-24 16:39:39 -0700 | [diff] [blame] | 137 | typedef std::unordered_map<int, ClientInfo> PingedClientMap; |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 138 | |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 139 | class BinderDeathRecipient : public android::IBinder::DeathRecipient { |
| 140 | public: |
| 141 | explicit BinderDeathRecipient(const android::sp<WatchdogProcessService>& service); |
| 142 | |
| 143 | void binderDied(const android::wp<android::IBinder>& who) override; |
| 144 | |
| 145 | private: |
| 146 | android::sp<WatchdogProcessService> mService; |
| 147 | }; |
| 148 | |
| 149 | class HidlDeathRecipient : public android::hardware::hidl_death_recipient { |
| 150 | public: |
| 151 | explicit HidlDeathRecipient(const android::sp<WatchdogProcessService>& service); |
| 152 | |
| 153 | void serviceDied(uint64_t cookie, |
| 154 | const android::wp<android::hidl::base::V1_0::IBase>& who) override; |
| 155 | |
| 156 | private: |
| 157 | android::sp<WatchdogProcessService> mService; |
| 158 | }; |
| 159 | |
Eric Jeong | 2ac089c | 2020-08-27 17:50:38 -0700 | [diff] [blame] | 160 | class PropertyChangeListener : |
| 161 | public android::hardware::automotive::vehicle::V2_0::IVehicleCallback { |
| 162 | public: |
| 163 | explicit PropertyChangeListener(const android::sp<WatchdogProcessService>& service); |
| 164 | |
| 165 | android::hardware::Return<void> onPropertyEvent( |
| 166 | const android::hardware::hidl_vec< |
| 167 | android::hardware::automotive::vehicle::V2_0::VehiclePropValue>& propValues) |
| 168 | override; |
| 169 | android::hardware::Return<void> onPropertySet( |
| 170 | const android::hardware::automotive::vehicle::V2_0::VehiclePropValue& propValue) |
| 171 | override; |
| 172 | android::hardware::Return<void> onPropertySetError( |
| 173 | android::hardware::automotive::vehicle::V2_0::StatusCode errorCode, int32_t propId, |
| 174 | int32_t areaId) override; |
| 175 | |
| 176 | private: |
| 177 | android::sp<WatchdogProcessService> mService; |
| 178 | }; |
| 179 | |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 180 | class MessageHandlerImpl : public MessageHandler { |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 181 | public: |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 182 | explicit MessageHandlerImpl(const android::sp<WatchdogProcessService>& service); |
| 183 | |
| 184 | void handleMessage(const Message& message) override; |
| 185 | |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 186 | private: |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 187 | android::sp<WatchdogProcessService> mService; |
| 188 | }; |
| 189 | |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 190 | private: |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 191 | android::binder::Status registerClientLocked(const ClientInfo& clientInfo, |
| 192 | TimeoutLength timeout); |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 193 | android::binder::Status unregisterClientLocked(const std::vector<TimeoutLength>& timeouts, |
| 194 | android::sp<IBinder> binder, |
| 195 | ClientType clientType); |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 196 | android::binder::Status tellClientAliveLocked(const android::sp<android::IBinder>& binder, |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 197 | int32_t sessionId); |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 198 | android::base::Result<void> startHealthCheckingLocked(TimeoutLength timeout); |
| 199 | android::base::Result<void> dumpAndKillClientsIfNotResponding(TimeoutLength timeout); |
| 200 | android::base::Result<void> dumpAndKillAllProcesses( |
Eric Jeong | 2ac089c | 2020-08-27 17:50:38 -0700 | [diff] [blame] | 201 | const std::vector<int32_t>& processesNotResponding, bool reportToVhal); |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 202 | int32_t getNewSessionId(); |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 203 | android::base::Result<void> updateVhal( |
| 204 | const android::hardware::automotive::vehicle::V2_0::VehiclePropValue& value); |
| 205 | android::base::Result<void> connectToVhalLocked(); |
Eric Jeong | 2ac089c | 2020-08-27 17:50:38 -0700 | [diff] [blame] | 206 | void subscribeToVhalHeartBeatLocked(); |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 207 | void reportWatchdogAliveToVhal(); |
| 208 | void reportTerminatedProcessToVhal(const std::vector<int32_t>& processesNotResponding); |
| 209 | android::base::Result<std::string> readProcCmdLine(int32_t pid); |
| 210 | void handleBinderDeath(const android::wp<android::IBinder>& who); |
| 211 | void handleHidlDeath(const android::wp<android::hidl::base::V1_0::IBase>& who); |
| 212 | void queryVhalPropertiesLocked(); |
| 213 | bool isVhalPropertySupportedLocked( |
| 214 | android::hardware::automotive::vehicle::V2_0::VehicleProperty propId); |
Eric Jeong | 2ac089c | 2020-08-27 17:50:38 -0700 | [diff] [blame] | 215 | void updateVhalHeartBeat(int64_t value); |
| 216 | void checkVhalHealth(); |
| 217 | void terminateVhal(); |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 218 | |
| 219 | using Processor = |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 220 | std::function<void(std::vector<ClientInfo>&, std::vector<ClientInfo>::const_iterator)>; |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 221 | bool findClientAndProcessLocked(const std::vector<TimeoutLength> timeouts, |
Lakshman Annadorai | d2de7f2 | 2020-11-17 16:27:22 -0800 | [diff] [blame] | 222 | const ClientInfo& clientInfo, const Processor& processor); |
| 223 | bool findClientAndProcessLocked(const std::vector<TimeoutLength> timeouts, |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 224 | const android::sp<android::IBinder> binder, |
| 225 | const Processor& processor); |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 226 | |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 227 | private: |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 228 | android::sp<Looper> mHandlerLooper; |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 229 | android::sp<MessageHandlerImpl> mMessageHandler; |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 230 | android::Mutex mMutex; |
Eric Jeong | 453287e | 2020-02-07 16:44:11 -0800 | [diff] [blame] | 231 | std::unordered_map<TimeoutLength, std::vector<ClientInfo>> mClients GUARDED_BY(mMutex); |
Eric Jeong | 27a178f | 2020-03-24 16:39:39 -0700 | [diff] [blame] | 232 | std::unordered_map<TimeoutLength, PingedClientMap> mPingedClients GUARDED_BY(mMutex); |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 233 | std::unordered_set<userid_t> mStoppedUserIds GUARDED_BY(mMutex); |
Lakshman Annadorai | 967b21e | 2020-10-30 09:35:29 -0700 | [diff] [blame] | 234 | android::sp<android::automotive::watchdog::internal::ICarWatchdogMonitor> mMonitor |
| 235 | GUARDED_BY(mMutex); |
Lakshman Annadorai | 0a0a787 | 2021-06-08 14:55:26 -0700 | [diff] [blame] | 236 | bool mIsEnabled GUARDED_BY(mMutex); |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 237 | // mLastSessionId is accessed only within main thread. No need for mutual-exclusion. |
| 238 | int32_t mLastSessionId; |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 239 | bool mServiceStarted; |
| 240 | android::sp<android::hardware::automotive::vehicle::V2_0::IVehicle> mVhalService |
| 241 | GUARDED_BY(mMutex); |
| 242 | android::sp<BinderDeathRecipient> mBinderDeathRecipient; |
| 243 | android::sp<HidlDeathRecipient> mHidlDeathRecipient; |
| 244 | std::unordered_set<android::hardware::automotive::vehicle::V2_0::VehicleProperty> |
| 245 | mNotSupportedVhalProperties; |
Eric Jeong | 2ac089c | 2020-08-27 17:50:38 -0700 | [diff] [blame] | 246 | android::sp<PropertyChangeListener> mPropertyChangeListener; |
| 247 | HeartBeat mVhalHeartBeat GUARDED_BY(mMutex); |
Eric Jeong | 6ff82ef | 2021-10-20 22:23:14 -0700 | [diff] [blame^] | 248 | std::chrono::milliseconds mVhalHealthCheckWindowMs; |
Lakshman Annadorai | ec4d08a | 2021-04-30 08:29:10 -0700 | [diff] [blame] | 249 | android::sp<IWatchdogServiceHelper> mWatchdogServiceHelper GUARDED_BY(mMutex); |
Eric Jeong | 34edd98 | 2019-12-17 17:26:35 -0800 | [diff] [blame] | 250 | }; |
| 251 | |
| 252 | } // namespace watchdog |
| 253 | } // namespace automotive |
| 254 | } // namespace android |
| 255 | |
Eric Jeong | 3a4b635 | 2020-08-18 18:06:53 -0700 | [diff] [blame] | 256 | #endif // CPP_WATCHDOG_SERVER_SRC_WATCHDOGPROCESSSERVICE_H_ |