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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30
31 #include <stdio.h>
32 #include <string.h>
33 #include <strings.h>
34 #include <stdlib.h>
35 #include <unistd.h>
36 #include <sys/types.h>
37 #include <limits.h>
38 #include <dirent.h>
39 #include <fcntl.h>
40 #include <sys/time.h>
41 #include <sys/procset.h>
42 #include <sys/priocntl.h>
43 #include <sys/task.h>
44 #include <procfs.h>
45 #include <project.h>
46 #include <errno.h>
47 #include <zone.h>
48 #include <libcontract_priv.h>
49
50 #include "priocntl.h"
51
52 /*LINTLIBRARY*/
53
54 /*
55 * Utility functions for priocntl command.
56 */
57
58 static char *procdir = "/proc";
59
60 /*PRINTFLIKE1*/
61 void
62 fatalerr(format, a1, a2, a3, a4, a5)
63 char *format;
64 int a1, a2, a3, a4, a5;
65 {
66 (void) fprintf(stderr, format, a1, a2, a3, a4, a5);
67 exit(1);
68 }
69
70
71 /*
72 * Structure defining idtypes known to the priocntl command
73 * along with the corresponding names
74 * The idtype values themselves are defined in <sys/procset.h>.
75 */
76 static struct idtypes {
77 idtype_t idtype;
78 char *idtypnm;
79 } idtypes [] = {
80 { P_PID, "pid" },
81 { P_PPID, "ppid" },
82 { P_PGID, "pgid" },
83 { P_SID, "sid" },
84 { P_CID, "class" },
85 { P_UID, "uid" },
86 { P_GID, "gid" },
87 { P_PROJID, "projid" },
88 { P_TASKID, "taskid" },
89 { P_ZONEID, "zoneid" },
90 { P_CTID, "ctid" },
91 { P_ALL, "all" }
92 };
93
94 #define IDCNT (sizeof (idtypes) / sizeof (struct idtypes))
95
96
97 int
98 str2idtyp(idtypnm, idtypep)
99 char *idtypnm;
100 idtype_t *idtypep;
101 {
102 register struct idtypes *curp;
103 register struct idtypes *endp;
104
105 for (curp = idtypes, endp = &idtypes[IDCNT]; curp < endp; curp++) {
106 if (strcmp(curp->idtypnm, idtypnm) == 0) {
107 *idtypep = curp->idtype;
108 return (0);
109 }
110 }
111 return (-1);
112 }
113
114
115 int
116 idtyp2str(idtype, idtypnm)
117 idtype_t idtype;
118 char *idtypnm;
119 {
120 register struct idtypes *curp;
121 register struct idtypes *endp;
122
123 for (curp = idtypes, endp = &idtypes[IDCNT]; curp < endp; curp++) {
124 if (idtype == curp->idtype) {
125 (void) strncpy(idtypnm, curp->idtypnm, PC_IDTYPNMSZ);
126 return (0);
127 }
128 }
129 return (-1);
130 }
131
132
133 /*
134 * Compare two IDs for equality.
135 */
136 int
137 idcompar(id1p, id2p)
138 id_t *id1p;
139 id_t *id2p;
140 {
141 if (*id1p == *id2p)
142 return (0);
143 else
144 return (-1);
145 }
146
147
148 id_t
149 clname2cid(clname)
150 char *clname;
151 {
152 pcinfo_t pcinfo;
153
154 (void) strncpy(pcinfo.pc_clname, clname, PC_CLNMSZ);
155 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
156 return ((id_t)-1);
157 return (pcinfo.pc_cid);
158 }
159
160
161 int
162 getmyid(idtype, idptr)
163 idtype_t idtype;
164 id_t *idptr;
165 {
166 pcinfo_t pcinfo;
167
168 switch (idtype) {
169
170 case P_PID:
171 *idptr = (id_t)getpid();
172 break;
173
174 case P_PPID:
175 *idptr = (id_t)getppid();
176 break;
177
178 case P_PGID:
179 *idptr = (id_t)getpgrp();
180 break;
181
182 case P_SID:
183 *idptr = (id_t)getsid(getpid());
184 break;
185
186 case P_CID:
187 if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
188 PC_KY_CLNAME, pcinfo.pc_clname, 0) == -1 ||
189 priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
190 return (-1);
191
192 *idptr = pcinfo.pc_cid;
193 break;
194
195 case P_UID:
196 *idptr = (id_t)getuid();
197 break;
198
199 case P_GID:
200 *idptr = (id_t)getgid();
201 break;
202
203 case P_PROJID:
204 *idptr = (id_t)getprojid();
205 break;
206
207 case P_TASKID:
208 *idptr = (id_t)gettaskid();
209 break;
210
211 case P_ZONEID:
212 *idptr = (id_t)getzoneid();
213 break;
214
215 case P_CTID: {
216 ctid_t id = getctid();
217 if (id == -1)
218 return (-1);
219 *idptr = id;
220 break;
221 }
222
223 default:
224 return (-1);
225 }
226 return (0);
227 }
228
229
230 int
231 getmyidstr(idtype, idstr)
232 idtype_t idtype;
233 char *idstr;
234 {
235 char clname[PC_CLNMSZ];
236
237 switch (idtype) {
238
239 case P_PID:
240 itoa((long)getpid(), idstr);
241 break;
242
243 case P_PPID:
244 itoa((long)getppid(), idstr);
245 break;
246
247 case P_PGID:
248 itoa((long)getpgrp(), idstr);
249 break;
250 case P_SID:
251 itoa((long)getsid(getpid()), idstr);
252 break;
253
254 case P_CID:
255 if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
256 PC_KY_CLNAME, clname, 0) == -1)
257 return (-1);
258 (void) strncpy(idstr, clname, PC_CLNMSZ);
259 break;
260
261 case P_UID:
262 itoa((long)getuid(), idstr);
263 break;
264
265 case P_GID:
266 itoa((long)getgid(), idstr);
267 break;
268
269 case P_PROJID:
270 itoa((long)getprojid(), idstr);
271 break;
272
273 case P_TASKID:
274 itoa((long)gettaskid(), idstr);
275 break;
276
277 case P_ZONEID:
278 itoa((long)getzoneid(), idstr);
279 break;
280
281 case P_CTID: {
282 id_t id;
283 if ((id = getctid()) == -1)
284 return (-1);
285 itoa((long)id, idstr);
286 break;
287 }
288
289 default:
290 return (-1);
291 }
292 return (0);
293 }
294
295 /*
296 * Look for pids with "upri > uprilim" in the set specified by idtype/id.
297 * If upri exceeds uprilim then print a warning.
298 */
299 int
300 verifyupri(idtype_t idtype, id_t id, char *clname, int key,
301 pri_t upri, char *basenm)
302 {
303 psinfo_t prinfo;
304 prcred_t prcred;
305 DIR *dirp;
306 struct dirent *dentp;
307 char pname[MAXNAMLEN];
308 char *fname;
309 int procfd;
310 int saverr;
311 pri_t uprilim;
312 int verify;
313 int error = 0;
314
315 if (idtype == P_PID) {
316 if (priocntl(P_PID, id, PC_GETXPARMS, clname, key,
317 &uprilim, 0) == -1)
318 error = -1;
319 else if (upri > uprilim)
320 (void) fprintf(stderr,
321 "%s: Specified user priority %d exceeds"
322 " limit %d; set to %d (pid %d)\n",
323 basenm, upri, uprilim, uprilim, (int)id);
324
325 return (error);
326 }
327
328 /*
329 * Look for the processes in the set specified by idtype/id.
330 * We read the /proc/<pid>/psinfo file to get the necessary
331 * process information.
332 */
333
334 if ((dirp = opendir(procdir)) == NULL)
335 fatalerr("%s: Can't open PROC directory %s\n",
336 basenm, procdir);
337
338 while ((dentp = readdir(dirp)) != NULL) {
339 if (dentp->d_name[0] == '.') /* skip . and .. */
340 continue;
341
342 (void) snprintf(pname, MAXNAMLEN, "%s/%s/",
343 procdir, dentp->d_name);
344 fname = pname + strlen(pname);
345 retry:
346 (void) strncpy(fname, "psinfo", strlen("psinfo") + 1);
347 if ((procfd = open(pname, O_RDONLY)) < 0)
348 continue;
349 if (read(procfd, &prinfo, sizeof (prinfo)) != sizeof (prinfo)) {
350 saverr = errno;
351 (void) close(procfd);
352 if (saverr == EAGAIN)
353 goto retry;
354 continue;
355 }
356 (void) close(procfd);
357
358 if (idtype == P_UID || idtype == P_GID) {
359 (void) strncpy(fname, "cred", strlen("cred") + 1);
360 if ((procfd = open(pname, O_RDONLY)) < 0 ||
361 read(procfd, &prcred, sizeof (prcred)) !=
362 sizeof (prcred)) {
363 saverr = errno;
364 (void) close(procfd);
365 if (saverr == EAGAIN)
366 goto retry;
367 continue;
368 }
369 (void) close(procfd);
370 }
371
372 if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0)
373 continue;
374
375 /*
376 * The lwp must be in the correct class.
377 */
378 if (strncmp(clname, prinfo.pr_lwp.pr_clname, PC_CLNMSZ) != 0)
379 continue;
380
381 verify = 0;
382 switch (idtype) {
383
384 case P_PPID:
385 if (id == (id_t)prinfo.pr_ppid)
386 verify++;
387 break;
388
389 case P_PGID:
390 if (id == (id_t)prinfo.pr_pgid)
391 verify++;
392 break;
393
394 case P_SID:
395 if (id == (id_t)prinfo.pr_sid)
396 verify++;
397 break;
398
399 case P_UID:
400 if (id == (id_t)prcred.pr_euid)
401 verify++;
402 break;
403
404 case P_GID:
405 if (id == (id_t)prcred.pr_egid)
406 verify++;
407 break;
408
409 case P_PROJID:
410 if (id == (id_t)prinfo.pr_projid)
411 verify++;
412 break;
413
414 case P_TASKID:
415 if (id == (id_t)prinfo.pr_taskid)
416 verify++;
417 break;
418
419 case P_ZONEID:
420 if (id == (id_t)prinfo.pr_zoneid)
421 verify++;
422 break;
423
424 case P_CTID:
425 if (id == (id_t)prinfo.pr_contract)
426 verify++;
427 break;
428
429 case P_CID:
430 case P_ALL:
431 verify++;
432 break;
433
434 default:
435 fatalerr("%s: Bad idtype %d in verifyupri()\n",
436 basenm, idtype);
437 }
438
439 if (verify) {
440 if (priocntl(P_PID, prinfo.pr_pid, PC_GETXPARMS,
441 clname, key, &uprilim, 0) == -1)
442 error = -1;
443 else if (upri > uprilim)
444 (void) fprintf(stderr,
445 "%s: Specified user priority %d exceeds"
446 " limit %d; set to %d (pid %d)\n",
447 basenm, upri, uprilim, uprilim,
448 (int)prinfo.pr_pid);
449 }
450 }
451 (void) closedir(dirp);
452
453 return (error);
454 }
455
456
457 /*
458 * Read a list of pids from a stream.
459 */
460 pid_t *
461 read_pidlist(size_t *npidsp, FILE *filep)
462 {
463 size_t nitems;
464 pid_t *pidlist = NULL;
465
466 *npidsp = 0;
467
468 do {
469 if ((pidlist = (pid_t *)realloc(pidlist,
470 (*npidsp + NPIDS) * sizeof (pid_t))) == NULL)
471 return (NULL);
472
473 nitems = fread(pidlist + *npidsp, sizeof (pid_t), NPIDS, filep);
474 if (ferror(filep))
475 return (NULL);
476
477 *npidsp += nitems;
478 } while (nitems == NPIDS);
479
480 return (pidlist);
481 }
482
483
484 void
485 free_pidlist(pid_t *pidlist)
486 {
487 free(pidlist);
488 }
489
490
491 long
492 str2num(char *p, long min, long max)
493 {
494 long val;
495 char *q;
496 errno = 0;
497
498 val = strtol(p, &q, 10);
499 if (errno != 0 || q == p || *q != '\0' || val < min || val > max)
500 errno = EINVAL;
501
502 return (val);
503 }
504
505
506 /*
507 * itoa() and reverse() taken almost verbatim from K & R Chapter 3.
508 */
509 static void reverse();
510
511 /*
512 * itoa(): Convert n to characters in s.
513 */
514 void
515 itoa(n, s)
516 long n;
517 char *s;
518 {
519 long i, sign;
520
521 if ((sign = n) < 0) /* record sign */
522 n = -n; /* make sign positive */
523 i = 0;
524 do { /* generate digits in reverse order */
525 s[i++] = n % 10 + '0'; /* get next digit */
526 } while ((n /= 10) > 0); /* delete it */
527 if (sign < 0)
528 s[i++] = '-';
529 s[i] = '\0';
530 reverse(s);
531 }
532
533
534 /*
535 * reverse(): Reverse string s in place.
536 */
537 static void
538 reverse(s)
539 char *s;
540 {
541 int c, i, j;
542
543 for (i = 0, j = strlen(s) - 1; i < j; i++, j--) {
544 c = s[i];
545 s[i] = s[j];
546 s[j] = (char)c;
547 }
548 }
549
550
551 /*
552 * The following routine was removed from libc (libc/port/gen/hrtnewres.c).
553 * It has also been added to disadmin, so if you fix it here, you should
554 * also probably fix it there. In the long term, this should be recoded to
555 * not be hrt'ish.
556 */
557
558 /*
559 * Convert interval expressed in htp->hrt_res to new_res.
560 *
561 * Calculate: (interval * new_res) / htp->hrt_res rounding off as
562 * specified by round.
563 *
564 * Note: All args are assumed to be positive. If
565 * the last divide results in something bigger than
566 * a long, then -1 is returned instead.
567 */
568
569 int
570 _hrtnewres(htp, new_res, round)
571 register hrtimer_t *htp;
572 register ulong_t new_res;
573 long round;
574 {
575 register long interval;
576 longlong_t dint;
577 longlong_t dto_res;
578 longlong_t drem;
579 longlong_t dfrom_res;
580 longlong_t prod;
581 longlong_t quot;
582 register long numerator;
583 register long result;
584 ulong_t modulus;
585 ulong_t twomodulus;
586 long temp;
587
588 if (new_res > NANOSEC || htp->hrt_rem < 0)
589 return (-1);
590
591 if (htp->hrt_rem >= htp->hrt_res) {
592 htp->hrt_secs += htp->hrt_rem / htp->hrt_res;
593 htp->hrt_rem = htp->hrt_rem % htp->hrt_res;
594 }
595
596 interval = htp->hrt_rem;
597 if (interval == 0) {
598 htp->hrt_res = new_res;
599 return (0);
600 }
601
602 /*
603 * Try to do the calculations in single precision first
604 * (for speed). If they overflow, use double precision.
605 * What we want to compute is:
606 *
607 * (interval * new_res) / hrt->hrt_res
608 */
609
610 numerator = interval * new_res;
611
612 if (numerator / new_res == interval) {
613
614 /*
615 * The above multiply didn't give overflow since
616 * the division got back the original number. Go
617 * ahead and compute the result.
618 */
619
620 result = numerator / htp->hrt_res;
621
622 /*
623 * For HRT_RND, compute the value of:
624 *
625 * (interval * new_res) % htp->hrt_res
626 *
627 * If it is greater than half of the htp->hrt_res,
628 * then rounding increases the result by 1.
629 *
630 * For HRT_RNDUP, we increase the result by 1 if:
631 *
632 * result * htp->hrt_res != numerator
633 *
634 * because this tells us we truncated when calculating
635 * result above.
636 *
637 * We also check for overflow when incrementing result
638 * although this is extremely rare.
639 */
640
641 if (round == HRT_RND) {
642 modulus = numerator - result * htp->hrt_res;
643 if ((twomodulus = 2 * modulus) / 2 == modulus) {
644
645 /*
646 * No overflow (if we overflow in calculation
647 * of twomodulus we fall through and use
648 * double precision).
649 */
650 if (twomodulus >= htp->hrt_res) {
651 temp = result + 1;
652 if (temp - 1 == result)
653 result++;
654 else
655 return (-1);
656 }
657 htp->hrt_res = new_res;
658 htp->hrt_rem = result;
659 return (0);
660 }
661 } else if (round == HRT_RNDUP) {
662 if (result * htp->hrt_res != numerator) {
663 temp = result + 1;
664 if (temp - 1 == result)
665 result++;
666 else
667 return (-1);
668 }
669 htp->hrt_res = new_res;
670 htp->hrt_rem = result;
671 return (0);
672 } else { /* round == HRT_TRUNC */
673 htp->hrt_res = new_res;
674 htp->hrt_rem = result;
675 return (0);
676 }
677 }
678
679 /*
680 * We would get overflow doing the calculation is
681 * single precision so do it the slow but careful way.
682 *
683 * Compute the interval times the resolution we are
684 * going to.
685 */
686
687 dint = interval;
688 dto_res = new_res;
689 prod = dint * dto_res;
690
691 /*
692 * For HRT_RND the result will be equal to:
693 *
694 * ((interval * new_res) + htp->hrt_res / 2) / htp->hrt_res
695 *
696 * and for HRT_RNDUP we use:
697 *
698 * ((interval * new_res) + htp->hrt_res - 1) / htp->hrt_res
699 *
700 * This is a different but equivalent way of rounding.
701 */
702
703 if (round == HRT_RND) {
704 drem = htp->hrt_res / 2;
705 prod = prod + drem;
706 } else if (round == HRT_RNDUP) {
707 drem = htp->hrt_res - 1;
708 prod = prod + drem;
709 }
710
711 dfrom_res = htp->hrt_res;
712 quot = prod / dfrom_res;
713
714 /*
715 * If the quotient won't fit in a long, then we have
716 * overflow. Otherwise, return the result.
717 */
718
719 if (quot > UINT_MAX) {
720 return (-1);
721 } else {
722 htp->hrt_res = new_res;
723 htp->hrt_rem = (int)quot;
724 return (0);
725 }
726 }