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 } 727