[apple/system_cmds.git] / taskpolicy.tproj / taskpolicy.c

/*
 * Copyright (c) 2013 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * "Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
 * Reserved.  This file contains Original Code and/or Modifications of
 * Original Code as defined in and that are subject to the Apple Public
 * Source License Version 1.0 (the 'License').  You may not use this file
 * except in compliance with the License.  Please obtain a copy of the
 * License at http://www.apple.com/publicsource and read it before using
 * this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License."
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/resource.h>
#include <err.h>
#include <sys/errno.h>
#include <stdbool.h>
#include <sysexits.h>
#include <mach/mach.h>
#include <mach/task_policy.h>

#include <spawn.h>
#include <spawn_private.h>
#include <sys/spawn_internal.h>

#define QOS_PARAMETER_LATENCY 0
#define QOS_PARAMETER_THROUGHPUT 1

extern char **environ;

static void usage(void);
static int parse_disk_policy(const char *strpolicy);
static int parse_qos_tier(const char *strpolicy, int parameter);
static uint64_t parse_qos_clamp(const char *qos_string);

int main(int argc, char * argv[])
{
	int ch, ret;
	pid_t pid = 0;
    posix_spawnattr_t attr;
    extern char **environ;
	bool flagx = false, flagX = false, flagb = false, flagB = false;
	int flagd = -1, flagg = -1;
	struct task_qos_policy qosinfo = { LATENCY_QOS_TIER_UNSPECIFIED, THROUGHPUT_QOS_TIER_UNSPECIFIED };
    uint64_t qos_clamp = POSIX_SPAWN_PROC_CLAMP_NONE;
	
	while ((ch = getopt(argc, argv, "xXbBd:g:c:t:l:p:")) != -1) {
		switch (ch) {
			case 'x':
				flagx = true;
				break;
			case 'X':
				flagX = true;
				break;
			case 'b':
				flagb = true;
				break;
			case 'B':
				flagB = true;
				break;
			case 'd':
				flagd = parse_disk_policy(optarg);
				if (flagd == -1) {
					warnx("Could not parse '%s' as a disk policy", optarg);
					usage();
				}
				break;
			case 'g':
				flagg = parse_disk_policy(optarg);
				if (flagg == -1) {
					warnx("Could not parse '%s' as a disk policy", optarg);
					usage();
				}
				break;
            case 'c':
                qos_clamp = parse_qos_clamp(optarg);
                if (qos_clamp == POSIX_SPAWN_PROC_CLAMP_NONE) {
                    warnx("Could not parse '%s' as a QoS clamp", optarg);
                    usage();
                }
                break;
			case 't':
				qosinfo.task_throughput_qos_tier = parse_qos_tier(optarg, QOS_PARAMETER_THROUGHPUT);
				if (qosinfo.task_throughput_qos_tier == -1) {
					warnx("Could not parse '%s' as a qos tier", optarg);
					usage();
				}
				break;
			case 'l':
				qosinfo.task_latency_qos_tier = parse_qos_tier(optarg, QOS_PARAMETER_LATENCY);
				if (qosinfo.task_latency_qos_tier == -1) {
					warnx("Could not parse '%s' as a qos tier", optarg);
					usage();
				}
				break;
			case 'p':
				pid = atoi(optarg);
				if (pid == 0) {
					warnx("Invalid pid '%s' specified", optarg);
					usage();
				}
				break;
			case '?':
			default:
				usage();
		}
	}
	argc -= optind;
	argv += optind;

	if (pid == 0 && argc == 0) {
		usage();
	}

	if (pid != 0 && (flagx || flagX || flagg != -1 || flagd != -1)) {
		warnx("Incompatible option(s) used with -p");
		usage();
	}
	
	if (flagx && flagX){
		warnx("Incompatible options -x, -X");
		usage();
	}

	if (flagb && flagB) {
		warnx("Incompatible options -b, -B");
		usage();
	}

	if (flagB && pid == 0) {
		warnx("The -B option can only be used with the -p option");
		usage();
	}

	if (flagx) {
		ret = setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY, IOPOL_SCOPE_PROCESS, IOPOL_VFS_HFS_CASE_SENSITIVITY_FORCE_CASE_SENSITIVE);
		if (ret == -1) {
			err(EX_SOFTWARE, "setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY...)");
		}
	}

	if (flagX) {
		ret = setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY, IOPOL_SCOPE_PROCESS, IOPOL_VFS_HFS_CASE_SENSITIVITY_DEFAULT);
		if (ret == -1) {
			err(EX_SOFTWARE, "setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY...)");
		}
	}

	if (flagb) {
		ret = setpriority(PRIO_DARWIN_PROCESS, pid, PRIO_DARWIN_BG);
		if (ret == -1) {
			err(EX_SOFTWARE, "setpriority()");
		}
	}

	if (flagB) {
		ret = setpriority(PRIO_DARWIN_PROCESS, pid, 0);
		if (ret == -1) {
			err(EX_SOFTWARE, "setpriority()");
		}
	}

	if (flagd >= 0) {
		ret = setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_PROCESS, flagd);
		if (ret == -1) {
			err(EX_SOFTWARE, "setiopolicy_np(...IOPOL_SCOPE_PROCESS...)");
		}
	}

	if (flagg >= 0){
		ret = setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_DARWIN_BG, flagg);
		if (ret == -1) {
			err(EX_SOFTWARE, "setiopolicy_np(...IOPOL_SCOPE_DARWIN_BG...)");
		}
	}

	if (qosinfo.task_latency_qos_tier != LATENCY_QOS_TIER_UNSPECIFIED ||
	    qosinfo.task_throughput_qos_tier != THROUGHPUT_QOS_TIER_UNSPECIFIED){
		mach_port_t task;
		if (pid) {
			ret = task_for_pid(mach_task_self(), pid, &task);
			if (ret != KERN_SUCCESS) {
				err(EX_SOFTWARE, "task_for_pid(%d) failed", pid);
				return EX_OSERR;
			}
		} else {
			task = mach_task_self();
		}
		ret = task_policy_set((task_t)task, TASK_OVERRIDE_QOS_POLICY, (task_policy_t)&qosinfo, TASK_QOS_POLICY_COUNT);
		if (ret != KERN_SUCCESS){
			err(EX_SOFTWARE, "task_policy_set(...TASK_OVERRIDE_QOS_POLICY...)");
		}
	}
	
	if (pid != 0)
		return 0;
    
    
    ret = posix_spawnattr_init(&attr);
    if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawnattr_init");
    
    ret = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETEXEC);
    if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawnattr_setflags");
    
    if (qos_clamp != POSIX_SPAWN_PROC_CLAMP_NONE) {
        ret = posix_spawnattr_set_qos_clamp_np(&attr, qos_clamp);
        if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawnattr_set_qos_clamp_np");
    }
    
    ret = posix_spawnp(&pid, argv[0], NULL, &attr, argv, environ);
    if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawn");
    
	return EX_OSERR;
}

static void usage(void)
{
	fprintf(stderr, "Usage: %s [-x|-X] [-d <policy>] [-g policy] [-c clamp] [-b] [-t <tier>]\n"
                    "                  [-l <tier>] <program> [<pargs> [...]]\n", getprogname());
	fprintf(stderr, "       %s [-b|-B] [-t <tier>] [-l <tier>] -p pid\n", getprogname());
	exit(EX_USAGE);
}

static int parse_disk_policy(const char *strpolicy)
{
	long policy;
	char *endptr = NULL;
	
	/* first try as an integer */
	policy = strtol(strpolicy, &endptr, 0);
	if (endptr && (endptr[0] == '\0') && (strpolicy[0] != '\0')) {
		/* parsed complete string as a number */
		return (int)policy;
	}
	
	if (0 == strcasecmp(strpolicy, "DEFAULT") ) {
		return IOPOL_DEFAULT;
	} else if (0 == strcasecmp(strpolicy, "IMPORTANT")) {
		return IOPOL_IMPORTANT;
	} else if (0 == strcasecmp(strpolicy, "PASSIVE")) {
		return IOPOL_PASSIVE;
	} else if (0 == strcasecmp(strpolicy, "THROTTLE")) {
		return IOPOL_THROTTLE;
	} else if (0 == strcasecmp(strpolicy, "UTILITY")) {
		return IOPOL_UTILITY;
	} else if (0 == strcasecmp(strpolicy, "STANDARD")) {
		return IOPOL_STANDARD;
	} else {
		return -1;
	}
}

