Differential D2559 Diff 5798 usr.bin/numactl/numactl.c

Changeset View

Standalone View

usr.bin/numactl/numactl.c

This file was added.

Property	Old Value	New Value
svn:eol-style	null	native \ No newline at end of property
svn:keywords	null	FreeBSD=%H \ No newline at end of property
svn:mime-type	null	text/plain \ No newline at end of property

				/*
				adrianUnsubmitted Not Done Inline Actions Fixed! adrian: Fixed!
				* Copyright (c) 2015 Adrian Chadd <adrian@FreeBSD.org>
				stasUnsubmitted Not Done Inline Actions FreeBSD tradition is to use "control" name for that kind of applications. See e.g. cdcontrol, cpucontrol, memcontrol, vidcontrol, pmccontrol, kbdcontrol etc. This tool should follow the pattern. stas:* FreeBSD tradition is to use "*control" name for that kind of applications. See e.g. cdcontrol…
				* All rights reserved.
				*
				* Redistribution and use in source and binary forms, with or without
				* modification, are permitted provided that the following conditions
				* are met:
				* 1. Redistributions of source code must retain the above copyright
				* notice, this list of conditions and the following disclaimer.
				* 2. Redistributions in binary form must reproduce the above copyright
				* notice, this list of conditions and the following disclaimer in the
				* documentation and/or other materials provided with the distribution.
				*
				* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
				* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
				* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
				* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
				* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
				* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
				* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
				* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
				* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
				* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
				* SUCH DAMAGE.
				*/

				#include <sys/cdefs.h>
				__FBSDID("$FreeBSD$");

				#include <sys/param.h>
				#include <sys/types.h>
				#include <sys/time.h>

				#include <ctype.h>
				#include <err.h>
				#include <errno.h>
				#include <libgen.h>
				#include <limits.h>
				#include <stdio.h>
				#include <stdlib.h>
				#include <stdint.h>
				#include <unistd.h>
				#include <string.h>
				#include <getopt.h>
				#include <sysexits.h>

				#include <sys/resource.h>
				#include <sys/cpuset.h>
				#include <sys/numa.h>

				enum {
				OPT_TID = 1001,
				OPT_PID,
				OPT_MEMDOMAIN,
				OPT_CPUDOMAIN,
				OPT_MEMPOLICY,
				OPT_SET,
				OPT_GET
				};

				static struct option longopts[] = {
				{ "tid", required_argument, NULL, OPT_TID },
				{ "pid", required_argument, NULL, OPT_PID },
				{ "memdomain", required_argument, NULL, OPT_MEMDOMAIN },
				{ "cpudomain", required_argument, NULL, OPT_CPUDOMAIN },
				{ "mempolicy", required_argument, NULL, OPT_MEMPOLICY },
				{ "set", no_argument, NULL, OPT_SET },
				{ "get", no_argument, NULL, OPT_GET },
				{ NULL, 0, NULL, 0 }
				};

				static const char *
				policy_to_str(vm_domain_policy_type_t vt)
				{
				switch (vt) {
				case VM_POLICY_NONE:
				return ("none");
				case VM_POLICY_ROUND_ROBIN:
				return ("rr");
				case VM_POLICY_FIXED_DOMAIN:
				return ("fixed-domain");
				case VM_POLICY_FIXED_DOMAIN_ROUND_ROBIN:
				return ("fixed-domain-rr");
				case VM_POLICY_FIRST_TOUCH:
				return ("first-touch");
				case VM_POLICY_FIRST_TOUCH_ROUND_ROBIN:
				return ("first-touch-rr");
				default:
				return ("unknown");
				}
				}

				static int
				parse_policy(struct vm_domain_policy vd, const char str)
				{

				if (strcmp(str, "rr") == 0) {
				vd->policy = VM_POLICY_ROUND_ROBIN;
				vd->domain = -1;
				vd->seq = 0;
				return (0);
				}

				if (strcmp(str, "first-touch-rr") == 0) {
				vd->policy = VM_POLICY_FIRST_TOUCH_ROUND_ROBIN;
				vd->domain = -1;
				vd->seq = 0;
				return (0);
				}

				if (strcmp(str, "first-touch") == 0) {
				vd->policy = VM_POLICY_FIRST_TOUCH;
				vd->domain = -1;
				vd->seq = 0;
				return (0);
				}

				if (strcmp(str, "fixed-domain") == 0) {
				vd->policy = VM_POLICY_FIXED_DOMAIN;
				vd->domain = 0;
				vd->seq = 0;
				return (0);
				}

				if (strcmp(str, "fixed-domain-rr") == 0) {
				vd->policy = VM_POLICY_FIXED_DOMAIN_ROUND_ROBIN;
				vd->domain = 0;
				vd->seq = 0;
				return (0);
				}

				return (-1);
				}

				static void
				usage(void)
				stasUnsubmitted Not Done Inline Actions mark it as __noreturn? stas: mark it as __noreturn?
				{

				printf("usage: numactl --get [--tid=<tid>] [--pid=<pid>]\n");
				printf(" numactl --set [--tid=<tid>] [--pid=<pid>]\n");
				printf(" [--mempolicy=<policy>] [--memdomain=<domain>]\n");
				printf(" [--cpudomain=<domain>]\n");
				printf(" numactl [--mempolicy=<policy>] [--memdomain=<domain>]\n");
				printf(" [--cpudomain=<domain>] <cmd> ...\n");

				exit(EX_USAGE);
				stasUnsubmitted Done Inline Actions EX_USAGE. stas: EX_USAGE.
				}

				static int
				set_numa_domain_cpuaffinity(int cpu_domain)
				{
				int error;
				cpuset_t set;
				error = cpuset_getaffinity(CPU_LEVEL_WHICH,
				CPU_WHICH_DOMAIN,
				cpu_domain,
				sizeof(set),
				&set);
				if (error != 0)
				err(EXIT_FAILURE, "cpuset_getaffinity");
				error = cpuset_setaffinity(CPU_LEVEL_WHICH,
				CPU_WHICH_PID,
				-1,
				sizeof(set),
				&set);
				if (error != 0)
				err(EXIT_FAILURE, "cpuset_setaffinity");

				return (0);
				}

				int
				main(int argc, char *argv[])
				{
				id_t id;
				cpuwhich_t which;
				struct vm_domain_policy vd;
				int error;
				int is_set = 0, is_get = 0;
				int mem_policy_set = 0;
				lwpid_t tid = -1;
				pid_t pid = -1;
				int ch;
				int cpu_domain = -1;

				stasUnsubmitted Not Done Inline Actions style(9) recommends variable to be sorted by size, then by name. stas: style(9) recommends variable to be sorted by size, then by name.
				while ((ch = getopt_long(argc, argv, "", longopts, NULL)) != -1) {
				switch (ch) {
				stasUnsubmitted Not Done Inline Actions geprogname(3)? stas: geprogname(3)?
				case OPT_TID:
				tid = atoi(optarg);
				stasUnsubmitted Done Inline Actions Is there any reason this tool uses long options? FreeBSD base utilities use short options in most cases, and it does not look like this tools is compatible with Linux's numactl either. In either case we'll need to add short options to long options if we want to keep long ones. stas: Is there any reason this tool uses long options? FreeBSD base utilities use short options in…
				break;
				case OPT_PID:
				pid = atoi(optarg);
				stasUnsubmitted Not Done Inline Actions This (and below) should really use strtoul(3) and complain about errors. Also, is there any reason it prints the tid, or is it just a leftover? stas: This (and below) should really use strtoul(3) and complain about errors. Also, is there any…
				break;
				case OPT_CPUDOMAIN:
				cpu_domain = atoi(optarg);
				break;
				case OPT_MEMDOMAIN:
				if (mem_policy_set == 0) {
				fprintf(stderr, "Error: set policy first before domain\n");
				exit(EXIT_FAILURE);
				}
				vd.domain = atoi(optarg);
				break;
				case OPT_MEMPOLICY:
				if (parse_policy(&vd, optarg) != 0) {
				fprintf(stderr, "Could not parse policy: '%s'\n", optarg);
				exit(EXIT_FAILURE);
				}
				mem_policy_set = 1;
				break;
				stasUnsubmitted Done Inline Actions Generally FreeBSD avoids contractions in error messages. stas: Generally FreeBSD avoids contractions in error messages.
				case OPT_SET:
				is_set = 1;
				break;
				case OPT_GET:
				is_get = 1;
				break;
				default:
				usage();
				}
				}
				argc -= optind;
				argv += optind;

				/* Handle the user wishing to run a command */
				if (argc) {
				/* Ensure that a policy was set */
				if (mem_policy_set == 0) {
				fprintf(stderr, "Error: no policy given\n");
				usage();
				}

				/* Set current memory process policy, will be inherited */
				if (numa_setaffinity(CPU_WHICH_PID, -1, &vd) != 0)
				stasUnsubmitted Done Inline Actions Print usage here? stas: Print usage here?
				err(EXIT_FAILURE, "numa_setaffinity");

				/* If a CPU domain policy was given, include that too */
				if (cpu_domain != -1)
				(void) set_numa_domain_cpuaffinity(cpu_domain);

				errno = 0;
				execvp(*argv, argv);
				err(errno == ENOENT ? 127 : 126, "%s", *argv);
				}

				/* Figure out which */
				if (tid != -1) {
				which = CPU_WHICH_TID;
				id = tid;
				} else if (pid != -1) {
				which = CPU_WHICH_PID;
				id = pid;
				}

				/* Sanity checks */
				if (is_set && is_get) {
				fprintf(stderr, "Error: can't set both 'set' and 'get'\n");
				usage();
				}

				if (is_set && ! mem_policy_set) {
				fprintf(stderr, "Error: --set given, but no policy\n");
				stasUnsubmitted Done Inline Actions Use EX_USAGE on usage(). Also, usage() itself should just exit. stas: Use EX_USAGE on usage(). Also, usage() itself should just exit.
				usage();
				}

				if (tid == -1 && pid == -1) {
				fprintf(stderr, "Error: no TID or PID given\n");
				usage();
				}

				/* If it's get, then get the policy and return */
				if (is_get) {
				error = numa_getaffinity(which, id, &vd);
				if (error != 0)
				err(EXIT_FAILURE, "numa_getaffinity");
				printf(" Policy: %s; domain: %d\n",
				policy_to_str(vd.policy),
				vd.domain);
				exit(EXIT_SUCCESS);
				}

				/* Assume it's set */

				/* Syscall */
				error = numa_setaffinity(which, id, &vd);
				if (error != 0)
				err(EXIT_FAILURE, "numa_setaffinity");

				/* If a CPU domain policy was given, include that too */
				if (cpu_domain != -1)
				(void) set_numa_domain_cpuaffinity(cpu_domain);

				exit(EXIT_SUCCESS);
				}