Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/renice/renice.c	Lines:	0	78	0.0 %
Date:	2017-11-07	Branches:	0	59	0.0 %


/*	$OpenBSD: renice.c,v 1.20 2016/09/19 20:20:38 bluhm Exp $	*/

/*
 * Copyright (c) 2009, 2015 Todd C. Miller <Todd.Miller@courtesan.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

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

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define	RENICE_NONE		0
#define	RENICE_ABSOLUTE		1
#define	RENICE_INCREMENT	2

struct renice_param {
	int pri;
	short pri_type;
	short id_type;
	id_t id;
};

int main(int, char **);
static int renice(struct renice_param *, struct renice_param *);
__dead void usage(void);

int
main(int argc, char **argv)
{
	struct renice_param *params, *p;
	struct passwd *pw;
	int ch, id_type = PRIO_PROCESS;
	int pri = 0, pri_type = RENICE_NONE;
	char *ep, *idstr;
	const char *errstr;

	if (pledge("stdio getpw proc flock rpath cpath wpath", NULL) == -1)
		err(1, "pledge");

	if (argc < 3)
		usage();

	/* Allocate enough space for the worst case. */
	params = p = reallocarray(NULL, argc - 1, sizeof(*params));
	if (params == NULL)
		err(1, NULL);

	/* Backwards compatibility: first arg may be priority. */
	if (isdigit((unsigned char)argv[1][0]) ||
	    ((argv[1][0] == '+' || argv[1][0] == '-') &&
	    isdigit((unsigned char)argv[1][1]))) {
		pri = (int)strtol(argv[1], &ep, 10);
		if (*ep != '\0' || ep == argv[1]) {
			warnx("invalid priority %s", argv[1]);
			usage();
		}
		pri_type = RENICE_ABSOLUTE;
		optind = 2;
	}

	/*
	 * Slightly tricky getopt() usage since it is legal to have
	 * option flags interleaved with arguments.
	 */
	for (;;) {
		if ((ch = getopt(argc, argv, "g:n:p:u:")) != -1) {
			switch (ch) {
			case 'g':
				id_type = PRIO_PGRP;
				idstr = optarg;
				break;
			case 'n':
				pri = (int)strtol(optarg, &ep, 10);
				if (*ep != '\0' || ep == optarg) {
					warnx("invalid increment %s", optarg);
					usage();
				}

				/* Set priority for previous entries? */
				if (pri_type == RENICE_NONE) {
					struct renice_param *pp;
					for (pp = params; pp != p; pp++) {
						pp->pri = pri;
						pp->pri_type = RENICE_INCREMENT;
					}
				}
				pri_type = RENICE_INCREMENT;
				continue;
			case 'p':
				id_type = PRIO_PROCESS;
				idstr = optarg;
				break;
			case 'u':
				id_type = PRIO_USER;
				idstr = optarg;
				break;
			default:
				usage();
				break;
			}
		} else {
			idstr = argv[optind++];
			if (idstr == NULL)
				break;
		}
		p->id_type = id_type;
		p->pri = pri;
		p->pri_type = pri_type;
		if (id_type == PRIO_USER) {
			if ((pw = getpwnam(idstr)) == NULL) {
				uid_t id = strtonum(idstr, 0, UID_MAX, &errstr);
				if (!errstr)
					pw = getpwuid(id);
			}
			if (pw == NULL) {
				warnx("unknown user %s", idstr);
				continue;
			}
			p->id = pw->pw_uid;
		} else {
			p->id = strtonum(idstr, 0, UINT_MAX, &errstr);
			if (errstr) {
				warnx("%s is %s", idstr, errstr);
				continue;
			}
		}
		p++;
	}
	if (pri_type == RENICE_NONE)
		usage();
	return(renice(params, p));
}

static int
renice(struct renice_param *p, struct renice_param *end)
{
	int new, old, errors = 0;

	for (; p < end; p++) {
		errno = 0;
		old = getpriority(p->id_type, p->id);
		if (errno) {
			warn("getpriority: %d", p->id);
			errors++;
			continue;
		}
		if (p->pri_type == RENICE_INCREMENT)
			p->pri += old;
		new = p->pri > PRIO_MAX ? PRIO_MAX :
		    p->pri < PRIO_MIN ? PRIO_MIN : p->pri;
		if (setpriority(p->id_type, p->id, new) == -1) {
			warn("setpriority: %d", p->id);
			errors++;
			continue;
		}
		printf("%d: old priority %d, new priority %d\n",
		    p->id, old, new);
	}
	return (errors);
}