static int parse_qos_tier(const char *strtier, int parameter){
	long policy;
	char *endptr = NULL;
	
	/* first try as an integer */
	policy = strtol(strtier, &endptr, 0);
	if (endptr && (endptr[0] == '\0') && (strtier[0] != '\0')) {
		switch (policy) {
			case 0:
				return parameter ? THROUGHPUT_QOS_TIER_0 : LATENCY_QOS_TIER_0;
				break;
			case 1:
				return parameter ? THROUGHPUT_QOS_TIER_1 : LATENCY_QOS_TIER_1;
				break;
			case 2:
				return parameter ? THROUGHPUT_QOS_TIER_2 : LATENCY_QOS_TIER_2;
				break;
			case 3:
				return parameter ? THROUGHPUT_QOS_TIER_3 : LATENCY_QOS_TIER_3;
				break;
			case 4:
				return parameter ? THROUGHPUT_QOS_TIER_4 : LATENCY_QOS_TIER_4;
				break;
			case 5:
				return parameter ? THROUGHPUT_QOS_TIER_5 : LATENCY_QOS_TIER_5;
				break;
			default:
				return -1;
				break;
		}
	}

	return -1;
}

static uint64_t parse_qos_clamp(const char *qos_string) {
    
    if (0 == strcasecmp(qos_string, "utility") ) {
        return POSIX_SPAWN_PROC_CLAMP_UTILITY;
    } else if (0 == strcasecmp(qos_string, "background")) {
        return POSIX_SPAWN_PROC_CLAMP_BACKGROUND;
    } else if (0 == strcasecmp(qos_string, "maintenance")) {
        return POSIX_SPAWN_PROC_CLAMP_MAINTENANCE;
    } else {
        return POSIX_SPAWN_PROC_CLAMP_NONE;
    }
}
Commit	Line	Data
fc6d9e4b A	1	/*
	2	* Copyright (c) 2013 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
	7	* Reserved. This file contains Original Code and/or Modifications of
	8	* Original Code as defined in and that are subject to the Apple Public
	9	* Source License Version 1.0 (the 'License'). You may not use this file
	10	* except in compliance with the License. Please obtain a copy of the
	11	* License at http://www.apple.com/publicsource and read it before using
	12	* this file.
	13	*
	14	* The Original Code and all software distributed under the License are
	15	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	16	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	17	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	19	* License for the specific language governing rights and limitations
	20	* under the License."
	21	*
	22	* @APPLE_LICENSE_HEADER_END@
	23	*/
	24
	25	#include <stdio.h>
	26	#include <stdlib.h>
	27	#include <unistd.h>
	28	#include <string.h>
	29	#include <sys/resource.h>
	30	#include <err.h>
	31	#include <sys/errno.h>
	32	#include <stdbool.h>
	33	#include <sysexits.h>
	34	#include <mach/mach.h>
	35	#include <mach/task_policy.h>
	36
