struct cpuset *
cpuset_new(const char *name, const struct range *range)
{
struct cpuset *set;
int cpu;
BUG_ON(!range);
BUG_ON(!num_cpus);
if (range->rg_from > range->rg_to
|| range->rg_to > num_cpus) {
dbg("cpuset: out of range (from %u, to %u)", range->rg_from,
range->rg_to);
return NULL;
}
if ((set = g_malloc0(sizeof(struct cpuset))) == NULL)
return NULL;
if ((set->cs_name = strdup(name)) == NULL) {
cpuset_free(set);
return NULL;
}
memcpy(&set->cs_range, range, sizeof(struct range));
for (cpu = range->rg_from; cpu <= range->rg_to; cpu++) {
set->cs_cpu_lru_list = g_slist_append(set->cs_cpu_lru_list, &cpus[cpu]);
BUG_ON(cpus[cpu].ci_cpuset);
cpus[cpu].ci_cpuset = set;
}
return set;
}
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;
}
/*
* hog the cpu time and check the cpu which the task is running on is in the
* cpus of the cpuset or not.
*
* return value: 0 - success.
* 1 - the cpu which the task is running on isn't in the cpus
* of the cpuset.
* -1 - failure for other reason.
*/
int cpu_hog(void)
{
double f = 2744545.34456455;
sigset_t sigset;
struct cpuset *cp = NULL;
struct bitmask *cpumask = NULL;
int cpu;
int nbits;
int ret = 0;
nbits = cpuset_cpus_nbits();
cp = cpuset_alloc();
if (cp == NULL)
return -1;
cpumask = bitmask_alloc(nbits);
if (cpumask == NULL) {
ret = -1;
goto err1;
}
if (sigemptyset(&sigset) < 0) {
ret = -1;
goto err2;
}
sigsuspend(&sigset);
if (cpuset_cpusetofpid(cp, 0) < 0) {
ret = -1;
goto err2;
}
if (cpuset_getcpus(cp, cpumask) != 0) {
ret = -1;
goto err2;
}
while (!end) {
f = sqrt(f * f);
cpu = cpuset_latestcpu(0);
if (cpu < 0) {
warn("get latest cpu failed.\n");
ret = -1;
goto err2;
}
if (!bitmask_isbitset(cpumask, cpu)) {
char str[50];
bitmask_displaylist(str, 50, cpumask);
warn("the task(%d) is running on the cpu(%d) excluded"
" by cpuset(cpus: %s)\n", getpid(), cpu, str);
ret = 1;
goto err2;
}
}
err2:
bitmask_free(cpumask);
err1:
cpuset_free(cp);
return ret;
}
