?  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 / priocntl.c
blobf599c18dad7053e2a3c18a88524ca813ffd91468
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 #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 <stdlib.h>
35 #include <string.h>
36 #include <wait.h>
37 #include <search.h>
38 #include <unistd.h>
39 #include <sys/types.h>
40 #include <dirent.h>
41 #include <fcntl.h>
42 #include <sys/param.h>
43 #include <sys/procset.h>
44 #include <sys/priocntl.h>
45 #include <procfs.h>
46 #include <macros.h>
47 #include <libgen.h>
48 #include <limits.h>
49 #include <errno.h>
50
51 #include "priocntl.h"
52
53 /*
54 * This file contains the code implementing the class independent part
55 * of the priocntl command. Most of the useful work for the priocntl
56 * command is done by the class specific sub-commands, the code for
57 * which is elsewhere. The class independent part of the command is
58 * responsible for executing the appropriate class specific sub-commands
59 * and providing any necessary input to the sub-commands.
60 * Code in this file should never assume any knowledge of any specific
61 * scheduler class (other than the SYS class).
62 */
63
64 #define CLASSPATH "/usr/lib/class"
65
66 typedef struct classpids {
67 char clp_clname[PC_CLNMSZ];
68 pid_t *clp_pidlist;
69 int clp_pidlistsz;
70 int clp_npids;
71 } classpids_t;
72
73 static char usage[] =
74 "usage: priocntl -l\n\
75 priocntl -d [-i idtype] [idlist]\n\
76 priocntl -s [-c class] [c.s.o.] [-i idtype] [idlist]\n\
77 priocntl -e [-c class] [c.s.o.] command [argument(s)]\n";
78
79 static char basenm[BASENMSZ];
80 static char cmdpath[MAXPATHLEN];
81
82 static char *procdir = "/proc";
83
84 static int print_classlist(void);
85 static void set_procs(char *, idtype_t, int, char **, char **);
86 static void exec_cmd(char *, char **);
87 static int print_procs(idtype_t, int, char *[]);
88 static void ids2pids(idtype_t, id_t *, int, classpids_t *, int);
89 static void add_pid_tolist(classpids_t *, int, char *, pid_t);
90 static void increase_pidlist(classpids_t *);
91 static boolean_t idmatch(char *, char *, int, char **);
92
93 /*
94 * These variables are defined to be used in prio_getopt() below.
95 */
96 static int prio_getopt();
97 /* LINTED static unused */
98 static int prio_optopt = 0;
99 static char *prio_optarg = 0;
100 static int prio_optind = 1;
101 static int prio_sp = 1;
102
103 int
104 main(int argc, char *argv[])
105 {
106 int c;
107 int lflag, dflag, sflag, eflag, cflag, iflag, csoptsflag;
108 char *clname;
109 char *idtypnm;
110 idtype_t idtype;
111 int idargc;
112 char **idargv;
113
114 (void) strlcpy(cmdpath, argv[0], MAXPATHLEN);
115 (void) strlcpy(basenm, basename(argv[0]), BASENMSZ);
116 lflag = dflag = sflag = eflag = cflag = iflag = csoptsflag = 0;
117 while ((c = prio_getopt(argc, argv, "ldsec:i:")) != -1) {
118
119 switch (c) {
120
121 case 'l':
122 lflag++;
123 break;
124
125 case 'd':
126 dflag++;
127 break;
128
129 case 's':
130 sflag++;
131 break;
132
133 case 'e':
134 eflag++;
135 break;
136
137 case 'c':
138 cflag++;
139 clname = prio_optarg;
140 break;
141
142 case 'i':
143 iflag++;
144 idtypnm = prio_optarg;
145 break;
146
147 case '?':
148 if (strcmp(argv[prio_optind - 1], "-c") == 0 ||
149 strcmp(argv[prio_optind - 1], "-i") == 0) {
150
151 /*
152 * getopt() will return ? if either
153 * of these appear without an argument.
154 */
155 fatalerr(usage);
156 }
157
158 /*
159 * We assume for now that any option that
160 * getopt() doesn't recognize (with the
161 * exception of c and i) is intended for a
162 * class specific subcommand. For now we also
163 * require that all class specific options
164 * take an argument (until we can get smarter
165 * about parsing our options).
166 */
167 csoptsflag++;
168 prio_optind++;
169 prio_sp = 1;
170 break;
171
172 default:
173 break;
174 }
175 }
176
177 if (lflag) {
178 if (dflag || sflag || eflag || cflag || iflag || csoptsflag)
179 fatalerr(usage);
180
181 return (print_classlist());
182
183 } else if (dflag) {
184 if (lflag || sflag || eflag || cflag || csoptsflag)
185 fatalerr(usage);
186 if (iflag) {
187 if (str2idtyp(idtypnm, &idtype) == -1)
188 fatalerr("%s: bad idtype %s\n", cmdpath,
189 idtypnm);
190 } else {
191 idtype = P_PID;
192 }
193
194 if (prio_optind < argc) {
195 idargc = argc - prio_optind;
196 idargv = &argv[prio_optind];
197 } else {
198 idargc = 0;
199 }
200
201 return (print_procs(idtype, idargc, idargv));
202
203 } else if (sflag) {
204 if (lflag || dflag || eflag)
205 fatalerr(usage);
206 if (iflag) {
207 if (str2idtyp(idtypnm, &idtype) == -1)
208 fatalerr("%s: bad idtype %s\n", cmdpath,
209 idtypnm);
210 } else {
211 idtype = P_PID;
212 }
213
214 if (cflag == 0)
215 clname = NULL;
216
217 if (prio_optind < argc) {
218 idargc = argc - prio_optind;
219 idargv = &argv[prio_optind];
220 } else {
221 idargc = 0;
222 }
223
224 set_procs(clname, idtype, idargc, idargv, argv);
225
226 } else if (eflag) {
227 if (lflag || dflag || sflag || iflag)
228 fatalerr(usage);
229
230 if (cflag == 0)
231 clname = NULL;
232
233 if (prio_optind >= argc)
234 fatalerr(usage);
235
236 exec_cmd(clname, argv);
237
238 } else {
239 fatalerr(usage);
240 }
241
242 return (0);
243 }
244
245
246 /*
247 * Print the heading for the class list and execute the class
248 * specific sub-command with the -l option for each configured class.
249 */
250 static int
251 print_classlist(void)
252 {
253 id_t cid;
254 int nclass;
255 pcinfo_t pcinfo;
256 static char subcmdpath[128];
257 int status;
258 pid_t pid;
259 int error = 0;
260
261 /*
262 * No special privileges required for this operation.
263 * Set the effective UID back to the real UID.
264 */
265 if (setuid(getuid()) == -1)
266 fatalerr("%s: Can't set effective UID back to real UID\n",
267 cmdpath);
268
269 if ((nclass = priocntl(0, 0, PC_GETCLINFO, NULL)) == -1)
270 fatalerr("%s: Can't get number of configured classes, priocntl"
271 " system call failed with errno %d\n", cmdpath, errno);
272
273 (void) printf("CONFIGURED CLASSES\n==================\n\n");
274 (void) printf("SYS (System Class)\n");
275 for (cid = 1; cid < nclass; cid++) {
276 (void) printf("\n");
277 (void) fflush(stdout);
278 pcinfo.pc_cid = cid;
279 if (priocntl(0, 0, PC_GETCLINFO, (caddr_t)&pcinfo) == -1)
280 fatalerr("%s: can't get class name (class ID = %ld)\n",
281 cmdpath, cid);
282 if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s",
283 CLASSPATH, pcinfo.pc_clname, pcinfo.pc_clname, basenm) >=
284 sizeof (subcmdpath))
285 fatalerr("%s: can't generate %s specific subcommand\n",
286 cmdpath, pcinfo.pc_clname);
287 if ((pid = fork()) == 0) {
288 (void) execl(subcmdpath, subcmdpath, "-l", (char *)0);
289 (void) printf("%s\n", pcinfo.pc_clname);
290 fatalerr("\tCan't execute %s specific subcommand\n",
291 pcinfo.pc_clname);
292 } else if (pid == (pid_t)-1) {
293 (void) printf("%s\n", pcinfo.pc_clname);
294 (void) fprintf(stderr,
295 "Can't execute %s specific subcommand)\n",
296 pcinfo.pc_clname);
297 error = 1;
298 } else {
299 (void) wait(&status);
300 if (status)
301 error = 1;
302 }
303 }
304
305 return (error);
306 }
307
308
309 /*
310 * For each class represented within the set of processes specified by
311 * idtype/idargv, print_procs() executes the class specific sub-command
312 * with the -d option. We pipe to each sub-command a list of pids in
313 * the set belonging to that class.
314 */
315 static int
316 print_procs(idtype_t idtype, int idargc, char *idargv[])
317 {
318 int i;
319 id_t id;
320 id_t idlist[NIDS];
321 int nids;
322 classpids_t *clpids;
323 int nclass;
324 id_t cid;
325 pcinfo_t pcinfo;
326 int pidexists;
327 FILE *pipe_to_subcmd;
328 char subcmd[128];
329 int error = 0;
330
331
332 /*
333 * Build a list of ids eliminating any duplicates in idargv.
334 */
335 if (idtype == P_ALL) {
336 /*
337 * No idlist should be specified. If one is specified,
338 * it is ignored.
339 */
340 nids = 0;
341 } else if (idargc == 0) {
342
343 /*
344 * No ids supplied by user; use current id.
345 */
346 if (getmyid(idtype, &idlist[0]) == -1)
347 fatalerr("%s: Can't get ID for current process,"
348 " idtype = %d\n", cmdpath, idtype);
349 nids = 1;
350 } else {
351 nids = 0;
352 for (i = 0; i < idargc && nids < NIDS; i++) {
353 if (idtype == P_CID) {
354 if ((id = clname2cid(idargv[i])) == -1) {
355 (void) fprintf(stderr, "%s: Invalid or"
356 " unconfigured class %s in idlist"
357 " - ignored\n", cmdpath, idargv[i]);
358 error = 1;
359 }
360 } else {
361 id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX);
362 if (errno) {
363 (void) fprintf(stderr,
364 "%s: Invalid id \"%s\"\n",
365 cmdpath, idargv[i]);
366 error = 1;
367 id = BADPID;
368 }
369 }
370
371 /*
372 * lsearch(3C) adds ids to the idlist,
373 * eliminating duplicates.
374 */
375 (void) lsearch((void *)&id, (void *)idlist,
376 (size_t *)&nids, sizeof (id), (int (*)())idcompar);
377 }
378 }
379
380 if ((nclass = priocntl(0, 0, PC_GETCLINFO, NULL)) == -1)
381 fatalerr("%s: Can't get number of configured classes, priocntl"
382 " system call failed with errno %d\n", cmdpath, errno);
383
384 if ((clpids = (classpids_t *)malloc(sizeof (classpids_t) * nclass)) ==
385 NULL)
386 fatalerr("%s: Can't allocate memory for clpids.\n", cmdpath);
387
388 for (cid = 1; cid < nclass; cid++) {
389 pcinfo.pc_cid = cid;
390 if (priocntl(0, 0, PC_GETCLINFO, (caddr_t)&pcinfo) == -1)
391 fatalerr("%s: Can't get class name, cid = %ld\n",
392 cmdpath, cid);
393
394 (void) strncpy(clpids[cid].clp_clname, pcinfo.pc_clname,
395 PC_CLNMSZ);
396
397 /*
398 * The memory allocation for the pidlist uses realloc().
399 * A realloc() call is required, when "clp_npids" is
400 * equal to "clp_pidlistsz".
401 */
402 clpids[cid].clp_pidlist = (pid_t *)NULL;
403 clpids[cid].clp_pidlistsz = 0;
404 clpids[cid].clp_npids = 0;
405 }
406
407 /*
408 * Build the pidlist.
409 */
410 ids2pids(idtype, idlist, nids, clpids, nclass);
411
412 /*
413 * No need for special privileges any more.
414 * Set the effective UID back to the real UID.
415 */
416 if (setuid(getuid()) == -1)
417 fatalerr("%s: Can't set effective UID back to real UID\n",
418 cmdpath);
419
420 pidexists = 0;
421 for (cid = 1; cid < nclass; cid++) {
422 if (clpids[cid].clp_npids == 0)
423 continue;
424
425 pidexists = 1;
426 if (snprintf(subcmd, sizeof (subcmd), "%s/%s/%s%s -d",
427 CLASSPATH, clpids[cid].clp_clname, clpids[cid].clp_clname,
428 basenm) >= sizeof (subcmd)) {
429 (void) fprintf(stderr,
430 "Can't generate %s specific subcommand\n",
431 clpids[cid].clp_clname);
432 error = 1;
433 free(clpids[cid].clp_pidlist);
434 continue;
435 }
436 if ((pipe_to_subcmd = popen(subcmd, "w")) == NULL) {
437 (void) printf("%s\n", clpids[cid].clp_clname);
438 (void) fprintf(stderr,
439 "Can't execute %s specific subcommand\n",
440 clpids[cid].clp_clname);
441 error = 1;
442 free(clpids[cid].clp_pidlist);
443 continue;
444 }
445 (void) fwrite(clpids[cid].clp_pidlist, sizeof (pid_t),
446 clpids[cid].clp_npids, pipe_to_subcmd);
447 if (pclose(pipe_to_subcmd))
448 error = 1;
449
450 free(clpids[cid].clp_pidlist);
451 }
452
453 free(clpids);
454
455 if (pidexists == 0)
456 fatalerr("%s: Process(es) not found.\n", cmdpath);
457
458 return (error);
459 }
460
461
462 /*
463 * Execute the appropriate class specific sub-command with the arguments
464 * pointed to by subcmdargv. If the user specified a class we simply
465 * exec the sub-command for that class. If no class was specified we
466 * verify that the processes in the set specified by idtype/idargv are
467 * all in the same class and then execute the sub-command for that class.
468 */
469 static void
470 set_procs(clname, idtype, idargc, idargv, subcmdargv)
471 char *clname;
472 idtype_t idtype;
473 int idargc;
474 char **idargv;
475 char **subcmdargv;
476 {
477 char idstr[PC_IDTYPNMSZ];
478 char myidstr[PC_IDTYPNMSZ];
479 char clnmbuf[PC_CLNMSZ];
480 pcinfo_t pcinfo;
481 static psinfo_t prinfo;
482 static prcred_t prcred;
483 DIR *dirp;
484 struct dirent *dentp;
485 static char pname[100];
486 char *fname;
487 int procfd;
488 int saverr;
489 static char subcmdpath[128];
490 boolean_t procinset;
491 id_t id;
492 size_t len;
493
494 if (clname == NULL && idtype == P_PID && idargc <= 1) {
495
496 /*
497 * No class specified by user but only one process
498 * in specified set. Get the class the easy way.
499 */
500 if (idargc == 0) {
501 if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
502 PC_KY_CLNAME, clnmbuf, 0) == -1)
503 if (errno == ESRCH)
504 fatalerr("%s: Process not found.\n",
505 cmdpath);
506 else
507 fatalerr("%s: Can't get class of"
508 " current process\npriocntl"
509 " system call failed with"
510 " errno %d\n", cmdpath, errno);
511 } else {
512 /* idargc == 1 */
513 id = (id_t)str2num(idargv[0], INT_MIN, INT_MAX);
514 if (errno)
515 fatalerr("%s: Invalid id \"%s\"\n", cmdpath,
516 idargv[0]);
517
518 if (priocntl(P_PID, id, PC_GETXPARMS,
519 NULL, PC_KY_CLNAME, clnmbuf, 0) == -1)
520 if (errno == ESRCH)
521 fatalerr("%s: Process not found.\n",
522 cmdpath);
523 else
524 fatalerr("%s: Can't get class of "
525 " specified process\npriocntl"
526 " system call failed with"
527 " errno %d\n", cmdpath, errno);
528 }
529
530 clname = clnmbuf;
531 } else if (clname == NULL) {
532
533 /*
534 * No class specified by user and potentially more
535 * than one process in specified set. Verify that
536 * all procs in set are in the same class.
537 */
538 if (idargc == 0 && idtype != P_ALL) {
539
540 /*
541 * No ids supplied by user; use current id.
542 */
543 if (getmyidstr(idtype, myidstr) == -1)
544 fatalerr("%s: Can't get ID string for current"
545 " process, idtype = %d\n", cmdpath, idtype);
546 }
547 if ((dirp = opendir(procdir)) == NULL)
548 fatalerr("%s: Can't open PROC directory %s\n",
549 cmdpath, procdir);
550
551 while ((dentp = readdir(dirp)) != NULL) {
552 if (dentp->d_name[0] == '.') /* skip . and .. */
553 continue;
554
555 len = snprintf(pname, sizeof (pname), "%s/%s/",
556 procdir, dentp->d_name);
557 /* Really max(sizeof ("psinfo"), sizeof ("cred")) */
558 if (len + sizeof ("psinfo") > sizeof (pname)) {
559 (void) fprintf(stderr,
560 "%s: skipping %s, name too long.\n",
561 cmdpath, dentp->d_name);
562 continue;
563 }
564 fname = pname + len;
565 retry:
566 (void) strcpy(fname, "psinfo");
567 if ((procfd = open(pname, O_RDONLY)) < 0)
568 continue;
569
570 if (read(procfd, &prinfo, sizeof (prinfo)) !=
571 sizeof (prinfo)) {
572 saverr = errno;
573 (void) close(procfd);
574 if (saverr == EAGAIN)
575 goto retry;
576 if (saverr != ENOENT) {
577 (void) fprintf(stderr,
578 "%s: Can't get process info for"
579 " %s\n", cmdpath, pname);
580 }
581 continue;
582 }
583 (void) close(procfd);
584
585 if (idtype == P_UID || idtype == P_GID) {
586 (void) strcpy(fname, "cred");
587 if ((procfd = open(pname, O_RDONLY)) < 0 ||
588 read(procfd, &prcred, sizeof (prcred)) !=
589 sizeof (prcred)) {
590 saverr = errno;
591 if (procfd >= 0)
592 (void) close(procfd);
593 if (saverr == EAGAIN)
594 goto retry;
595 if (saverr != ENOENT) {
596 (void) fprintf(stderr,
597 "%s: Can't get process"
598 " credentials for %s\n",
599 cmdpath, pname);
600 }
601 continue;
602 }
603 (void) close(procfd);
604 }
605
606 if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0)
607 continue;
608
609
610 switch (idtype) {
611
612 case P_PID:
613 itoa((long)prinfo.pr_pid, idstr);
614 procinset = idmatch(idstr, myidstr,
615 idargc, idargv);
616 break;
617
618 case P_PPID:
619 itoa((long)prinfo.pr_ppid, idstr);
620 procinset = idmatch(idstr, myidstr,
621 idargc, idargv);
622 break;
623
624 case P_PGID:
625 itoa((long)prinfo.pr_pgid, idstr);
626 procinset = idmatch(idstr, myidstr,
627 idargc, idargv);
628 break;
629
630 case P_SID:
631 itoa((long)prinfo.pr_sid, idstr);
632 procinset = idmatch(idstr, myidstr,
633 idargc, idargv);
634 break;
635
636 case P_CID:
637 procinset = idmatch(prinfo.pr_lwp.pr_clname,
638 myidstr, idargc, idargv);
639 break;
640
641 case P_UID:
642 itoa((long)prcred.pr_euid, idstr);
643 procinset = idmatch(idstr, myidstr,
644 idargc, idargv);
645 break;
646
647 case P_GID:
648 itoa((long)prcred.pr_egid, idstr);
649 procinset = idmatch(idstr, myidstr,
650 idargc, idargv);
651 break;
652
653 case P_PROJID:
654 itoa((long)prinfo.pr_projid, idstr);
655 procinset = idmatch(idstr, myidstr,
656 idargc, idargv);
657 break;
658
659 case P_TASKID:
660 itoa((long)prinfo.pr_taskid, idstr);
661 procinset = idmatch(idstr, myidstr,
662 idargc, idargv);
663 break;
664
665 case P_ZONEID:
666 itoa((long)prinfo.pr_zoneid, idstr);
667 procinset = idmatch(idstr, myidstr,
668 idargc, idargv);
669 break;
670
671 case P_CTID:
672 itoa((long)prinfo.pr_contract, idstr);
673 procinset = idmatch(idstr, myidstr,
674 idargc, idargv);
675 break;
676
677 case P_ALL:
678 procinset = B_TRUE;
679 break;
680
681 default:
682 fatalerr("%s: Bad idtype %d in set_procs()\n",
683 cmdpath, idtype);
684 }
685 if (procinset == B_TRUE) {
686 if (clname == NULL) {
687
688 /*
689 * First proc found in set.
690 */
691 (void) strcpy(clnmbuf,
692 prinfo.pr_lwp.pr_clname);
693 clname = clnmbuf;
694 } else if (strcmp(clname,
695 prinfo.pr_lwp.pr_clname) != 0) {
696 fatalerr("%s: Specified processes"
697 " from different classes.\n",
698 cmdpath);
699 }
700 }
701 }
702 (void) closedir(dirp);
703 if (clname == NULL)
704 fatalerr("%s: Process(es) not found.\n", cmdpath);
705 } else {
706
707 /*
708 * User specified class. Check it for validity.
709 */
710 (void) strcpy(pcinfo.pc_clname, clname);
711 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
712 fatalerr("%s: Invalid or unconfigured class %s\n",
713 cmdpath, clname);
714 }
715
716 /*
717 * No need for special privileges any more.
718 * Set the effective UID back to the real UID.
719 */
720 if (setuid(getuid()) == -1)
721 fatalerr("%s: Can't set effective UID back to real UID\n",
722 cmdpath);
723
724 if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s",
725 CLASSPATH, clname, clname, basenm) >= sizeof (subcmdpath))
726 fatalerr("%s: can't generate %s specific subcommand\n",
727 cmdpath, clname);
728
729 subcmdargv[0] = subcmdpath;
730 (void) execv(subcmdpath, subcmdargv);
731 fatalerr("%s: Can't execute %s sub-command\n", cmdpath, clname);
732 }
733
734
735 /*
736 * Execute the appropriate class specific sub-command with the arguments
737 * pointed to by subcmdargv. If the user specified a class we simply
738 * exec the sub-command for that class. If no class was specified we
739 * execute the sub-command for our own current class.
740 */
741 static void
742 exec_cmd(clname, subcmdargv)
743 char *clname;
744 char **subcmdargv;
745 {
746 pcinfo_t pcinfo;
747 char clnmbuf[PC_CLNMSZ];
748 char subcmdpath[128];
749
750 /*
751 * No special privileges required for this operation.
752 * Set the effective UID back to the real UID.
753 */
754 if (setuid(getuid()) == -1)
755 fatalerr("%s: Can't set effective UID back to real UID\n",
756 cmdpath);
757
758 if (clname == NULL) {
759 if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL,
760 PC_KY_CLNAME, clnmbuf, 0) == -1)
761 fatalerr("%s: Can't get class name of current process\n"
762 "priocntl system call failed with errno %d\n",
763 cmdpath, errno);
764
765 clname = clnmbuf;
766 } else {
767
768 /*
769 * User specified class. Check it for validity.
770 */
771 (void) strcpy(pcinfo.pc_clname, clname);
772 if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
773 fatalerr("%s: Invalid or unconfigured class %s\n",
774 cmdpath, clname);
775 }
776
777 if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s",
778 CLASSPATH, clname, clname, basenm) >= sizeof (subcmdpath))
779 fatalerr("%s: can't generate %s specific subcommand\n",
780 cmdpath, clname);
781 subcmdargv[0] = subcmdpath;
782 (void) execv(subcmdpath, subcmdargv);
783 fatalerr("%s: Can't execute %s sub-command\n", cmdpath, clname);
784 }
785
786
787 /*
788 * Fill in the classpids structures in the array pointed to by clpids
789 * with pids for the processes in the set specified by idtype/idlist.
790 * We read the /proc/<pid>/psinfo file to get the necessary process
791 * information.
792 */
793 static void
794 ids2pids(idtype, idlist, nids, clpids, nclass)
795 idtype_t idtype;
796 id_t *idlist;
797 int nids;
798 classpids_t *clpids;
799 int nclass;
800 {
801 static psinfo_t prinfo;
802 static prcred_t prcred;
803 DIR *dirp;
804 struct dirent *dentp;
805 char pname[100];
806 char *fname;
807 int procfd;
808 int saverr;
809 int i;
810 char *clname;
811 size_t len;
812
813 if ((dirp = opendir(procdir)) == NULL)
814 fatalerr("%s: Can't open PROC directory %s\n",
815 cmdpath, procdir);
816
817 while ((dentp = readdir(dirp)) != NULL) {
818 if (dentp->d_name[0] == '.') /* skip . and .. */
819 continue;
820
821 len = snprintf(pname, sizeof (pname), "%s/%s/",
822 procdir, dentp->d_name);
823 /* Really max(sizeof ("psinfo"), sizeof ("cred")) */
824 if (len + sizeof ("psinfo") > sizeof (pname)) {
825 (void) fprintf(stderr,
826 "%s: skipping %s, name too long.\n",
827 cmdpath, dentp->d_name);
828 continue;
829 }
830 fname = pname + len;
831 retry:
832 (void) strcpy(fname, "psinfo");
833 if ((procfd = open(pname, O_RDONLY)) < 0)
834 continue;
835 if (read(procfd, &prinfo, sizeof (prinfo)) != sizeof (prinfo)) {
836 saverr = errno;
837 (void) close(procfd);
838 if (saverr == EAGAIN)
839 goto retry;
840 if (saverr != ENOENT) {
841 (void) fprintf(stderr,
842 "%s: Can't get process info for %s\n",
843 cmdpath, pname);
844 }
845 continue;
846 }
847 (void) close(procfd);
848
849 if (idtype == P_UID || idtype == P_GID) {
850 (void) strcpy(fname, "cred");
851 if ((procfd = open(pname, O_RDONLY)) < 0 ||
852 read(procfd, &prcred, sizeof (prcred)) !=
853 sizeof (prcred)) {
854 saverr = errno;
855 (void) close(procfd);
856 if (saverr == EAGAIN)
857 goto retry;
858 if (saverr != ENOENT) {
859 (void) fprintf(stderr,
860 "%s: Can't get process credentials"
861 " for %s\n",
862 cmdpath, pname);
863 }
864 continue;
865 }
866 (void) close(procfd);
867 }
868
869 if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0)
870 continue;
871
872 switch (idtype) {
873
874 case P_PID:
875 for (i = 0; i < nids; i++) {
876 if (idlist[i] == (id_t)prinfo.pr_pid)
877 add_pid_tolist(clpids, nclass,
878 prinfo.pr_lwp.pr_clname,
879 prinfo.pr_pid);
880 }
881 break;
882
883 case P_PPID:
884 for (i = 0; i < nids; i++) {
885 if (idlist[i] == (id_t)prinfo.pr_ppid)
886 add_pid_tolist(clpids, nclass,
887 prinfo.pr_lwp.pr_clname,
888 prinfo.pr_pid);
889 }
890 break;
891
892 case P_PGID:
893 for (i = 0; i < nids; i++) {
894 if (idlist[i] == (id_t)prinfo.pr_pgid)
895 add_pid_tolist(clpids, nclass,
896 prinfo.pr_lwp.pr_clname,
897 prinfo.pr_pid);
898 }
899 break;
900
901 case P_SID:
902 for (i = 0; i < nids; i++) {
903 if (idlist[i] == (id_t)prinfo.pr_sid)
904 add_pid_tolist(clpids, nclass,
905 prinfo.pr_lwp.pr_clname,
906 prinfo.pr_pid);
907 }
908 break;
909
910 case P_CID:
911 for (i = 0; i < nids; i++) {
912 clname = clpids[idlist[i]].clp_clname;
913 if (strcmp(clname,
914 prinfo.pr_lwp.pr_clname) == 0)
915 add_pid_tolist(clpids, nclass,
916 prinfo.pr_lwp.pr_clname,
917 prinfo.pr_pid);
918 }
919 break;
920
921 case P_UID:
922 for (i = 0; i < nids; i++) {
923 if (idlist[i] == (id_t)prcred.pr_euid)
924 add_pid_tolist(clpids, nclass,
925 prinfo.pr_lwp.pr_clname,
926 prinfo.pr_pid);
927 }
928 break;
929
930 case P_GID:
931 for (i = 0; i < nids; i++) {
932 if (idlist[i] == (id_t)prcred.pr_egid)
933 add_pid_tolist(clpids, nclass,
934 prinfo.pr_lwp.pr_clname,
935 prinfo.pr_pid);
936 }
937 break;
938
939 case P_PROJID:
940 for (i = 0; i < nids; i++) {
941 if (idlist[i] == (id_t)prinfo.pr_projid)
942 add_pid_tolist(clpids, nclass,
943 prinfo.pr_lwp.pr_clname,
944 prinfo.pr_pid);
945 }
946 break;
947
948 case P_TASKID:
949 for (i = 0; i < nids; i++) {
950 if (idlist[i] == (id_t)prinfo.pr_taskid)
951 add_pid_tolist(clpids, nclass,
952 prinfo.pr_lwp.pr_clname,
953 prinfo.pr_pid);
954 }
955 break;
956
957 case P_ZONEID:
958 for (i = 0; i < nids; i++) {
959 if (idlist[i] == (id_t)prinfo.pr_zoneid)
960 add_pid_tolist(clpids, nclass,
961 prinfo.pr_lwp.pr_clname,
962 prinfo.pr_pid);
963 }
964 break;
965
966 case P_CTID:
967 for (i = 0; i < nids; i++) {
968 if (idlist[i] == (id_t)prinfo.pr_contract)
969 add_pid_tolist(clpids, nclass,
970 prinfo.pr_lwp.pr_clname,
971 prinfo.pr_pid);
972 }
973 break;
974
975 case P_ALL:
976 add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname,
977 prinfo.pr_pid);
978 break;
979
980 default:
981 fatalerr("%s: Bad idtype %d in ids2pids()\n",
982 cmdpath, idtype);
983 }
984 }
985 (void) closedir(dirp);
986 }
987
988
989 /*
990 * Search the array pointed to by clpids for the classpids
991 * structure corresponding to clname and add pid to its
992 * pidlist.
993 */
994 static void
995 add_pid_tolist(clpids, nclass, clname, pid)
996 classpids_t *clpids;
997 int nclass;
998 char *clname;
999 pid_t pid;
1000 {
1001 classpids_t *clp;
1002
1003 for (clp = clpids; clp != &clpids[nclass]; clp++) {
1004 if (strcmp(clp->clp_clname, clname) == 0) {
1005 if (clp->clp_npids == clp->clp_pidlistsz)
1006 increase_pidlist(clp);
1007
1008 (clp->clp_pidlist)[clp->clp_npids] = pid;
1009 clp->clp_npids++;
1010 return;
1011 }
1012 }
1013 }
1014
1015
1016 static void
1017 increase_pidlist(classpids_t *clp)
1018 {
1019 if ((clp->clp_pidlist = realloc(clp->clp_pidlist,
1020 (clp->clp_pidlistsz + NPIDS) * sizeof (pid_t))) == NULL)
1021 /*
1022 * The pidlist is filled up and we cannot increase the size.
1023 */
1024 fatalerr("%s: Can't allocate memory for pidlist.\n", cmdpath);
1025
1026 clp->clp_pidlistsz += NPIDS;
1027 }
1028
1029
1030 /*
1031 * Compare id strings for equality. If idargv contains ids
1032 * (idargc > 0) compare idstr to each id in idargv, otherwise
1033 * just compare to curidstr.
1034 */
1035 static boolean_t
1036 idmatch(idstr, curidstr, idargc, idargv)
1037 char *idstr;
1038 char *curidstr;
1039 int idargc;
1040 char **idargv;
1041 {
1042 int i;
1043
1044 if (idargc == 0) {
1045 if (strcmp(curidstr, idstr) == 0)
1046 return (B_TRUE);
1047 } else {
1048 for (i = 0; i < idargc; i++) {
1049 if (strcmp(idargv[i], idstr) == 0)
1050 return (B_TRUE);
1051 }
1052 }
1053 return (B_FALSE);
1054 }
1055
1056 /*
1057 * This is a copy of the getopt() function found in libc:getopt.c. A separate
1058 * copy is required to fix the bug id #1114636. To fix the problem we need to
1059 * reset the _sp to 1. Since _sp in libc:getopt() is not exposed, a copy of
1060 * the getopt() is kept so that prio_sp can be reset to 1.
1061 */
1062
1063 static int
1064 prio_getopt(argc, argv, opts)
1065 int argc;
1066 #ifdef __STDC__
1067 char *const *argv, *opts;
1068 #else
1069 char **argv, *opts;
1070 #endif
1071 {
1072 register char c;
1073 register char *cp;
1074
1075 if (prio_sp == 1)
1076 if (prio_optind >= argc ||
1077 argv[prio_optind][0] != '-' || argv[prio_optind][1] == '\0')
1078 return (EOF);
1079 else if (strcmp(argv[prio_optind], "--") == NULL) {
1080 prio_optind++;
1081 return (EOF);
1082 }
1083 prio_optopt = c = (unsigned char)argv[prio_optind][prio_sp];
1084 if (c == ':' || (cp = strchr(opts, c)) == NULL) {
1085 if (argv[prio_optind][++prio_sp] == '\0') {
1086 prio_optind++;
1087 prio_sp = 1;
1088 }
1089 return ('?');
1090 }
1091 if (*++cp == ':') {
1092 if (argv[prio_optind][prio_sp+1] != '\0')
1093 prio_optarg = &argv[prio_optind++][prio_sp+1];
1094 else if (++prio_optind >= argc) {
1095 prio_sp = 1;
1096 return ('?');
1097 } else
1098 prio_optarg = argv[prio_optind++];
1099 prio_sp = 1;
1100 } else {
1101 if (argv[prio_optind][++prio_sp] == '\0') {
1102 prio_sp = 1;
1103 prio_optind++;
1104 }
1105 prio_optarg = NULL;
1106 }
1107 return (c);
1108 }
unleashed repo fork