?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / priocntl / rtpriocntl.c
blob12efb5dc838f69bb8d2491cfca3895a39163f849
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
30 /* All Rights Reserved */
31
32
33 #include <stdio.h>
34 #include <string.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <sys/types.h>
38 #include <sys/time.h>
39 #include <sys/procset.h>
40 #include <sys/priocntl.h>
41 #include <sys/rtpriocntl.h>
42 #include <sys/param.h>
43 #include <signal.h>
44 #include <libgen.h>
45 #include <limits.h>
46 #include <errno.h>
47
48 #include "priocntl.h"
49
50 /*
51 * This file contains the class specific code implementing
52 * the real-time priocntl sub-command.
53 */
54
55 #define ADDKEYVAL(p, k, v) { (p[0]) = (k); (p[1]) = (v); p += 2; }
56
57 #define RT_KEYCNT 4 /* maximal number of (key, value) pairs */
58
59 /*
60 * control flags
61 */
62 #define RT_DOPRI 0x01 /* change priority */
63 #define RT_DOTQ 0x02 /* change RT time quantum */
64 #define RT_DOSIG 0x10 /* change RT time quantum signal */
65
66
67 static void print_rtinfo(void);
68 static int print_rtprocs(void);
69 static int rt_priocntl(idtype_t, id_t, int, char *, uintptr_t *);
70 static int set_rtprocs(idtype_t, int, char **, uint_t, pri_t, long,
71 long, int);
72 static void exec_rtcmd(char **, uint_t, pri_t, long, long, int);
73
74
75 static char usage[] =
76 "usage: priocntl -l\n"
77 " priocntl -d [-i idtype] [idlist]\n"
78 " priocntl -s [-c RT] [-p rtpri] [-t tqntm [-r res]] [-q tqsig]\n"
79 " [-i idtype] [idlist]\n"
80 " priocntl -e [-c RT] [-p rtpri] [-t tqntm [-r res]] [-q tqsig]\n"
81 " command [argument(s)]\n";
82
83 static char cmdpath[MAXPATHLEN];
84 static char basenm[BASENMSZ];
85
86
87 int
88 main(int argc, char *argv[])
89 {
90 int c;
91 int lflag, dflag, sflag, pflag;
92 int tflag, rflag, eflag, iflag, qflag;
93 pri_t rtpri;
94 long tqntm;
95 long res;
96 int tqsig;
97 char *idtypnm;
98 idtype_t idtype;
99 int idargc;
100 uint_t cflags;
101
102 (void) strlcpy(cmdpath, argv[0], MAXPATHLEN);
103 (void) strlcpy(basenm, basename(argv[0]), BASENMSZ);
104 lflag = dflag = sflag = pflag = 0;
105 tflag = rflag = eflag = iflag = qflag = 0;
106 while ((c = getopt(argc, argv, "ldsp:t:r:q:ec:i:")) != -1) {
107 switch (c) {
108
109 case 'l':
110 lflag++;
111 break;
112
113 case 'd':
114 dflag++;
115 break;
116
117 case 's':
118 sflag++;
119 break;
120
121 case 'p':
122 pflag++;
123 rtpri = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX);
124 if (errno)
125 fatalerr("%s: Specified real time priority %s"
126 " out of configured range\n",
127 basenm, optarg);
128 break;
129
130 case 't':
131 tflag++;
132 tqntm = str2num(optarg, 1, INT_MAX);
133 if (errno)
134 fatalerr("%s: Invalid time quantum specified;"
135 " time quantum must be positive\n", basenm);
136 break;
137
138 case 'r':
139 rflag++;
140 res = str2num(optarg, 1, 1000000000);
141 if (errno)
142 fatalerr("%s: Invalid resolution specified;"
143 " resolution must be between"
144 " 1 and 1,000,000,000\n", basenm);
145
146 break;
147
148 case 'q':
149 qflag++;
150 if (str2sig(optarg, &tqsig) != 0)
151 fatalerr("%s: Invalid real time quantum signal"
152 " specified\n", basenm);
153 break;
154
155 case 'e':
156 eflag++;
157 break;
158
159 case 'c':
160 if (strcmp(optarg, "RT") != 0)
161 fatalerr("error: %s executed for %s class, %s"
162 " is actually sub-command for RT class\n",
163 cmdpath, optarg, cmdpath);
164 break;
165
166 case 'i':
167 iflag++;
168 idtypnm = optarg;
169 break;
170
171 case '?':
172 fatalerr(usage);
173
174 default:
175 break;
176 }
177 }
178
179 if (lflag) {
180 if (dflag || sflag || pflag || tflag || rflag || eflag ||
181 iflag || qflag)
182 fatalerr(usage);
183
184 print_rtinfo();
185
186 } else if (dflag) {
187 if (lflag || sflag || pflag || tflag || rflag || eflag || qflag)
188 fatalerr(usage);
189
190 return (print_rtprocs());
191
192 } else if (sflag) {
193 if (lflag || dflag || eflag)
194 fatalerr(usage);
195
196 if (iflag) {
197 if (str2idtyp(idtypnm, &idtype) == -1)
198 fatalerr("%s: Bad idtype %s\n", basenm,
199 idtypnm);
200 } else {
201 idtype = P_PID;
202 }
203
204 cflags = (pflag ? RT_DOPRI : 0);
205
206 if (tflag)
207 cflags |= RT_DOTQ;
208
209 if (rflag == 0)
210 res = 1000;
211
212 if (optind < argc)
213 idargc = argc - optind;
214 else
215 idargc = 0;
216
217 if (qflag)
218 cflags |= RT_DOSIG;
219
220 return (set_rtprocs(idtype, idargc, &argv[optind], cflags,
221 rtpri, tqntm, res, tqsig));
222
223 } else if (eflag) {
224 if (lflag || dflag || sflag || iflag)
225 fatalerr(usage);
226
227 cflags = (pflag ? RT_DOPRI : 0);
228
229 if (tflag)
230 cflags |= RT_DOTQ;
231
232 if (rflag == 0)
233 res = 1000;
234
235 if (qflag)
236 cflags |= RT_DOSIG;
237
238 exec_rtcmd(&argv[optind], cflags, rtpri, tqntm, res, tqsig);
239
240 } else {
241 fatalerr(usage);
242 }
243
244 return (0);
245 }
246
247
248 /*
249 * Print our class name and the configured user priority range.
250 */
251 static void
252 print_rtinfo(void)
253 {
254 pcinfo_t pcinfo;
255
256 (void) strcpy(pcinfo.pc_clname, "RT");
257
258 (void) printf("RT (Real Time)\n");
259
260 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
261 fatalerr("\tCan't get maximum configured RT priority\n");
262
263 (void) printf("\tConfigured RT User Priority Range: 0 through %d\n",
264 ((rtinfo_t *)pcinfo.pc_clinfo)->rt_maxpri);
265 }
266
267
268 /*
269 * Read a list of pids from stdin and print the real-time priority and time
270 * quantum (in millisecond resolution) for each of the corresponding processes.
271 */
272 static int
273 print_rtprocs(void)
274 {
275 pid_t *pidlist;
276 size_t numread;
277 int i;
278 char clname[PC_CLNMSZ];
279 pri_t rt_pri;
280 uint_t rt_tqsecs;
281 int rt_tqnsecs;
282 int rt_tqsig;
283 int error = 0;
284
285 /*
286 * Read a list of pids from stdin.
287 */
288 if ((pidlist = read_pidlist(&numread, stdin)) == NULL)
289 fatalerr("%s: Can't read pidlist.\n", basenm);
290
291 (void) printf("REAL TIME PROCESSES:\n"
292 " PID RTPRI TQNTM TQSIG\n");
293
294 if (numread == 0)
295 fatalerr("%s: No pids on input\n", basenm);
296
297 for (i = 0; i < numread; i++) {
298 (void) printf("%7ld", pidlist[i]);
299 if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, "RT",
300 RT_KY_TQSECS, &rt_tqsecs, RT_KY_TQNSECS, &rt_tqnsecs,
301 RT_KY_PRI, &rt_pri, RT_KY_TQSIG, &rt_tqsig, 0) != -1) {
302 (void) printf(" %5d", rt_pri);
303 if (rt_tqnsecs == RT_TQINF)
304 (void) printf(" RT_TQINF");
305 else
306 (void) printf(" %11lld",
307 (longlong_t)rt_tqsecs * 1000 +
308 rt_tqnsecs / 1000000);
309
310 (void) printf(" %3d\n", rt_tqsig);
311 } else {
312 error = 1;
313
314 if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, NULL,
315 PC_KY_CLNAME, clname, 0) != -1 &&
316 strcmp(clname, "RT"))
317 /*
318 * Process from some class other than real time.
319 * It has probably changed class while priocntl
320 * command was executing (otherwise we wouldn't
321 * have been passed its pid). Print the little
322 * we know about it.
323 */
324 (void) printf("\tChanged to class %s while"
325 " priocntl command executing\n", clname);
326 else
327 (void) printf("\tCan't get real time"
328 " parameters\n");
329 }
330 }
331
332 free_pidlist(pidlist);
333 return (error);
334 }
335
336
337 /*
338 * Call priocntl() with command codes PC_SETXPARMS or PC_GETXPARMS.
339 * The first parameter behind the command code is always the class name.
340 * Each parameter is headed by a key, which determines the meaning of the
341 * following value. There are maximal RT_KEYCNT = 4 (key, value) pairs.
342 */
343 static int
344 rt_priocntl(idtype_t idtype, id_t id, int cmd, char *clname, uintptr_t *argsp)
345 {
346 return (priocntl(idtype, id, cmd, clname, argsp[0], argsp[1],
347 argsp[2], argsp[3], argsp[4], argsp[5], argsp[6], argsp[7], 0));
348 }
349
350
351 /*
352 * Set all processes in the set specified by idtype/idargv to real time
353 * (if they aren't already real time) and set their real-time priority,
354 * real-time quantum and real-time quantum signal to those specified by
355 * rtpri, tqntm/res and rtqsig.
356 */
357 static int
358 set_rtprocs(idtype_t idtype, int idargc, char **idargv, uint_t cflags,
359 pri_t rtpri, long tqntm, long res, int rtqsig)
360 {
361 pcinfo_t pcinfo;
362 uintptr_t args[2*RT_KEYCNT+1];
363 uintptr_t *argsp = &args[0];
364 pri_t maxrtpri;
365 hrtimer_t hrtime;
366 char idtypnm[PC_IDTYPNMSZ];
367 int i;
368 id_t id;
369 int error = 0;
370
371
372 /*
373 * Get the real time class ID and max configured RT priority.
374 */
375 (void) strcpy(pcinfo.pc_clname, "RT");
376 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
377 fatalerr("%s: Can't get RT class ID, priocntl system call"
378 " failed with errno %d\n", basenm, errno);
379 maxrtpri = ((rtinfo_t *)pcinfo.pc_clinfo)->rt_maxpri;
380
381 /*
382 * Validate the rtpri and res arguments.
383 */
384 if ((cflags & RT_DOPRI) != 0) {
385 if (rtpri > maxrtpri || rtpri < 0)
386 fatalerr("%s: Specified real time priority %d out of"
387 " configured range\n", basenm, rtpri);
388 ADDKEYVAL(argsp, RT_KY_PRI, rtpri);
389 }
390
391 if ((cflags & RT_DOTQ) != 0) {
392 hrtime.hrt_secs = 0;
393 hrtime.hrt_rem = tqntm;
394 hrtime.hrt_res = res;
395 if (_hrtnewres(&hrtime, NANOSEC, HRT_RNDUP) == -1)
396 fatalerr("%s: Can't convert resolution.\n", basenm);
397 ADDKEYVAL(argsp, RT_KY_TQSECS, hrtime.hrt_secs);
398 ADDKEYVAL(argsp, RT_KY_TQNSECS, hrtime.hrt_rem);
399 }
400
401 if ((cflags & RT_DOSIG) != 0)
402 ADDKEYVAL(argsp, RT_KY_TQSIG, rtqsig);
403 *argsp = 0;
404
405 if (idtype == P_ALL) {
406 if (rt_priocntl(P_ALL, 0, PC_SETXPARMS, "RT", args) == -1) {
407 if (errno == EPERM) {
408 (void) fprintf(stderr,
409 "Permissions error encountered"
410 " on one or more processes.\n");
411 error = 1;
412 } else {
413 fatalerr("%s: Can't reset real time parameters"
414 "\npriocntl system call failed with"
415 " errno %d\n", basenm, errno);
416 }
417 }
418 } else if (idargc == 0) {
419 if (rt_priocntl(idtype, P_MYID, PC_SETXPARMS, "RT",
420 args) == -1) {
421 if (errno == EPERM) {
422 (void) idtyp2str(idtype, idtypnm);
423 (void) fprintf(stderr, "Permissions error"
424 " encountered on current %s.\n", idtypnm);
425 error = 1;
426 } else {
427 fatalerr("%s: Can't reset real time parameters"
428 "\npriocntl system call failed with"
429 " errno %d\n", basenm, errno);
430 }
431 }
432 } else {
433 (void) idtyp2str(idtype, idtypnm);
434 for (i = 0; i < idargc; i++) {
435 if (idtype == P_CID) {
436 (void) strcpy(pcinfo.pc_clname, idargv[i]);
437 if (priocntl(0, 0, PC_GETCID,
438 (caddr_t)&pcinfo) == -1)
439 fatalerr("%s: Invalid or unconfigured"
440 " class %s, priocntl system call"
441 " failed with errno %d\n",
442 basenm, pcinfo.pc_clname, errno);
443 id = pcinfo.pc_cid;
444 } else {
445 id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX);
446 if (errno)
447 fatalerr("%s: Invalid id \"%s\"\n",
448 basenm, idargv[i]);
449 }
450
451 if (rt_priocntl(idtype, id, PC_SETXPARMS, "RT",
452 args) == -1) {
453 if (errno == EPERM) {
454 (void) fprintf(stderr,
455 "Permissions error encountered on"
456 " %s %s.\n", idtypnm, idargv[i]);
457 error = 1;
458 } else {
459 fatalerr("%s: Can't reset real time"
460 " parameters\npriocntl system call"
461 " failed with errno %d\n",
462 basenm, errno);
463 }
464 }
465 }
466 }
467
468 return (error);
469 }
470
471
472 /*
473 * Execute the command pointed to by cmdargv as a real-time process
474 * with real time priority rtpri, quantum tqntm/res and quantum signal rtqsig.
475 */
476 static void
477 exec_rtcmd(char **cmdargv, uint_t cflags, pri_t rtpri, long tqntm, long res,
478 int rtqsig)
479 {
480 pcinfo_t pcinfo;
481 uintptr_t args[2*RT_KEYCNT+1];
482 uintptr_t *argsp = &args[0];
483 pri_t maxrtpri;
484 hrtimer_t hrtime;
485
486 /*
487 * Get the real time class ID and max configured RT priority.
488 */
489 (void) strcpy(pcinfo.pc_clname, "RT");
490 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
491 fatalerr("%s: Can't get RT class ID, priocntl system call"
492 " failed with errno %d\n", basenm, errno);
493 maxrtpri = ((rtinfo_t *)pcinfo.pc_clinfo)->rt_maxpri;
494
495 if ((cflags & RT_DOPRI) != 0) {
496 if (rtpri > maxrtpri || rtpri < 0)
497 fatalerr("%s: Specified real time priority %d out of"
498 " configured range\n", basenm, rtpri);
499 ADDKEYVAL(argsp, RT_KY_PRI, rtpri);
500 }
501
502 if ((cflags & RT_DOTQ) != 0) {
503 hrtime.hrt_secs = 0;
504 hrtime.hrt_rem = tqntm;
505 hrtime.hrt_res = res;
506 if (_hrtnewres(&hrtime, NANOSEC, HRT_RNDUP) == -1)
507 fatalerr("%s: Can't convert resolution.\n", basenm);
508 ADDKEYVAL(argsp, RT_KY_TQSECS, hrtime.hrt_secs);
509 ADDKEYVAL(argsp, RT_KY_TQNSECS, hrtime.hrt_rem);
510 }
511
512 if ((cflags & RT_DOSIG) != 0)
513 ADDKEYVAL(argsp, RT_KY_TQSIG, rtqsig);
514 *argsp = 0;
515
516 if (rt_priocntl(P_PID, P_MYID, PC_SETXPARMS, "RT", args) == -1)
517 fatalerr("%s: Can't reset real time parameters\n"
518 "priocntl system call failed with errno %d\n",
519 basenm, errno);
520
521 (void) execvp(cmdargv[0], cmdargv);
522 fatalerr("%s: Can't execute %s, exec failed with errno %d\n",
523 basenm, cmdargv[0], errno);
524 }
unleashed repo fork