blob: 3fa548f78eb3a924f84202fc5e835c547e328e3d [file] [log] [blame]
Mark Salyzyn12717162014-04-29 15:49:14 -07001/*
San Mehat493dad92009-09-12 10:06:57 -07002** Copyright 2007, The Android Open Source Project
3**
Tim Murrayb769c8d2015-06-08 14:56:29 -07004** 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
San Mehat493dad92009-09-12 10:06:57 -07007**
Tim Murrayb769c8d2015-06-08 14:56:29 -07008** http://www.apache.org/licenses/LICENSE-2.0
San Mehat493dad92009-09-12 10:06:57 -07009**
Tim Murrayb769c8d2015-06-08 14:56:29 -070010** 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
San Mehat493dad92009-09-12 10:06:57 -070014** limitations under the License.
15*/
16
Elliott Hughes8e9aeb92017-11-10 10:22:07 -080017#include <cutils/sched_policy.h>
18
Jeff Brownbff8f3f2012-05-08 15:05:42 -070019#define LOG_TAG "SchedPolicy"
20
San Mehat493dad92009-09-12 10:06:57 -070021#include <errno.h>
22#include <fcntl.h>
Mark Salyzyn12717162014-04-29 15:49:14 -070023#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <unistd.h>
27
Elliott Hughes9f495082018-04-25 14:52:50 -070028#include <android-base/macros.h>
Mark Salyzyncfd5b082016-10-17 14:28:00 -070029#include <log/log.h>
Mark Salyzyn12717162014-04-29 15:49:14 -070030
Jeff Brownbff8f3f2012-05-08 15:05:42 -070031/* Re-map SP_DEFAULT to the system default policy, and leave other values unchanged.
32 * Call this any place a SchedPolicy is used as an input parameter.
33 * Returns the possibly re-mapped policy.
34 */
35static inline SchedPolicy _policy(SchedPolicy p)
36{
37 return p == SP_DEFAULT ? SP_SYSTEM_DEFAULT : p;
38}
San Mehatd2e4e462009-10-29 11:48:00 -070039
Elliott Hughes9b828ad2015-07-30 08:47:35 -070040#if defined(__ANDROID__)
Raphael0384a982009-09-15 17:10:17 -070041
Brad Fitzpatrick86b12152010-05-08 11:51:13 -070042#include <pthread.h>
Elliott Hughese07d77e2014-07-11 20:57:03 -070043#include <sched.h>
44#include <sys/prctl.h>
San Mehat3cd5b662009-09-14 16:05:24 -070045
San Mehat805d67a2009-10-29 13:56:26 -070046#define POLICY_DEBUG 0
San Mehatd2e4e462009-10-29 11:48:00 -070047
Ruchi Kandoi422852e2014-04-22 18:55:08 -070048// timer slack value in nS enforced when the thread moves to background
49#define TIMER_SLACK_BG 40000000
Todd Kjos4cdce422015-06-25 13:08:14 -070050#define TIMER_SLACK_FG 50000
Ruchi Kandoi422852e2014-04-22 18:55:08 -070051
Brad Fitzpatricke43c2482010-05-07 12:06:05 -070052static pthread_once_t the_once = PTHREAD_ONCE_INIT;
53
John Reck2e336b12016-08-26 13:43:19 -070054static int __sys_supports_timerslack = -1;
San Mehatc0dfca72009-10-27 11:52:55 -070055
Tim Murrayb769c8d2015-06-08 14:56:29 -070056// File descriptors open to /dev/cpuset/../tasks, setup by initialize, or -1 on error
Tim Murray4284f9f2015-11-10 14:31:09 -080057static int system_bg_cpuset_fd = -1;
Tim Murrayb769c8d2015-06-08 14:56:29 -070058static int bg_cpuset_fd = -1;
59static int fg_cpuset_fd = -1;
Tim Murray6647bb52016-01-11 16:16:35 -080060static int ta_cpuset_fd = -1; // special cpuset for top app
Tim Murray419ba9e2018-04-13 10:15:49 -070061static int rs_cpuset_fd = -1; // special cpuset for screen off restrictions
Tim Murrayaa45cb82016-07-08 15:47:11 -070062
63// File descriptors open to /dev/stune/../tasks, setup by initialize, or -1 on error
Todd Kjosba8a4752015-10-26 16:22:11 -070064static int bg_schedboost_fd = -1;
65static int fg_schedboost_fd = -1;
Tim Murray955694b2016-07-11 11:40:15 -070066static int ta_schedboost_fd = -1;
Joel Fernandes88ef9f02017-03-25 22:46:10 -070067static int rt_schedboost_fd = -1;
Tim Murrayb769c8d2015-06-08 14:56:29 -070068
Brad Fitzpatricke43c2482010-05-07 12:06:05 -070069/* Add tid to the scheduling group defined by the policy */
Tim Murrayb769c8d2015-06-08 14:56:29 -070070static int add_tid_to_cgroup(int tid, int fd)
San Mehat493dad92009-09-12 10:06:57 -070071{
Brad Fitzpatricke43c2482010-05-07 12:06:05 -070072 if (fd < 0) {
Tim Murrayb769c8d2015-06-08 14:56:29 -070073 SLOGE("add_tid_to_cgroup failed; fd=%d\n", fd);
74 errno = EINVAL;
San Mehat493dad92009-09-12 10:06:57 -070075 return -1;
San Mehat805d67a2009-10-29 13:56:26 -070076 }
San Mehat493dad92009-09-12 10:06:57 -070077
Brad Fitzpatrick253e27a2010-05-06 10:00:37 -070078 // specialized itoa -- works for tid > 0
79 char text[22];
80 char *end = text + sizeof(text) - 1;
81 char *ptr = end;
82 *ptr = '\0';
83 while (tid > 0) {
84 *--ptr = '0' + (tid % 10);
85 tid = tid / 10;
86 }
87
88 if (write(fd, ptr, end - ptr) < 0) {
Brad Fitzpatricke43c2482010-05-07 12:06:05 -070089 /*
90 * If the thread is in the process of exiting,
91 * don't flag an error
92 */
93 if (errno == ESRCH)
94 return 0;
Tim Murrayb769c8d2015-06-08 14:56:29 -070095 SLOGW("add_tid_to_cgroup failed to write '%s' (%s); fd=%d\n",
96 ptr, strerror(errno), fd);
97 errno = EINVAL;
San Mehat493dad92009-09-12 10:06:57 -070098 return -1;
99 }
100
San Mehat493dad92009-09-12 10:06:57 -0700101 return 0;
102}
103
Isaac Chen795267d2017-02-16 11:47:33 +0800104/*
105 If CONFIG_CPUSETS for Linux kernel is set, "tasks" can be found under
106 /dev/cpuset mounted in init.rc; otherwise, that file does not exist
107 even though the directory, /dev/cpuset, is still created (by init.rc).
108
109 A couple of other candidates (under cpuset mount directory):
110 notify_on_release
111 release_agent
112
113 Yet another way to decide if cpuset is enabled is to parse
114 /proc/self/status and search for lines begin with "Mems_allowed".
115
116 If CONFIG_PROC_PID_CPUSET is set, the existence "/proc/self/cpuset" can
117 be used to decide if CONFIG_CPUSETS is set, so we don't have a dependency
118 on where init.rc mounts cpuset. That's why we'd better require this
119 configuration be set if CONFIG_CPUSETS is set.
120
Elliott Hughes76a934a2017-06-28 07:50:00 -0700121 In older releases, this was controlled by build-time configuration.
Isaac Chen795267d2017-02-16 11:47:33 +0800122 */
Isaac Chen795267d2017-02-16 11:47:33 +0800123bool cpusets_enabled() {
124 static bool enabled = (access("/dev/cpuset/tasks", F_OK) == 0);
125
126 return enabled;
127}
128
129/*
130 Similar to CONFIG_CPUSETS above, but with a different configuration
Alex Naidis2d998ea2017-06-10 22:34:23 +0200131 CONFIG_CGROUP_SCHEDTUNE that's in Android common Linux kernel and Linaro
Isaac Chen795267d2017-02-16 11:47:33 +0800132 Stable Kernel (LSK), but not in mainline Linux as of v4.9.
133
Elliott Hughes5dc77362017-06-29 08:52:49 -0700134 In older releases, this was controlled by build-time configuration.
Isaac Chen795267d2017-02-16 11:47:33 +0800135 */
Isaac Chen795267d2017-02-16 11:47:33 +0800136bool schedboost_enabled() {
137 static bool enabled = (access("/dev/stune/tasks", F_OK) == 0);
138
139 return enabled;
140}
141
142static void __initialize() {
143 const char* filename;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700144
Isaac Chen795267d2017-02-16 11:47:33 +0800145 if (cpusets_enabled()) {
146 if (!access("/dev/cpuset/tasks", W_OK)) {
Tim Murrayb769c8d2015-06-08 14:56:29 -0700147
Isaac Chen795267d2017-02-16 11:47:33 +0800148 filename = "/dev/cpuset/foreground/tasks";
149 fg_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
150 filename = "/dev/cpuset/background/tasks";
151 bg_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
152 filename = "/dev/cpuset/system-background/tasks";
153 system_bg_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
154 filename = "/dev/cpuset/top-app/tasks";
155 ta_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
Tim Murray419ba9e2018-04-13 10:15:49 -0700156 filename = "/dev/cpuset/restricted/tasks";
157 rs_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
Tim Murray4284f9f2015-11-10 14:31:09 -0800158
Isaac Chen795267d2017-02-16 11:47:33 +0800159 if (schedboost_enabled()) {
160 filename = "/dev/stune/top-app/tasks";
161 ta_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
162 filename = "/dev/stune/foreground/tasks";
163 fg_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
164 filename = "/dev/stune/background/tasks";
165 bg_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
Joel Fernandes88ef9f02017-03-25 22:46:10 -0700166 filename = "/dev/stune/rt/tasks";
167 rt_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
Isaac Chen795267d2017-02-16 11:47:33 +0800168 }
169 }
Tim Murrayb769c8d2015-06-08 14:56:29 -0700170 }
John Reck2e336b12016-08-26 13:43:19 -0700171
172 char buf[64];
173 snprintf(buf, sizeof(buf), "/proc/%d/timerslack_ns", getpid());
174 __sys_supports_timerslack = !access(buf, W_OK);
San Mehatc0dfca72009-10-27 11:52:55 -0700175}
176
177/*
Martijn Coenen7b173a12016-04-04 17:11:56 +0200178 * Returns the path under the requested cgroup subsystem (if it exists)
San Mehatc0dfca72009-10-27 11:52:55 -0700179 *
San Mehat503df202010-03-02 17:09:56 -0800180 * The data from /proc/<pid>/cgroup looks (something) like:
San Mehatc0dfca72009-10-27 11:52:55 -0700181 * 2:cpu:/bg_non_interactive
San Mehat503df202010-03-02 17:09:56 -0800182 * 1:cpuacct:/
San Mehatc0dfca72009-10-27 11:52:55 -0700183 *
184 * We return the part after the "/", which will be an empty string for
185 * the default cgroup. If the string is longer than "bufLen", the string
186 * will be truncated.
187 */
Martijn Coenen7b173a12016-04-04 17:11:56 +0200188static int getCGroupSubsys(int tid, const char* subsys, char* buf, size_t bufLen)
San Mehatc0dfca72009-10-27 11:52:55 -0700189{
Elliott Hughes9b828ad2015-07-30 08:47:35 -0700190#if defined(__ANDROID__)
San Mehatc0dfca72009-10-27 11:52:55 -0700191 char pathBuf[32];
San Mehat503df202010-03-02 17:09:56 -0800192 char lineBuf[256];
193 FILE *fp;
San Mehatc0dfca72009-10-27 11:52:55 -0700194
195 snprintf(pathBuf, sizeof(pathBuf), "/proc/%d/cgroup", tid);
John Stultz2f13f0a2016-07-01 17:45:06 -0700196 if (!(fp = fopen(pathBuf, "re"))) {
San Mehatc0dfca72009-10-27 11:52:55 -0700197 return -1;
198 }
199
San Mehat503df202010-03-02 17:09:56 -0800200 while(fgets(lineBuf, sizeof(lineBuf) -1, fp)) {
201 char *next = lineBuf;
Martijn Coenen7b173a12016-04-04 17:11:56 +0200202 char *found_subsys;
San Mehat503df202010-03-02 17:09:56 -0800203 char *grp;
204 size_t len;
San Mehatc0dfca72009-10-27 11:52:55 -0700205
San Mehat503df202010-03-02 17:09:56 -0800206 /* Junk the first field */
207 if (!strsep(&next, ":")) {
208 goto out_bad_data;
209 }
San Mehatc0dfca72009-10-27 11:52:55 -0700210
Martijn Coenen7b173a12016-04-04 17:11:56 +0200211 if (!(found_subsys = strsep(&next, ":"))) {
San Mehat503df202010-03-02 17:09:56 -0800212 goto out_bad_data;
213 }
214
Martijn Coenen7b173a12016-04-04 17:11:56 +0200215 if (strcmp(found_subsys, subsys)) {
San Mehat503df202010-03-02 17:09:56 -0800216 /* Not the subsys we're looking for */
217 continue;
218 }
219
220 if (!(grp = strsep(&next, ":"))) {
221 goto out_bad_data;
222 }
223 grp++; /* Drop the leading '/' */
224 len = strlen(grp);
225 grp[len-1] = '\0'; /* Drop the trailing '\n' */
226
227 if (bufLen <= len) {
228 len = bufLen - 1;
229 }
230 strncpy(buf, grp, len);
231 buf[len] = '\0';
232 fclose(fp);
233 return 0;
San Mehatc0dfca72009-10-27 11:52:55 -0700234 }
235
Martijn Coenen7b173a12016-04-04 17:11:56 +0200236 SLOGE("Failed to find subsys %s", subsys);
San Mehat503df202010-03-02 17:09:56 -0800237 fclose(fp);
238 return -1;
239 out_bad_data:
San Mehat7e8529a2010-03-25 09:31:42 -0700240 SLOGE("Bad cgroup data {%s}", lineBuf);
San Mehat503df202010-03-02 17:09:56 -0800241 fclose(fp);
242 return -1;
San Mehatc0dfca72009-10-27 11:52:55 -0700243#else
244 errno = ENOSYS;
245 return -1;
246#endif
247}
248
249int get_sched_policy(int tid, SchedPolicy *policy)
250{
Glenn Kasten69bfb1f2012-03-16 09:43:19 -0700251 if (tid == 0) {
252 tid = gettid();
253 }
Brad Fitzpatricke43c2482010-05-07 12:06:05 -0700254 pthread_once(&the_once, __initialize);
San Mehatc0dfca72009-10-27 11:52:55 -0700255
Wei Wang40267982017-03-25 09:53:31 -0700256 char grpBuf[32];
Isaac Chen795267d2017-02-16 11:47:33 +0800257
Erik Staatsb4c46542017-04-24 14:49:28 -0700258 grpBuf[0] = '\0';
259 if (schedboost_enabled()) {
260 if (getCGroupSubsys(tid, "schedtune", grpBuf, sizeof(grpBuf)) < 0) return -1;
261 }
262 if ((grpBuf[0] == '\0') && cpusets_enabled()) {
Wei Wang40267982017-03-25 09:53:31 -0700263 if (getCGroupSubsys(tid, "cpuset", grpBuf, sizeof(grpBuf)) < 0) return -1;
Erik Staatsb4c46542017-04-24 14:49:28 -0700264 }
265 if (grpBuf[0] == '\0') {
Wei Wanga8d59fa2017-03-28 11:13:51 -0700266 *policy = SP_FOREGROUND;
Erik Staatsb4c46542017-04-24 14:49:28 -0700267 } else if (!strcmp(grpBuf, "foreground")) {
268 *policy = SP_FOREGROUND;
269 } else if (!strcmp(grpBuf, "system-background")) {
270 *policy = SP_SYSTEM;
271 } else if (!strcmp(grpBuf, "background")) {
272 *policy = SP_BACKGROUND;
273 } else if (!strcmp(grpBuf, "top-app")) {
274 *policy = SP_TOP_APP;
275 } else {
276 errno = ERANGE;
277 return -1;
San Mehatc0dfca72009-10-27 11:52:55 -0700278 }
279 return 0;
280}
281
Tim Murrayb769c8d2015-06-08 14:56:29 -0700282int set_cpuset_policy(int tid, SchedPolicy policy)
283{
284 // in the absence of cpusets, use the old sched policy
Isaac Chen795267d2017-02-16 11:47:33 +0800285 if (!cpusets_enabled()) {
286 return set_sched_policy(tid, policy);
287 }
288
Tim Murrayb769c8d2015-06-08 14:56:29 -0700289 if (tid == 0) {
290 tid = gettid();
291 }
292 policy = _policy(policy);
293 pthread_once(&the_once, __initialize);
294
Tim Murrayb43225e2015-11-18 16:42:44 -0800295 int fd = -1;
296 int boost_fd = -1;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700297 switch (policy) {
298 case SP_BACKGROUND:
299 fd = bg_cpuset_fd;
Todd Kjosba8a4752015-10-26 16:22:11 -0700300 boost_fd = bg_schedboost_fd;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700301 break;
302 case SP_FOREGROUND:
303 case SP_AUDIO_APP:
304 case SP_AUDIO_SYS:
305 fd = fg_cpuset_fd;
Tim Murray955694b2016-07-11 11:40:15 -0700306 boost_fd = fg_schedboost_fd;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700307 break;
Tim Murray6647bb52016-01-11 16:16:35 -0800308 case SP_TOP_APP :
309 fd = ta_cpuset_fd;
Tim Murray955694b2016-07-11 11:40:15 -0700310 boost_fd = ta_schedboost_fd;
Tim Murray6647bb52016-01-11 16:16:35 -0800311 break;
Tim Murray4284f9f2015-11-10 14:31:09 -0800312 case SP_SYSTEM:
313 fd = system_bg_cpuset_fd;
Tim Murray4284f9f2015-11-10 14:31:09 -0800314 break;
Tim Murray419ba9e2018-04-13 10:15:49 -0700315 case SP_RESTRICTED:
316 fd = rs_cpuset_fd;
317 break;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700318 default:
Todd Kjosba8a4752015-10-26 16:22:11 -0700319 boost_fd = fd = -1;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700320 break;
321 }
322
323 if (add_tid_to_cgroup(tid, fd) != 0) {
324 if (errno != ESRCH && errno != ENOENT)
325 return -errno;
326 }
327
Isaac Chen795267d2017-02-16 11:47:33 +0800328 if (schedboost_enabled()) {
329 if (boost_fd > 0 && add_tid_to_cgroup(tid, boost_fd) != 0) {
330 if (errno != ESRCH && errno != ENOENT)
331 return -errno;
332 }
Todd Kjosba8a4752015-10-26 16:22:11 -0700333 }
334
Tim Murray99910262015-06-22 14:00:56 -0700335 return 0;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700336}
337
Stephen Cranef5b8e342017-06-06 15:35:51 -0700338static void set_timerslack_ns(int tid, unsigned long slack) {
Elliott Hughesd7967c12016-08-03 15:11:01 -0700339 // v4.6+ kernels support the /proc/<tid>/timerslack_ns interface.
340 // TODO: once we've backported this, log if the open(2) fails.
Erik Staatsd32331f2017-04-26 15:15:55 -0700341 if (__sys_supports_timerslack) {
342 char buf[64];
343 snprintf(buf, sizeof(buf), "/proc/%d/timerslack_ns", tid);
344 int fd = open(buf, O_WRONLY | O_CLOEXEC);
345 if (fd != -1) {
Stephen Cranef5b8e342017-06-06 15:35:51 -0700346 int len = snprintf(buf, sizeof(buf), "%lu", slack);
Erik Staatsd32331f2017-04-26 15:15:55 -0700347 if (write(fd, buf, len) != len) {
348 SLOGE("set_timerslack_ns write failed: %s\n", strerror(errno));
349 }
350 close(fd);
351 return;
John Stultz2f13f0a2016-07-01 17:45:06 -0700352 }
Erik Staatsd32331f2017-04-26 15:15:55 -0700353 }
354
355 // TODO: Remove when /proc/<tid>/timerslack_ns interface is backported.
356 if ((tid == 0) || (tid == gettid())) {
357 if (prctl(PR_SET_TIMERSLACK, slack) == -1) {
358 SLOGE("set_timerslack_ns prctl failed: %s\n", strerror(errno));
359 }
John Stultz2f13f0a2016-07-01 17:45:06 -0700360 }
John Stultz2f13f0a2016-07-01 17:45:06 -0700361}
362
San Mehatc0dfca72009-10-27 11:52:55 -0700363int set_sched_policy(int tid, SchedPolicy policy)
364{
Glenn Kasten69bfb1f2012-03-16 09:43:19 -0700365 if (tid == 0) {
366 tid = gettid();
367 }
Glenn Kasten69bfb1f2012-03-16 09:43:19 -0700368 policy = _policy(policy);
Brad Fitzpatricke43c2482010-05-07 12:06:05 -0700369 pthread_once(&the_once, __initialize);
San Mehat493dad92009-09-12 10:06:57 -0700370
San Mehatd2e4e462009-10-29 11:48:00 -0700371#if POLICY_DEBUG
372 char statfile[64];
373 char statline[1024];
374 char thread_name[255];
San Mehatd2e4e462009-10-29 11:48:00 -0700375
Raja Ma2f37e42016-04-19 23:55:14 +0530376 snprintf(statfile, sizeof(statfile), "/proc/%d/stat", tid);
San Mehatd2e4e462009-10-29 11:48:00 -0700377 memset(thread_name, 0, sizeof(thread_name));
378
John Stultz2f13f0a2016-07-01 17:45:06 -0700379 int fd = open(statfile, O_RDONLY | O_CLOEXEC);
San Mehatd2e4e462009-10-29 11:48:00 -0700380 if (fd >= 0) {
381 int rc = read(fd, statline, 1023);
382 close(fd);
383 statline[rc] = 0;
384 char *p = statline;
385 char *q;
386
387 for (p = statline; *p != '('; p++);
388 p++;
389 for (q = p; *q != ')'; q++);
390
391 strncpy(thread_name, p, (q-p));
392 }
Glenn Kasten10ec3c72012-04-19 15:25:58 -0700393 switch (policy) {
394 case SP_BACKGROUND:
San Mehat7e8529a2010-03-25 09:31:42 -0700395 SLOGD("vvv tid %d (%s)", tid, thread_name);
Glenn Kasten10ec3c72012-04-19 15:25:58 -0700396 break;
397 case SP_FOREGROUND:
Dima Zavin29319a62012-06-04 13:14:36 -0700398 case SP_AUDIO_APP:
399 case SP_AUDIO_SYS:
Tim Murray6647bb52016-01-11 16:16:35 -0800400 case SP_TOP_APP:
San Mehat7e8529a2010-03-25 09:31:42 -0700401 SLOGD("^^^ tid %d (%s)", tid, thread_name);
Glenn Kasten10ec3c72012-04-19 15:25:58 -0700402 break;
403 case SP_SYSTEM:
404 SLOGD("/// tid %d (%s)", tid, thread_name);
405 break;
Joel Fernandes88ef9f02017-03-25 22:46:10 -0700406 case SP_RT_APP:
407 SLOGD("RT tid %d (%s)", tid, thread_name);
408 break;
Glenn Kasten10ec3c72012-04-19 15:25:58 -0700409 default:
San Mehat7e8529a2010-03-25 09:31:42 -0700410 SLOGD("??? tid %d (%s)", tid, thread_name);
Glenn Kasten10ec3c72012-04-19 15:25:58 -0700411 break;
San Mehatd2e4e462009-10-29 11:48:00 -0700412 }
413#endif
414
Wei Wang40267982017-03-25 09:53:31 -0700415 if (schedboost_enabled()) {
Tim Murrayaa45cb82016-07-08 15:47:11 -0700416 int boost_fd = -1;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700417 switch (policy) {
418 case SP_BACKGROUND:
Tim Murrayaa45cb82016-07-08 15:47:11 -0700419 boost_fd = bg_schedboost_fd;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700420 break;
421 case SP_FOREGROUND:
422 case SP_AUDIO_APP:
423 case SP_AUDIO_SYS:
Tim Murray955694b2016-07-11 11:40:15 -0700424 boost_fd = fg_schedboost_fd;
Tim Murrayaa45cb82016-07-08 15:47:11 -0700425 break;
Tim Murray6647bb52016-01-11 16:16:35 -0800426 case SP_TOP_APP:
Tim Murray955694b2016-07-11 11:40:15 -0700427 boost_fd = ta_schedboost_fd;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700428 break;
Joel Fernandes88ef9f02017-03-25 22:46:10 -0700429 case SP_RT_APP:
430 boost_fd = rt_schedboost_fd;
431 break;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700432 default:
Tim Murrayaa45cb82016-07-08 15:47:11 -0700433 boost_fd = -1;
Tim Murrayb769c8d2015-06-08 14:56:29 -0700434 break;
435 }
436
Wei Wang40267982017-03-25 09:53:31 -0700437 if (boost_fd > 0 && add_tid_to_cgroup(tid, boost_fd) != 0) {
San Mehat493dad92009-09-12 10:06:57 -0700438 if (errno != ESRCH && errno != ENOENT)
439 return -errno;
440 }
Tim Murrayaa45cb82016-07-08 15:47:11 -0700441
San Mehat493dad92009-09-12 10:06:57 -0700442 }
443
Erik Staatsd32331f2017-04-26 15:15:55 -0700444 set_timerslack_ns(tid, policy == SP_BACKGROUND ? TIMER_SLACK_BG : TIMER_SLACK_FG);
Ruchi Kandoi422852e2014-04-22 18:55:08 -0700445
San Mehat493dad92009-09-12 10:06:57 -0700446 return 0;
447}
Raphael0384a982009-09-15 17:10:17 -0700448
Jeff Brownbff8f3f2012-05-08 15:05:42 -0700449#else
450
451/* Stubs for non-Android targets. */
452
Elliott Hughes38d25672017-11-30 16:23:51 -0800453int set_sched_policy(int /*tid*/, SchedPolicy /*policy*/) {
Jeff Brownbff8f3f2012-05-08 15:05:42 -0700454 return 0;
455}
456
Elliott Hughes38d25672017-11-30 16:23:51 -0800457int get_sched_policy(int /*tid*/, SchedPolicy* policy) {
Jeff Brownbff8f3f2012-05-08 15:05:42 -0700458 *policy = SP_SYSTEM_DEFAULT;
459 return 0;
460}
461
462#endif
463
Elliott Hughes9f495082018-04-25 14:52:50 -0700464const char* get_sched_policy_name(SchedPolicy policy) {
Glenn Kasten69bfb1f2012-03-16 09:43:19 -0700465 policy = _policy(policy);
Elliott Hughes9f495082018-04-25 14:52:50 -0700466 static const char* const kSchedPolicyNames[] = {
Tim Murray419ba9e2018-04-13 10:15:49 -0700467 [SP_BACKGROUND] = "bg", [SP_FOREGROUND] = "fg", [SP_SYSTEM] = " ",
468 [SP_AUDIO_APP] = "aa", [SP_AUDIO_SYS] = "as", [SP_TOP_APP] = "ta",
469 [SP_RT_APP] = "rt", [SP_RESTRICTED] = "rs",
Glenn Kasten86c7cc82012-03-05 16:14:39 -0800470 };
Elliott Hughes9f495082018-04-25 14:52:50 -0700471 static_assert(arraysize(kSchedPolicyNames) == SP_CNT, "missing name");
472 if (policy < SP_BACKGROUND || policy >= SP_CNT) {
Glenn Kasten86c7cc82012-03-05 16:14:39 -0800473 return "error";
Elliott Hughes9f495082018-04-25 14:52:50 -0700474 }
475 return kSchedPolicyNames[policy];
Glenn Kasten86c7cc82012-03-05 16:14:39 -0800476}