static void show_sched_info(struct chrt_ctl *ctl)
{
if (ctl->all_tasks) {
pid_t tid;
struct proc_tasks *ts = proc_open_tasks(ctl->pid);
if (!ts)
err(EXIT_FAILURE, _("cannot obtain the list of tasks"));
while (!proc_next_tid(ts, &tid))
show_sched_pid_info(ctl, tid);
proc_close_tasks(ts);
} else
show_sched_pid_info(ctl, ctl->pid);
}
static int test_tasks(int argc, char *argv[])
{
pid_t tid, pid;
struct proc_tasks *ts;
if (argc != 2)
return EXIT_FAILURE;
pid = strtol(argv[1], (char **) NULL, 10);
printf("PID=%d, TIDs:", pid);
ts = proc_open_tasks(pid);
if (!ts)
err(EXIT_FAILURE, "open list of tasks failed");
while (proc_next_tid(ts, &tid) == 0)
printf(" %d", tid);
printf("\n");
proc_close_tasks(ts);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int i, policy = SCHED_RR, priority = 0, verbose = 0, policy_flag = 0,
all_tasks = 0;
struct sched_param sp;
pid_t pid = -1;
static const struct option longopts[] = {
{ "all-tasks", 0, NULL, 'a' },
{ "batch", 0, NULL, 'b' },
{ "fifo", 0, NULL, 'f' },
{ "idle", 0, NULL, 'i' },
{ "pid", 0, NULL, 'p' },
{ "help", 0, NULL, 'h' },
{ "max", 0, NULL, 'm' },
{ "other", 0, NULL, 'o' },
{ "rr", 0, NULL, 'r' },
{ "reset-on-fork", 0, NULL, 'R' },
{ "verbose", 0, NULL, 'v' },
{ "version", 0, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
while((i = getopt_long(argc, argv, "+abfiphmoRrvV", longopts, NULL)) != -1)
{
int ret = EXIT_FAILURE;
switch (i) {
case 'a':
all_tasks = 1;
break;
case 'b':
#ifdef SCHED_BATCH
policy = SCHED_BATCH;
#endif
break;
case 'f':
policy = SCHED_FIFO;
break;
case 'R':
#ifdef SCHED_RESET_ON_FORK
policy_flag |= SCHED_RESET_ON_FORK;
#endif
break;
case 'i':
#ifdef SCHED_IDLE
policy = SCHED_IDLE;
#endif
break;
case 'm':
show_min_max();
return EXIT_SUCCESS;
case 'o':
policy = SCHED_OTHER;
break;
case 'p':
errno = 0;
pid = strtol_or_err(argv[argc - 1], _("failed to parse pid"));
break;
case 'r':
policy = SCHED_RR;
break;
case 'v':
verbose = 1;
break;
case 'V':
printf("%s from %s\n", program_invocation_short_name,
PACKAGE_STRING);
return EXIT_SUCCESS;
case 'h':
ret = EXIT_SUCCESS;
/* fallthrough */
default:
show_usage(ret);
}
}
if (((pid > -1) && argc - optind < 1) ||
((pid == -1) && argc - optind < 2))
show_usage(EXIT_FAILURE);
if ((pid > -1) && (verbose || argc - optind == 1)) {
if (all_tasks) {
pid_t tid;
struct proc_tasks *ts = proc_open_tasks(pid);
if (!ts)
err(EXIT_FAILURE, _("cannot obtain the list of tasks"));
while (!proc_next_tid(ts, &tid))
show_rt_info(tid, FALSE);
proc_close_tasks(ts);
} else
show_rt_info(pid, FALSE);
if (argc - optind == 1)
return EXIT_SUCCESS;
}
errno = 0;
priority = strtol_or_err(argv[optind], _("failed to parse priority"));
#ifdef SCHED_RESET_ON_FORK
/* sanity check */
if ((policy_flag & SCHED_RESET_ON_FORK) &&
!(policy == SCHED_FIFO || policy == SCHED_RR))
errx(EXIT_FAILURE, _("SCHED_RESET_ON_FORK flag is suppoted for "
"SCHED_FIFO and SCHED_RR policies only"));
#endif
policy |= policy_flag;
if (pid == -1)
pid = 0;
sp.sched_priority = priority;
if (all_tasks) {
pid_t tid;
struct proc_tasks *ts = proc_open_tasks(pid);
if (!ts)
err(EXIT_FAILURE, _("cannot obtain the list of tasks"));
while (!proc_next_tid(ts, &tid))
if (sched_setscheduler(tid, policy, &sp) == -1)
err(EXIT_FAILURE, _("failed to set tid %d's policy"), tid);
proc_close_tasks(ts);
} else if (sched_setscheduler(pid, policy, &sp) == -1)
err(EXIT_FAILURE, _("failed to set pid %d's policy"), pid);
if (verbose)
show_rt_info(pid, TRUE);
if (!pid) {
argv += optind + 1;
execvp(argv[0], argv);
perror("execvp");
err(EXIT_FAILURE, _("failed to execute %s"), argv[0]);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
cpu_set_t *new_set;
pid_t pid = 0;
int c, all_tasks = 0;
int ncpus;
size_t new_setsize, nbits;
struct taskset ts;
static const struct option longopts[] = {
{ "all-tasks", 0, NULL, 'a' },
{ "pid", 0, NULL, 'p' },
{ "cpu-list", 0, NULL, 'c' },
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
memset(&ts, 0, sizeof(ts));
while ((c = getopt_long(argc, argv, "+apchV", longopts, NULL)) != -1) {
switch (c) {
case 'a':
all_tasks = 1;
break;
case 'p':
pid = strtol_or_err(argv[argc - 1],
_("failed to parse pid"));
break;
case 'c':
ts.use_list = 1;
break;
case 'V':
printf("%s from %s\n", program_invocation_short_name,
PACKAGE_STRING);
return EXIT_SUCCESS;
case 'h':
usage(stdout);
break;
default:
usage(stderr);
break;
}
}
if ((!pid && argc - optind < 2)
|| (pid && (argc - optind < 1 || argc - optind > 2)))
usage(stderr);
ncpus = get_max_number_of_cpus();
if (ncpus <= 0)
errx(EXIT_FAILURE, _("cannot determine NR_CPUS; aborting"));
/*
* the ts->set is always used for the sched_getaffinity call
* On the sched_getaffinity the kernel demands a user mask of
* at least the size of its own cpumask_t.
*/
ts.set = cpuset_alloc(ncpus, &ts.setsize, &nbits);
if (!ts.set)
err(EXIT_FAILURE, _("cpuset_alloc failed"));
/* buffer for conversion from mask to string */
ts.buflen = 7 * nbits;
ts.buf = xmalloc(ts.buflen);
/*
* new_set is always used for the sched_setaffinity call
* On the sched_setaffinity the kernel will zero-fill its
* cpumask_t if the user's mask is shorter.
*/
new_set = cpuset_alloc(ncpus, &new_setsize, NULL);
if (!new_set)
err(EXIT_FAILURE, _("cpuset_alloc failed"));
if (argc - optind == 1)
ts.get_only = 1;
else if (ts.use_list) {
if (cpulist_parse(argv[optind], new_set, new_setsize, 0))
errx(EXIT_FAILURE, _("failed to parse CPU list: %s"),
argv[optind]);
} else if (cpumask_parse(argv[optind], new_set, new_setsize)) {
errx(EXIT_FAILURE, _("failed to parse CPU mask: %s"),
argv[optind]);
}
if (all_tasks) {
struct proc_tasks *tasks = proc_open_tasks(pid);
while (!proc_next_tid(tasks, &ts.pid))
do_taskset(&ts, new_setsize, new_set);
proc_close_tasks(tasks);
} else {
ts.pid = pid;
do_taskset(&ts, new_setsize, new_set);
}
free(ts.buf);
cpuset_free(ts.set);
cpuset_free(new_set);
if (!pid) {
argv += optind + 1;
execvp(argv[0], argv);
err(EXIT_FAILURE, _("executing %s failed"), argv[0]);
}
return EXIT_SUCCESS;
}
static int set_sched_one(struct chrt_ctl *ctl, pid_t pid)
{
struct sched_param sp = { .sched_priority = ctl->priority };
int policy = ctl->policy;
# ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork)
policy |= SCHED_RESET_ON_FORK;
# endif
return sched_setscheduler(pid, policy, &sp);
}
#else /* !HAVE_SCHED_SETATTR */
static int set_sched_one(struct chrt_ctl *ctl, pid_t pid)
{
/* use main() to check if the setting makes sense */
struct sched_attr sa = {
.size = sizeof(struct sched_attr),
.sched_policy = ctl->policy,
.sched_priority = ctl->priority,
.sched_runtime = ctl->runtime,
.sched_period = ctl->period,
.sched_deadline = ctl->deadline
};
# ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork)
sa.sched_flags |= SCHED_RESET_ON_FORK;
# endif
return sched_setattr(pid, &sa, 0);
}
#endif /* HAVE_SCHED_SETATTR */
static void set_sched(struct chrt_ctl *ctl)
{
if (ctl->all_tasks) {
pid_t tid;
struct proc_tasks *ts = proc_open_tasks(ctl->pid);
if (!ts)
err(EXIT_FAILURE, _("cannot obtain the list of tasks"));
while (!proc_next_tid(ts, &tid))
if (set_sched_one(ctl, tid) == -1)
err(EXIT_FAILURE, _("failed to set tid %d's policy"), tid);
proc_close_tasks(ts);
} else if (set_sched_one(ctl, ctl->pid) == -1)
err(EXIT_FAILURE, _("failed to set pid %d's policy"), ctl->pid);
ctl->altered = 1;
}
int main(int argc, char **argv)
{
struct chrt_ctl _ctl = { .pid = -1 }, *ctl = &_ctl;
int c;
static const struct option longopts[] = {
{ "all-tasks", no_argument, NULL, 'a' },
{ "batch", no_argument, NULL, 'b' },
{ "deadline", no_argument, NULL, 'd' },
{ "fifo", no_argument, NULL, 'f' },
{ "idle", no_argument, NULL, 'i' },
{ "pid", no_argument, NULL, 'p' },
{ "help", no_argument, NULL, 'h' },
{ "max", no_argument, NULL, 'm' },
{ "other", no_argument, NULL, 'o' },
{ "rr", no_argument, NULL, 'r' },
{ "sched-runtime", required_argument, NULL, 'T' },
{ "sched-period", required_argument, NULL, 'P' },
{ "sched-deadline", required_argument, NULL, 'D' },
{ "reset-on-fork", no_argument, NULL, 'R' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ NULL, no_argument, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while((c = getopt_long(argc, argv, "+abdDfiphmoPTrRvV", longopts, NULL)) != -1)
{
int ret = EXIT_FAILURE;
switch (c) {
case 'a':
ctl->all_tasks = 1;
break;
case 'b':
#ifdef SCHED_BATCH
ctl->policy = SCHED_BATCH;
#endif
break;
case 'd':
#ifdef SCHED_DEADLINE
ctl->policy = SCHED_DEADLINE;
#endif
break;
case 'f':
ctl->policy = SCHED_FIFO;
break;
case 'R':
ctl->reset_on_fork = 1;
break;
case 'i':
#ifdef SCHED_IDLE
ctl->policy = SCHED_IDLE;
#endif
break;
case 'm':
show_min_max();
return EXIT_SUCCESS;
case 'o':
ctl->policy = SCHED_OTHER;
break;
case 'p':
errno = 0;
ctl->pid = strtos32_or_err(argv[argc - 1], _("invalid PID argument"));
break;
case 'r':
ctl->policy = SCHED_RR;
break;
case 'v':
ctl->verbose = 1;
break;
case 'T':
ctl->runtime = strtou64_or_err(optarg, _("invalid runtime argument"));
break;
case 'P':
ctl->period = strtou64_or_err(optarg, _("invalid period argument"));
break;
case 'D':
ctl->deadline = strtou64_or_err(optarg, _("invalid deadline argument"));
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
ret = EXIT_SUCCESS;
/* fallthrough */
default:
show_usage(ret);
}
}
if (((ctl->pid > -1) && argc - optind < 1) ||
((ctl->pid == -1) && argc - optind < 2))
show_usage(EXIT_FAILURE);
if ((ctl->pid > -1) && (ctl->verbose || argc - optind == 1)) {
show_sched_info(ctl);
if (argc - optind == 1)
return EXIT_SUCCESS;
}
errno = 0;
ctl->priority = strtos32_or_err(argv[optind], _("invalid priority argument"));
#ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork && ctl->policy != SCHED_FIFO && ctl->policy != SCHED_RR)
errx(EXIT_FAILURE, _("--reset-on-fork option is supported for "
"SCHED_FIFO and SCHED_RR policies only"));
#endif
#ifdef SCHED_DEADLINE
if ((ctl->runtime || ctl->deadline || ctl->period) && ctl->policy != SCHED_DEADLINE)
errx(EXIT_FAILURE, _("--sched-{runtime,deadline,period} options "
"are supported for SCHED_DEADLINE only"));
if (ctl->policy == SCHED_DEADLINE) {
/* The basic rule is runtime <= deadline <= period, so we can
* make deadline and runtime optional on command line. Note we
* don't check any values or set any defaults, it's kernel
* responsibility.
*/
if (ctl->deadline == 0)
ctl->deadline = ctl->period;
if (ctl->runtime == 0)
ctl->runtime = ctl->deadline;
}
#else
if (ctl->runtime || ctl->deadline || ctl->period)
errx(EXIT_FAILURE, _("SCHED_DEADLINE is unsupported"));
#endif
if (ctl->pid == -1)
ctl->pid = 0;
set_sched(ctl);
if (ctl->verbose)
show_sched_info(ctl);
if (!ctl->pid) {
argv += optind + 1;
execvp(argv[0], argv);
err(EXIT_FAILURE, _("failed to execute %s"), argv[0]);
}
return EXIT_SUCCESS;
}
