341 lines
8.2 KiB
C
341 lines
8.2 KiB
C
/*
|
|
** Copyright 2007, 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.
|
|
*/
|
|
|
|
#define LOG_TAG "SchedPolicy"
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <cutils/sched_policy.h>
|
|
#include <log/log.h>
|
|
|
|
#define UNUSED __attribute__((__unused__))
|
|
|
|
/* Re-map SP_DEFAULT to the system default policy, and leave other values unchanged.
|
|
* Call this any place a SchedPolicy is used as an input parameter.
|
|
* Returns the possibly re-mapped policy.
|
|
*/
|
|
static inline SchedPolicy _policy(SchedPolicy p)
|
|
{
|
|
return p == SP_DEFAULT ? SP_SYSTEM_DEFAULT : p;
|
|
}
|
|
|
|
#if defined(__ANDROID__)
|
|
|
|
#include <pthread.h>
|
|
#include <sched.h>
|
|
#include <sys/prctl.h>
|
|
|
|
#define POLICY_DEBUG 0
|
|
|
|
// This prctl is only available in Android kernels.
|
|
#define PR_SET_TIMERSLACK_PID 41
|
|
|
|
// timer slack value in nS enforced when the thread moves to background
|
|
#define TIMER_SLACK_BG 40000000
|
|
|
|
static pthread_once_t the_once = PTHREAD_ONCE_INIT;
|
|
|
|
static int __sys_supports_schedgroups = -1;
|
|
|
|
// File descriptors open to /dev/cpuctl/../tasks, setup by initialize, or -1 on error.
|
|
static int bg_cgroup_fd = -1;
|
|
static int fg_cgroup_fd = -1;
|
|
|
|
/* Add tid to the scheduling group defined by the policy */
|
|
static int add_tid_to_cgroup(int tid, SchedPolicy policy)
|
|
{
|
|
int fd;
|
|
|
|
switch (policy) {
|
|
case SP_BACKGROUND:
|
|
fd = bg_cgroup_fd;
|
|
break;
|
|
case SP_FOREGROUND:
|
|
case SP_AUDIO_APP:
|
|
case SP_AUDIO_SYS:
|
|
fd = fg_cgroup_fd;
|
|
break;
|
|
default:
|
|
fd = -1;
|
|
break;
|
|
}
|
|
|
|
if (fd < 0) {
|
|
SLOGE("add_tid_to_cgroup failed; policy=%d\n", policy);
|
|
return -1;
|
|
}
|
|
|
|
// specialized itoa -- works for tid > 0
|
|
char text[22];
|
|
char *end = text + sizeof(text) - 1;
|
|
char *ptr = end;
|
|
*ptr = '\0';
|
|
while (tid > 0) {
|
|
*--ptr = '0' + (tid % 10);
|
|
tid = tid / 10;
|
|
}
|
|
|
|
if (write(fd, ptr, end - ptr) < 0) {
|
|
/*
|
|
* If the thread is in the process of exiting,
|
|
* don't flag an error
|
|
*/
|
|
if (errno == ESRCH)
|
|
return 0;
|
|
SLOGW("add_tid_to_cgroup failed to write '%s' (%s); policy=%d\n",
|
|
ptr, strerror(errno), policy);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __initialize(void) {
|
|
char* filename;
|
|
if (!access("/dev/cpuctl/tasks", F_OK)) {
|
|
__sys_supports_schedgroups = 1;
|
|
|
|
filename = "/dev/cpuctl/tasks";
|
|
fg_cgroup_fd = open(filename, O_WRONLY | O_CLOEXEC);
|
|
if (fg_cgroup_fd < 0) {
|
|
SLOGE("open of %s failed: %s\n", filename, strerror(errno));
|
|
}
|
|
|
|
filename = "/dev/cpuctl/bg_non_interactive/tasks";
|
|
bg_cgroup_fd = open(filename, O_WRONLY | O_CLOEXEC);
|
|
if (bg_cgroup_fd < 0) {
|
|
SLOGE("open of %s failed: %s\n", filename, strerror(errno));
|
|
}
|
|
} else {
|
|
__sys_supports_schedgroups = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Try to get the scheduler group.
|
|
*
|
|
* The data from /proc/<pid>/cgroup looks (something) like:
|
|
* 2:cpu:/bg_non_interactive
|
|
* 1:cpuacct:/
|
|
*
|
|
* We return the part after the "/", which will be an empty string for
|
|
* the default cgroup. If the string is longer than "bufLen", the string
|
|
* will be truncated.
|
|
*/
|
|
static int getSchedulerGroup(int tid, char* buf, size_t bufLen)
|
|
{
|
|
#if defined(__ANDROID__)
|
|
char pathBuf[32];
|
|
char lineBuf[256];
|
|
FILE *fp;
|
|
|
|
snprintf(pathBuf, sizeof(pathBuf), "/proc/%d/cgroup", tid);
|
|
if (!(fp = fopen(pathBuf, "r"))) {
|
|
return -1;
|
|
}
|
|
|
|
while(fgets(lineBuf, sizeof(lineBuf) -1, fp)) {
|
|
char *next = lineBuf;
|
|
char *subsys;
|
|
char *grp;
|
|
size_t len;
|
|
|
|
/* Junk the first field */
|
|
if (!strsep(&next, ":")) {
|
|
goto out_bad_data;
|
|
}
|
|
|
|
if (!(subsys = strsep(&next, ":"))) {
|
|
goto out_bad_data;
|
|
}
|
|
|
|
if (strcmp(subsys, "cpu")) {
|
|
/* Not the subsys we're looking for */
|
|
continue;
|
|
}
|
|
|
|
if (!(grp = strsep(&next, ":"))) {
|
|
goto out_bad_data;
|
|
}
|
|
grp++; /* Drop the leading '/' */
|
|
len = strlen(grp);
|
|
grp[len-1] = '\0'; /* Drop the trailing '\n' */
|
|
|
|
if (bufLen <= len) {
|
|
len = bufLen - 1;
|
|
}
|
|
strncpy(buf, grp, len);
|
|
buf[len] = '\0';
|
|
fclose(fp);
|
|
return 0;
|
|
}
|
|
|
|
SLOGE("Failed to find cpu subsys");
|
|
fclose(fp);
|
|
return -1;
|
|
out_bad_data:
|
|
SLOGE("Bad cgroup data {%s}", lineBuf);
|
|
fclose(fp);
|
|
return -1;
|
|
#else
|
|
errno = ENOSYS;
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int get_sched_policy(int tid, SchedPolicy *policy)
|
|
{
|
|
if (tid == 0) {
|
|
tid = gettid();
|
|
}
|
|
pthread_once(&the_once, __initialize);
|
|
|
|
if (__sys_supports_schedgroups) {
|
|
char grpBuf[32];
|
|
if (getSchedulerGroup(tid, grpBuf, sizeof(grpBuf)) < 0)
|
|
return -1;
|
|
if (grpBuf[0] == '\0') {
|
|
*policy = SP_FOREGROUND;
|
|
} else if (!strcmp(grpBuf, "bg_non_interactive")) {
|
|
*policy = SP_BACKGROUND;
|
|
} else {
|
|
errno = ERANGE;
|
|
return -1;
|
|
}
|
|
} else {
|
|
int rc = sched_getscheduler(tid);
|
|
if (rc < 0)
|
|
return -1;
|
|
else if (rc == SCHED_NORMAL)
|
|
*policy = SP_FOREGROUND;
|
|
else if (rc == SCHED_BATCH)
|
|
*policy = SP_BACKGROUND;
|
|
else {
|
|
errno = ERANGE;
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int set_sched_policy(int tid, SchedPolicy policy)
|
|
{
|
|
if (tid == 0) {
|
|
tid = gettid();
|
|
}
|
|
policy = _policy(policy);
|
|
pthread_once(&the_once, __initialize);
|
|
|
|
#if POLICY_DEBUG
|
|
char statfile[64];
|
|
char statline[1024];
|
|
char thread_name[255];
|
|
int fd;
|
|
|
|
sprintf(statfile, "/proc/%d/stat", tid);
|
|
memset(thread_name, 0, sizeof(thread_name));
|
|
|
|
fd = open(statfile, O_RDONLY);
|
|
if (fd >= 0) {
|
|
int rc = read(fd, statline, 1023);
|
|
close(fd);
|
|
statline[rc] = 0;
|
|
char *p = statline;
|
|
char *q;
|
|
|
|
for (p = statline; *p != '('; p++);
|
|
p++;
|
|
for (q = p; *q != ')'; q++);
|
|
|
|
strncpy(thread_name, p, (q-p));
|
|
}
|
|
switch (policy) {
|
|
case SP_BACKGROUND:
|
|
SLOGD("vvv tid %d (%s)", tid, thread_name);
|
|
break;
|
|
case SP_FOREGROUND:
|
|
case SP_AUDIO_APP:
|
|
case SP_AUDIO_SYS:
|
|
SLOGD("^^^ tid %d (%s)", tid, thread_name);
|
|
break;
|
|
case SP_SYSTEM:
|
|
SLOGD("/// tid %d (%s)", tid, thread_name);
|
|
break;
|
|
default:
|
|
SLOGD("??? tid %d (%s)", tid, thread_name);
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
if (__sys_supports_schedgroups) {
|
|
if (add_tid_to_cgroup(tid, policy)) {
|
|
if (errno != ESRCH && errno != ENOENT)
|
|
return -errno;
|
|
}
|
|
} else {
|
|
struct sched_param param;
|
|
|
|
param.sched_priority = 0;
|
|
sched_setscheduler(tid,
|
|
(policy == SP_BACKGROUND) ?
|
|
SCHED_BATCH : SCHED_NORMAL,
|
|
¶m);
|
|
}
|
|
|
|
prctl(PR_SET_TIMERSLACK_PID, policy == SP_BACKGROUND ? TIMER_SLACK_BG : 0, tid);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
/* Stubs for non-Android targets. */
|
|
|
|
int set_sched_policy(int tid UNUSED, SchedPolicy policy UNUSED)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int get_sched_policy(int tid UNUSED, SchedPolicy *policy)
|
|
{
|
|
*policy = SP_SYSTEM_DEFAULT;
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
const char *get_sched_policy_name(SchedPolicy policy)
|
|
{
|
|
policy = _policy(policy);
|
|
static const char * const strings[SP_CNT] = {
|
|
[SP_BACKGROUND] = "bg",
|
|
[SP_FOREGROUND] = "fg",
|
|
[SP_SYSTEM] = " ",
|
|
[SP_AUDIO_APP] = "aa",
|
|
[SP_AUDIO_SYS] = "as",
|
|
};
|
|
if ((policy < SP_CNT) && (strings[policy] != NULL))
|
|
return strings[policy];
|
|
else
|
|
return "error";
|
|
}
|
|
|