1a7e3f61 A	37	#include <spawn.h>
	38	#include <spawn_private.h>
	39	#include <sys/spawn_internal.h>
	40
fc6d9e4b A	41	#define QOS_PARAMETER_LATENCY 0
	42	#define QOS_PARAMETER_THROUGHPUT 1
	43
1a7e3f61 A	44	extern char **environ;
1a7e3f61 A	45
fc6d9e4b A	46	static void usage(void);
	47	static int parse_disk_policy(const char *strpolicy);
	48	static int parse_qos_tier(const char *strpolicy, int parameter);
1a7e3f61	49	static uint64_t parse_qos_clamp(const char *qos_string);
fc6d9e4b A	50
	51	int main(int argc, char * argv[])
	52	{
	53	int ch, ret;
1a7e3f61 A	54	pid_t pid = 0;
	55	posix_spawnattr_t attr;
	56	extern char **environ;
	57	bool flagx = false, flagX = false, flagb = false, flagB = false;
fc6d9e4b A	58	int flagd = -1, flagg = -1;
fc6d9e4b A	59	struct task_qos_policy qosinfo = { LATENCY_QOS_TIER_UNSPECIFIED, THROUGHPUT_QOS_TIER_UNSPECIFIED };
1a7e3f61	60	uint64_t qos_clamp = POSIX_SPAWN_PROC_CLAMP_NONE;
fc6d9e4b	61
1a7e3f61	62	while ((ch = getopt(argc, argv, "xXbBd:g:c:t:l:p:")) != -1) {
fc6d9e4b A	63	switch (ch) {
	64	case 'x':
	65	flagx = true;
	66	break;
	67	case 'X':
	68	flagX = true;
	69	break;
	70	case 'b':
	71	flagb = true;
	72	break;
1a7e3f61 A	73	case 'B':
	74	flagB = true;
	75	break;
fc6d9e4b A	76	case 'd':
	77	flagd = parse_disk_policy(optarg);
	78	if (flagd == -1) {
	79	warnx("Could not parse '%s' as a disk policy", optarg);
	80	usage();
	81	}
	82	break;
	83	case 'g':
	84	flagg = parse_disk_policy(optarg);
	85	if (flagg == -1) {
	86	warnx("Could not parse '%s' as a disk policy", optarg);
	87	usage();
	88	}
	89	break;
1a7e3f61 A	90	case 'c':
	91	qos_clamp = parse_qos_clamp(optarg);
	92	if (qos_clamp == POSIX_SPAWN_PROC_CLAMP_NONE) {
	93	warnx("Could not parse '%s' as a QoS clamp", optarg);
	94	usage();
	95	}
	96	break;
fc6d9e4b A	97	case 't':
	98	qosinfo.task_throughput_qos_tier = parse_qos_tier(optarg, QOS_PARAMETER_THROUGHPUT);
	99	if (qosinfo.task_throughput_qos_tier == -1) {
	100	warnx("Could not parse '%s' as a qos tier", optarg);
	101	usage();
	102	}
	103	break;
	104	case 'l':
	105	qosinfo.task_latency_qos_tier = parse_qos_tier(optarg, QOS_PARAMETER_LATENCY);
	106	if (qosinfo.task_latency_qos_tier == -1) {
	107	warnx("Could not parse '%s' as a qos tier", optarg);
	108	usage();
	109	}
	110	break;
1a7e3f61 A	111	case 'p':
	112	pid = atoi(optarg);
	113	if (pid == 0) {
	114	warnx("Invalid pid '%s' specified", optarg);
	115	usage();
	116	}
	117	break;
fc6d9e4b A	118	case '?':
	119	default:
	120	usage();
	121	}
	122	}
	123	argc -= optind;
	124	argv += optind;
	125
1a7e3f61 A	126	if (pid == 0 && argc == 0) {
	127	usage();
	128	}
	129
	130	if (pid != 0 && (flagx \|\| flagX \|\| flagg != -1 \|\| flagd != -1)) {
	131	warnx("Incompatible option(s) used with -p");
fc6d9e4b A	132	usage();
	133	}
	134
	135	if (flagx && flagX){
	136	warnx("Incompatible options -x, -X");
	137	usage();
	138	}
	139
1a7e3f61 A	140	if (flagb && flagB) {
	141	warnx("Incompatible options -b, -B");
	142	usage();
	143	}
	144
	145	if (flagB && pid == 0) {
	146	warnx("The -B option can only be used with the -p option");
	147	usage();
	148	}
	149
fc6d9e4b A	150	if (flagx) {
	151	ret = setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY, IOPOL_SCOPE_PROCESS, IOPOL_VFS_HFS_CASE_SENSITIVITY_FORCE_CASE_SENSITIVE);
	152	if (ret == -1) {
	153	err(EX_SOFTWARE, "setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY...)");
	154	}
	155	}
	156
	157	if (flagX) {
	158	ret = setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY, IOPOL_SCOPE_PROCESS, IOPOL_VFS_HFS_CASE_SENSITIVITY_DEFAULT);
	159	if (ret == -1) {
	160	err(EX_SOFTWARE, "setiopolicy_np(IOPOL_TYPE_VFS_HFS_CASE_SENSITIVITY...)");
	161	}
	162	}
	163
	164	if (flagb) {
1a7e3f61 A	165	ret = setpriority(PRIO_DARWIN_PROCESS, pid, PRIO_DARWIN_BG);
	166	if (ret == -1) {
	167	err(EX_SOFTWARE, "setpriority()");
	168	}
	169	}
	170
	171	if (flagB) {
	172	ret = setpriority(PRIO_DARWIN_PROCESS, pid, 0);
fc6d9e4b A	173	if (ret == -1) {
	174	err(EX_SOFTWARE, "setpriority()");
	175	}
	176	}
	177
	178	if (flagd >= 0) {
	179	ret = setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_PROCESS, flagd);
	180	if (ret == -1) {
	181	err(EX_SOFTWARE, "setiopolicy_np(...IOPOL_SCOPE_PROCESS...)");
	182	}
	183	}
	184
	185	if (flagg >= 0){
	186	ret = setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_DARWIN_BG, flagg);
	187	if (ret == -1) {
	188	err(EX_SOFTWARE, "setiopolicy_np(...IOPOL_SCOPE_DARWIN_BG...)");
	189	}
	190	}
	191
	192	if (qosinfo.task_latency_qos_tier != LATENCY_QOS_TIER_UNSPECIFIED \|\|
	193	qosinfo.task_throughput_qos_tier != THROUGHPUT_QOS_TIER_UNSPECIFIED){
1a7e3f61 A	194	mach_port_t task;
	195	if (pid) {
	196	ret = task_for_pid(mach_task_self(), pid, &task);
	197	if (ret != KERN_SUCCESS) {
	198	err(EX_SOFTWARE, "task_for_pid(%d) failed", pid);
	199	return EX_OSERR;
	200	}
	201	} else {
	202	task = mach_task_self();
	203	}
	204	ret = task_policy_set((task_t)task, TASK_OVERRIDE_QOS_POLICY, (task_policy_t)&qosinfo, TASK_QOS_POLICY_COUNT);
fc6d9e4b A	205	if (ret != KERN_SUCCESS){
	206	err(EX_SOFTWARE, "task_policy_set(...TASK_OVERRIDE_QOS_POLICY...)");
	207	}
	208	}
	209