__dead void
usage(void)
{
	fprintf(stderr, "usage: renice [-n] increment [-gpu] id\n");
	exit(1);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: renice.c,v 1.20 2016/09/19 20:20:38 bluhm Exp $ */
2
3			/*
4			* Copyright (c) 2009, 2015 Todd C. Miller <Todd.Miller@courtesan.com>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <sys/types.h>
20			#include <sys/time.h>
21			#include <sys/resource.h>
22
23			#include <ctype.h>
24			#include <err.h>
25			#include <errno.h>
26			#include <limits.h>
27			#include <pwd.h>
28			#include <stdio.h>
29			#include <stdlib.h>
30			#include <string.h>
31			#include <unistd.h>
32
33			#define RENICE_NONE 0
34			#define RENICE_ABSOLUTE 1
35			#define RENICE_INCREMENT 2
36
37			struct renice_param {
38			int pri;
39			short pri_type;
40			short id_type;
41			id_t id;
42			};
43
44			int main(int, char **);
45			static int renice(struct renice_param , struct renice_param );
46			__dead void usage(void);
47
48			int
49			main(int argc, char **argv)
50			{
51			struct renice_param params, p;
52			struct passwd *pw;
53			int ch, id_type = PRIO_PROCESS;
54			int pri = 0, pri_type = RENICE_NONE;
55			char ep, idstr;
56			const char *errstr;
57
58			if (pledge("stdio getpw proc flock rpath cpath wpath", NULL) == -1)
59			err(1, "pledge");
60
61			if (argc < 3)
62			usage();
63
64			/* Allocate enough space for the worst case. */
65			params = p = reallocarray(NULL, argc - 1, sizeof(*params));
66			if (params == NULL)
67			err(1, NULL);
68
69			/* Backwards compatibility: first arg may be priority. */
70			if (isdigit((unsigned char)argv[1][0]) \|\|
71			((argv[1][0] == '+' \|\| argv[1][0] == '-') &&
72			isdigit((unsigned char)argv[1][1]))) {
73			pri = (int)strtol(argv[1], &ep, 10);
74			if (*ep != '\0' \|\| ep == argv[1]) {
75			warnx("invalid priority %s", argv[1]);
76			usage();
77			}
78			pri_type = RENICE_ABSOLUTE;
79			optind = 2;
80			}
81
82			/*
83			* Slightly tricky getopt() usage since it is legal to have
84			* option flags interleaved with arguments.
85			*/
86			for (;;) {
87			if ((ch = getopt(argc, argv, "g:n:p:u:")) != -1) {
88			switch (ch) {
89			case 'g':
90			id_type = PRIO_PGRP;
91			idstr = optarg;
92			break;
93			case 'n':
94			pri = (int)strtol(optarg, &ep, 10);
95			if (*ep != '\0' \|\| ep == optarg) {
96			warnx("invalid increment %s", optarg);
97			usage();
98			}
99
100			/* Set priority for previous entries? */
101			if (pri_type == RENICE_NONE) {
102			struct renice_param *pp;
103			for (pp = params; pp != p; pp++) {
104			pp->pri = pri;
105			pp->pri_type = RENICE_INCREMENT;
106			}
107			}
108			pri_type = RENICE_INCREMENT;
109			continue;
110			case 'p':
111			id_type = PRIO_PROCESS;
112			idstr = optarg;
113			break;
114			case 'u':
115			id_type = PRIO_USER;
116			idstr = optarg;
117			break;
118			default:
119			usage();
120			break;
121			}
122			} else {
123			idstr = argv[optind++];
124			if (idstr == NULL)
125			break;
126			}
127			p->id_type = id_type;
128			p->pri = pri;
129			p->pri_type = pri_type;
130			if (id_type == PRIO_USER) {
131			if ((pw = getpwnam(idstr)) == NULL) {
132			uid_t id = strtonum(idstr, 0, UID_MAX, &errstr);
133			if (!errstr)
134			pw = getpwuid(id);
135			}
136			if (pw == NULL) {
137			warnx("unknown user %s", idstr);
138			continue;
139			}
140			p->id = pw->pw_uid;
141			} else {
142			p->id = strtonum(idstr, 0, UINT_MAX, &errstr);
143			if (errstr) {
144			warnx("%s is %s", idstr, errstr);
145			continue;
146			}
147			}
148			p++;
149			}
150			if (pri_type == RENICE_NONE)
151			usage();
152			return(renice(params, p));
153			}
154
155			static int
156			renice(struct renice_param p, struct renice_param end)
157			{
158			int new, old, errors = 0;
159
160			for (; p < end; p++) {
161			errno = 0;
162			old = getpriority(p->id_type, p->id);
163			if (errno) {
164			warn("getpriority: %d", p->id);
165			errors++;
166			continue;
167			}
168			if (p->pri_type == RENICE_INCREMENT)
169			p->pri += old;
170			new = p->pri > PRIO_MAX ? PRIO_MAX :
171			p->pri < PRIO_MIN ? PRIO_MIN : p->pri;
172			if (setpriority(p->id_type, p->id, new) == -1) {
173			warn("setpriority: %d", p->id);
174			errors++;
175			continue;
176			}
177			printf("%d: old priority %d, new priority %d\n",
178			p->id, old, new);
179			}
180			return (errors);
181			}
182
183			__dead void
184			usage(void)
185			{
186			fprintf(stderr, "usage: renice [-n] increment [-gpu] id\n");
187			exit(1);
188			}