1 /*
2  * Copyright (C) 2010 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 
17 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wconversion"
20 
21 #include <sys/resource.h>
22 
23 #include <sched.h>
24 
25 #include <android/frameworks/displayservice/1.0/IDisplayService.h>
26 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
27 #include <android/hardware/graphics/allocator/2.0/IAllocator.h>
28 #include <android/hardware/graphics/allocator/3.0/IAllocator.h>
29 #include <binder/IPCThreadState.h>
30 #include <binder/IServiceManager.h>
31 #include <binder/ProcessState.h>
32 #include <common/FlagManager.h>
33 #include <configstore/Utils.h>
34 #include <displayservice/DisplayService.h>
35 #include <errno.h>
36 #include <hidl/LegacySupport.h>
37 #include <processgroup/sched_policy.h>
38 #include "SurfaceFlinger.h"
39 #include "SurfaceFlingerFactory.h"
40 #include "SurfaceFlingerProperties.h"
41 
42 using namespace android;
43 
startGraphicsAllocatorService()44 static status_t startGraphicsAllocatorService() {
45     using android::hardware::configstore::getBool;
46     using android::hardware::configstore::V1_0::ISurfaceFlingerConfigs;
47     if (!android::sysprop::start_graphics_allocator_service(false)) {
48         return OK;
49     }
50 
51     status_t result = hardware::registerPassthroughServiceImplementation<
52             android::hardware::graphics::allocator::V3_0::IAllocator>();
53     if (result == OK) {
54         return OK;
55     }
56 
57     result = hardware::registerPassthroughServiceImplementation<
58             android::hardware::graphics::allocator::V2_0::IAllocator>();
59     if (result != OK) {
60         ALOGE("could not start graphics allocator service");
61         return result;
62     }
63 
64     return OK;
65 }
66 
startDisplayService()67 static void startDisplayService() {
68     using android::frameworks::displayservice::V1_0::implementation::DisplayService;
69     using android::frameworks::displayservice::V1_0::IDisplayService;
70 
71     sp<IDisplayService> displayservice = sp<DisplayService>::make();
72     status_t err = displayservice->registerAsService();
73 
74     // b/141930622
75     if (err != OK) {
76         ALOGE("Did not register (deprecated) IDisplayService service.");
77     }
78 }
79 
main(int,char **)80 int main(int, char**) {
81     signal(SIGPIPE, SIG_IGN);
82 
83     hardware::configureRpcThreadpool(1 /* maxThreads */,
84             false /* callerWillJoin */);
85 
86     startGraphicsAllocatorService();
87 
88     // When SF is launched in its own process, limit the number of
89     // binder threads to 4.
90     ProcessState::self()->setThreadPoolMaxThreadCount(4);
91 
92     // Set uclamp.min setting on all threads, maybe an overkill but we want
93     // to cover important threads like RenderEngine.
94     if (SurfaceFlinger::setSchedAttr(true) != NO_ERROR) {
95         ALOGW("Failed to set uclamp.min during boot: %s", strerror(errno));
96     }
97 
98     // The binder threadpool we start will inherit sched policy and priority
99     // of (this) creating thread. We want the binder thread pool to have
100     // SCHED_FIFO policy and priority 1 (lowest RT priority)
101     // Once the pool is created we reset this thread's priority back to
102     // original.
103     int newPriority = 0;
104     int origPolicy = sched_getscheduler(0);
105     struct sched_param origSchedParam;
106 
107     int errorInPriorityModification = sched_getparam(0, &origSchedParam);
108     if (errorInPriorityModification == 0) {
109         int policy = SCHED_FIFO;
110         newPriority = sched_get_priority_min(policy);
111 
112         struct sched_param param;
113         param.sched_priority = newPriority;
114 
115         errorInPriorityModification = sched_setscheduler(0, policy, &param);
116     }
117 
118     // start the thread pool
119     sp<ProcessState> ps(ProcessState::self());
120     ps->startThreadPool();
121 
122     // Reset current thread's policy and priority
123     if (errorInPriorityModification == 0) {
124         errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
125     } else {
126         ALOGE("Failed to set SurfaceFlinger binder threadpool priority to SCHED_FIFO");
127     }
128 
129     // instantiate surfaceflinger
130     sp<SurfaceFlinger> flinger = surfaceflinger::createSurfaceFlinger();
131 
132     // Set the minimum policy of surfaceflinger node to be SCHED_FIFO.
133     // So any thread with policy/priority lower than {SCHED_FIFO, 1}, will run
134     // at least with SCHED_FIFO policy and priority 1.
135     if (errorInPriorityModification == 0) {
136         flinger->setMinSchedulerPolicy(SCHED_FIFO, newPriority);
137     }
138 
139     setpriority(PRIO_PROCESS, 0, PRIORITY_URGENT_DISPLAY);
140 
141     set_sched_policy(0, SP_FOREGROUND);
142 
143     // initialize before clients can connect
144     flinger->init();
145 
146     // publish surface flinger
147     sp<IServiceManager> sm(defaultServiceManager());
148     sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false,
149                    IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL | IServiceManager::DUMP_FLAG_PROTO);
150 
151     // publish gui::ISurfaceComposer, the new AIDL interface
152     sp<SurfaceComposerAIDL> composerAIDL = sp<SurfaceComposerAIDL>::make(flinger);
153     if (FlagManager::getInstance().misc1()) {
154         composerAIDL->setMinSchedulerPolicy(SCHED_FIFO, newPriority);
155     }
156     sm->addService(String16("SurfaceFlingerAIDL"), composerAIDL, false,
157                    IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL | IServiceManager::DUMP_FLAG_PROTO);
158 
159     startDisplayService(); // dependency on SF getting registered above
160 
161     if (SurfaceFlinger::setSchedFifo(true) != NO_ERROR) {
162         ALOGW("Failed to set SCHED_FIFO during boot: %s", strerror(errno));
163     }
164 
165     // run surface flinger in this thread
166     flinger->run();
167 
168     return 0;
169 }
170 
171 // TODO(b/129481165): remove the #pragma below and fix conversion issues
172 #pragma clang diagnostic pop // ignored "-Wconversion"
173