1a7e3f61 A	210	if (pid != 0)
	211	return 0;
	212
	213
	214	ret = posix_spawnattr_init(&attr);
	215	if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawnattr_init");
	216
	217	ret = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETEXEC);
	218	if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawnattr_setflags");
	219
	220	if (qos_clamp != POSIX_SPAWN_PROC_CLAMP_NONE) {
	221	ret = posix_spawnattr_set_qos_clamp_np(&attr, qos_clamp);
	222	if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawnattr_set_qos_clamp_np");
	223	}
	224
	225	ret = posix_spawnp(&pid, argv[0], NULL, &attr, argv, environ);
	226	if (ret != 0) errc(EX_NOINPUT, ret, "posix_spawn");
	227
fc6d9e4b A	228	return EX_OSERR;
	229	}
	230
	231	static void usage(void)
	232	{
1a7e3f61 A	233	fprintf(stderr, "Usage: %s [-x\|-X] [-d <policy>] [-g policy] [-c clamp] [-b] [-t <tier>]\n"
	234	" [-l <tier>] <program> [<pargs> [...]]\n", getprogname());
	235	fprintf(stderr, " %s [-b\|-B] [-t <tier>] [-l <tier>] -p pid\n", getprogname());
fc6d9e4b A	236	exit(EX_USAGE);
	237	}
	238
	239	static int parse_disk_policy(const char *strpolicy)
	240	{
	241	long policy;
	242	char *endptr = NULL;
	243
	244	/* first try as an integer */
	245	policy = strtol(strpolicy, &endptr, 0);
	246	if (endptr && (endptr[0] == '\0') && (strpolicy[0] != '\0')) {
	247	/* parsed complete string as a number */
	248	return (int)policy;
	249	}
	250
	251	if (0 == strcasecmp(strpolicy, "DEFAULT") ) {
	252	return IOPOL_DEFAULT;
	253	} else if (0 == strcasecmp(strpolicy, "IMPORTANT")) {
	254	return IOPOL_IMPORTANT;
	255	} else if (0 == strcasecmp(strpolicy, "PASSIVE")) {
	256	return IOPOL_PASSIVE;
	257	} else if (0 == strcasecmp(strpolicy, "THROTTLE")) {
	258	return IOPOL_THROTTLE;
	259	} else if (0 == strcasecmp(strpolicy, "UTILITY")) {
	260	return IOPOL_UTILITY;
	261	} else if (0 == strcasecmp(strpolicy, "STANDARD")) {
	262	return IOPOL_STANDARD;
	263	} else {
	264	return -1;
	265	}
	266	}
	267
	268	static int parse_qos_tier(const char *strtier, int parameter){
	269	long policy;
	270	char *endptr = NULL;
	271
	272	/* first try as an integer */
	273	policy = strtol(strtier, &endptr, 0);
	274	if (endptr && (endptr[0] == '\0') && (strtier[0] != '\0')) {
	275	switch (policy) {
	276	case 0:
	277	return parameter ? THROUGHPUT_QOS_TIER_0 : LATENCY_QOS_TIER_0;
	278	break;
	279	case 1:
	280	return parameter ? THROUGHPUT_QOS_TIER_1 : LATENCY_QOS_TIER_1;
	281	break;
	282	case 2:
	283	return parameter ? THROUGHPUT_QOS_TIER_2 : LATENCY_QOS_TIER_2;
	284	break;
	285	case 3:
	286	return parameter ? THROUGHPUT_QOS_TIER_3 : LATENCY_QOS_TIER_3;
	287	break;
	288	case 4:
	289	return parameter ? THROUGHPUT_QOS_TIER_4 : LATENCY_QOS_TIER_4;
	290	break;
	291	case 5:
	292	return parameter ? THROUGHPUT_QOS_TIER_5 : LATENCY_QOS_TIER_5;
	293	break;
	294	default:
	295	return -1;
	296	break;
	297	}
	298	}
	299
300	return -1;
301	}
1a7e3f61 A	302
	303	static uint64_t parse_qos_clamp(const char *qos_string) {
	304
	305	if (0 == strcasecmp(qos_string, "utility") ) {
	306	return POSIX_SPAWN_PROC_CLAMP_UTILITY;
	307	} else if (0 == strcasecmp(qos_string, "background")) {
	308	return POSIX_SPAWN_PROC_CLAMP_BACKGROUND;
	309	} else if (0 == strcasecmp(qos_string, "maintenance")) {
	310	return POSIX_SPAWN_PROC_CLAMP_MAINTENANCE;
	311	} else {
	312	return POSIX_SPAWN_PROC_CLAMP_NONE;
	313	}
	314	}