/* * Copyright (C) 2022 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.car.os; import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.DUMP_INFO; import android.car.Car; import android.car.builtin.util.Slogf; import android.car.os.ICarPerformanceService; import android.car.os.ThreadPolicyWithPriority; import android.content.Context; import android.os.Binder; import android.os.RemoteException; import android.util.Log; import android.util.proto.ProtoOutputStream; import com.android.car.CarLocalServices; import com.android.car.CarLog; import com.android.car.CarServiceBase; import com.android.car.CarServiceUtils; import com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport; import com.android.car.internal.util.IndentingPrintWriter; import com.android.car.watchdog.CarWatchdogService; /** * Service to implement CarPerformanceManager API. */ public final class CarPerformanceService extends ICarPerformanceService.Stub implements CarServiceBase { static final String TAG = CarLog.tagFor(CarPerformanceService.class); private static final boolean DEBUG = Slogf.isLoggable(TAG, Log.DEBUG); private CarWatchdogService mCarWatchdogService; private final Context mContext; public CarPerformanceService(Context context) { mContext = context; } @Override public void init() { mCarWatchdogService = CarLocalServices.getService(CarWatchdogService.class); if (DEBUG) { Slogf.d(TAG, "CarPerformanceService is initialized"); } } @Override public void release() {} @Override @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO) public void dump(IndentingPrintWriter writer) { writer.printf("*%s*\n", getClass().getSimpleName()); writer.increaseIndent(); writer.printf("DEBUG=%s", DEBUG); writer.decreaseIndent(); } @Override @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO) public void dumpProto(ProtoOutputStream proto) {} /** * Sets the thread priority for a specific thread. * * The thread must belong to the calling process. * * @throws IllegalArgumentException If the given policy/priority is not valid. * @throws IllegalStateException If the provided tid does not belong to the calling process. * @throws RemoteException If binder error happens. * @throws SecurityException If permission check failed. * @throws ServiceSpecificException If the operation failed. * @throws UnsupportedOperationException If the current android release doesn't support the API. */ @Override public void setThreadPriority(int tid, ThreadPolicyWithPriority threadPolicyWithPriority) throws RemoteException { CarServiceUtils.assertPermission(mContext, Car.PERMISSION_MANAGE_THREAD_PRIORITY); int pid = Binder.getCallingPid(); int uid = Binder.getCallingUid(); mCarWatchdogService.setThreadPriority(pid, tid, uid, threadPolicyWithPriority.getPolicy(), threadPolicyWithPriority.getPriority()); } /** * Gets the thread scheduling policy and priority for the specified thread. * * The thread must belong to the calling process. * * @throws IllegalStateException If the operation failed or the provided tid does not belong to * the calling process. * @throws RemoteException If binder error happens. * @throws SecurityException If permission check failed. * @throws UnsupportedOperationException If the current android release doesn't support the API. */ @Override public ThreadPolicyWithPriority getThreadPriority(int tid) throws RemoteException { CarServiceUtils.assertPermission(mContext, Car.PERMISSION_MANAGE_THREAD_PRIORITY); int pid = Binder.getCallingPid(); int uid = Binder.getCallingUid(); try { int[] result = mCarWatchdogService.getThreadPriority(pid, tid, uid); return new ThreadPolicyWithPriority(result[0], result[1]); } catch (IllegalArgumentException e) { throw new IllegalStateException( "current scheduling policy doesn't support getting priority, cause: " + e.getCause(), e); } } }