# # CDDL HEADER START # # The contents of this file are subject to the terms of the # Common Development and Distribution License (the "License"). # You may not use this file except in compliance with the License. # # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE # or http://www.opensolaris.org/os/licensing. # See the License for the specific language governing permissions # and limitations under the License. # # When distributing Covered Code, include this CDDL HEADER in each # file and include the License file at usr/src/OPENSOLARIS.LICENSE. # If applicable, add the following below this CDDL HEADER, with the # fields enclosed by brackets "[]" replaced with your own identifying # information: Portions Copyright [yyyy] [name of copyright owner] # # CDDL HEADER END # # # Copyright 2009 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # PROG= priocntl PRIOCNTLOBJ= $(PROG).o subr.o PRIOCNTLSRC= $(PRIOCNTLOBJ:%.o=%.c) OBJS= $(PRIOCNTLOBJ) rt$(PROG).o ts$(PROG).o ia$(PROG).o fss$(PROG).o \ fx$(PROG).o sdc$(PROG).o SRCS= $(OBJ:%.o=%.c) include ../Makefile.cmd LDLIBS += -lcontract CERRWARN += -Wno-parentheses CERRWARN += $(CNOWARN_UNINIT) CLASSD = $(ROOTLIB)/class RTD = $(CLASSD)/RT SDCD = $(CLASSD)/SDC TSD = $(CLASSD)/TS IAD = $(CLASSD)/IA FSSD = $(CLASSD)/FSS FXD = $(CLASSD)/FX DIRS = $(CLASSD) $(RTD) $(SDCD) $(TSD) $(IAD) $(FSSD) $(FXD) RTPROG = RT$(PROG) SDCPROG = SDC$(PROG) TSPROG = TS$(PROG) IAPROG = IA$(PROG) FSSPROG = FSS$(PROG) FXPROG = FX$(PROG) ROOTRTPROG = $(RTD)/$(RTPROG) ROOTSDCPROG = $(SDCD)/$(SDCPROG) ROOTTSPROG = $(TSD)/$(TSPROG) ROOTIAPROG = $(IAD)/$(IAPROG) ROOTFSSPROG = $(FSSD)/$(FSSPROG) ROOTFXPROG = $(FXD)/$(FXPROG) $(ROOTUSRSBINPROG) : FILEMODE = 04555 $(DIRS) : FILEMODE = 0775 CLOBBERFILES += $(RTPROG) $(SDCPROG) $(TSPROG) $(IAPROG) $(FSSPROG) $(FXPROG) # installation rules $(RTD)/% : % $(INS.file) $(SDCD)/% : % $(INS.file) $(TSD)/% : % $(INS.file) $(IAD)/% : % $(INS.file) $(FSSD)/% : % $(INS.file) $(FXD)/% : % $(INS.file) .KEEP_STATE: all: $(PROG) $(RTPROG) $(SDCPROG) $(TSPROG) $(IAPROG) $(FSSPROG) $(FXPROG) $(PROG): $(PRIOCNTLOBJ) $(LINK.c) $(PRIOCNTLOBJ) -o $@ $(LDLIBS) $(POST_PROCESS) $(RTPROG): rt$(PRIOCNTLOBJ) $(LINK.c) rt$(PRIOCNTLOBJ) -o $@ $(LDLIBS) $(POST_PROCESS) $(SDCPROG): sdc$(PRIOCNTLOBJ) $(LINK.c) sdc$(PRIOCNTLOBJ) -o $@ $(LDLIBS) $(POST_PROCESS) $(TSPROG): ts$(PRIOCNTLOBJ) $(LINK.c) ts$(PRIOCNTLOBJ) -o $@ $(LDLIBS) $(POST_PROCESS) $(IAPROG): ia$(PRIOCNTLOBJ) $(LINK.c) ia$(PRIOCNTLOBJ) -o $@ $(LDLIBS) $(POST_PROCESS) $(FSSPROG): fss$(PRIOCNTLOBJ) $(LINK.c) fss$(PRIOCNTLOBJ) -o $@ $(LDLIBS) $(POST_PROCESS) $(FXPROG): fx$(PRIOCNTLOBJ) $(LINK.c) fx$(PRIOCNTLOBJ) -o $@ $(LDLIBS) $(POST_PROCESS) install: all $(DIRS) \ $(ROOTPROG) \ $(ROOTRTPROG) \ $(ROOTSDCPROG) \ $(ROOTTSPROG) \ $(ROOTIAPROG) \ $(ROOTFSSPROG) \ $(ROOTFXPROG) $(DIRS): $(INS.dir) clean: $(RM) $(OBJS) lint: $(LINT.c) $(PRIOCNTLSRC) $(LDLIBS) $(LINT.c) rt$(PRIOCNTLSRC) $(LDLIBS) $(LINT.c) sdc$(PRIOCNTLSRC) $(LDLIBS) $(LINT.c) ts$(PRIOCNTLSRC) $(LDLIBS) $(LINT.c) ia$(PRIOCNTLSRC) $(LDLIBS) $(LINT.c) fss$(PRIOCNTLSRC) $(LDLIBS) $(LINT.c) fx$(PRIOCNTLSRC) $(LDLIBS) include ../Makefile.targ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include #include #include #include #include #include #include #include #include #include "priocntl.h" /* * This file contains the class specific code implementing the fair-share * scheduler priocntl sub-command. */ #define ADDKEYVAL(p, k, v) { (p[0]) = (k); (p[1]) = (v); p += 2; } #define FSS_KEYCNT 2 /* max number of (key, value) pairs */ /* * Control flags */ #define FSS_DOUPRILIM 0x01 /* user priority limit */ #define FSS_DOUPRI 0x02 /* user priority */ static void print_fssinfo(void); static int print_fssprocs(void); static int fss_priocntl(idtype_t, id_t, int, char *, uintptr_t *); static int set_fssprocs(idtype_t, int, char **, uint_t, pri_t, pri_t); static void exec_fsscmd(char **, uint_t, pri_t, pri_t); static char usage[] = "usage: priocntl -l\n" " priocntl -d [-d idtype] [idlist]\n" " priocntl -s [-c FSS] [-m fssuprilim] [-p fssupri] [-i idtype] " "[idlist]\n" " priocntl -e [-c FSS] [-m fssuprilim] [-p fssupri] command [argument(s)]" "\n"; static char cmdpath[MAXPATHLEN]; static char basenm[BASENMSZ]; int main(int argc, char *argv[]) { int c; int lflag, dflag, sflag, mflag, pflag, eflag, iflag; pri_t fssuprilim; pri_t fssupri; char *idtypnm; idtype_t idtype; int idargc; uint_t cflags; (void) strlcpy(cmdpath, argv[0], MAXPATHLEN); (void) strlcpy(basenm, basename(argv[0]), BASENMSZ); lflag = dflag = sflag = mflag = pflag = eflag = iflag = 0; while ((c = getopt(argc, argv, "ldsm:p:ec:i:")) != -1) { switch (c) { case 'l': lflag++; break; case 'd': dflag++; break; case 's': sflag++; break; case 'm': mflag++; fssuprilim = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority limit %s " "out of configured range\n", basenm, optarg); break; case 'p': pflag++; fssupri = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority %s " "out of configured range\n", basenm, optarg); break; case 'e': eflag++; break; case 'c': if (strcmp(optarg, "FSS") != 0) fatalerr("error: %s executed for %s class, %s " "is actually sub-command for FSS class\n", cmdpath, optarg, cmdpath); break; case 'i': iflag++; idtypnm = optarg; break; case '?': fatalerr(usage); default: break; } } if (lflag) { if (dflag || sflag || mflag || pflag || eflag || iflag) fatalerr(usage); print_fssinfo(); } else if (dflag) { if (lflag || sflag || mflag || pflag || eflag) fatalerr(usage); return (print_fssprocs()); } else if (sflag) { if (lflag || dflag || eflag) fatalerr(usage); if (iflag) { if (str2idtyp(idtypnm, &idtype) == -1) fatalerr("%s: Bad idtype %s\n", basenm, idtypnm); } else { idtype = P_PID; } cflags = (pflag ? FSS_DOUPRI : 0); if (mflag) cflags |= FSS_DOUPRILIM; if (optind < argc) idargc = argc - optind; else idargc = 0; return (set_fssprocs(idtype, idargc, &argv[optind], cflags, fssuprilim, fssupri)); } else if (eflag) { if (lflag || dflag || sflag || iflag) fatalerr(usage); cflags = (pflag ? FSS_DOUPRI : 0); if (mflag) cflags |= FSS_DOUPRILIM; exec_fsscmd(&argv[optind], cflags, fssuprilim, fssupri); } else { fatalerr(usage); } return (0); } /* * Print our class name and the configured user priority range. */ static void print_fssinfo(void) { pcinfo_t pcinfo; (void) strcpy(pcinfo.pc_clname, "FSS"); (void) printf("FSS (Fair Share)\n"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("\tCan't get configured FSS user priority range\n"); (void) printf("\tConfigured FSS User Priority Range: -%d through %d\n", ((fssinfo_t *)pcinfo.pc_clinfo)->fss_maxupri, ((fssinfo_t *)pcinfo.pc_clinfo)->fss_maxupri); } /* * Read a list of pids from stdin and print the user priority and user * priority limit for each of the corresponding processes. */ static int print_fssprocs(void) { pid_t *pidlist; size_t numread; int i; char clname[PC_CLNMSZ]; pri_t fssuprilim; pri_t fssupri; int error = 0; /* * Read a list of pids from stdin. */ if ((pidlist = read_pidlist(&numread, stdin)) == NULL) fatalerr("%s: Can't read pidlist.\n", basenm); (void) printf("FAIR SHARING PROCESSES:\n" " PID FSSUPRILIM FSSUPRI\n"); if (numread == 0) fatalerr("%s: No pids on input\n", basenm); for (i = 0; i < numread; i++) { (void) printf("%7ld", pidlist[i]); if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, "FSS", FSS_KY_UPRI, &fssupri, FSS_KY_UPRILIM, &fssuprilim, 0) != -1) { (void) printf(" %5d %5d\n", fssuprilim, fssupri); } else { error = 1; if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, NULL, PC_KY_CLNAME, clname, 0) == -1 && strcmp(clname, "FSS")) /* * Process from some class other than fair * sharing. It has probably changed class while * priocntl command was executing (otherwise * we wouldn't have been passed its pid). * Print the little we know about it. */ (void) printf("\tChanged to class %s while" " priocntl command executing\n", clname); else (void) printf("\tCan't get FSS user priority" "\n"); } } free_pidlist(pidlist); return (error); } /* * Call priocntl() with command codes PC_SETXPARMS or PC_GETXPARMS. The * first parameter behind the command code is always the class name. * Each parameter is headed by a key, which detemines the meanin of the * following value. There is maximum FSS_KEYCNT == 2 of (key, value) pairs. */ static int fss_priocntl(idtype_t idtype, id_t id, int cmd, char *clname, uintptr_t *argsp) { return (priocntl(idtype, id, cmd, clname, argsp[0], argsp[1], argsp[2], argsp[3], 0)); } /* * Set all processes in the set specified by idtype/idargv to fair-sharing * (if they aren't already fair-sharing) and set their user priority limit * and user priority to those specified by fssuprilim and fssupri. */ static int set_fssprocs(idtype_t idtype, int idargc, char **idargv, uint_t cflags, short fssuprilim, short fssupri) { pcinfo_t pcinfo; uintptr_t args[2 * FSS_KEYCNT + 1]; uintptr_t *argsp = &args[0]; pri_t maxupri; char idtypnm[PC_IDTYPNMSZ]; int i; int error = 0; id_t id; /* * Get the fair sharing class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "FSS"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get FSS class ID, priocntl system call " "failed (%s)\n", basenm, strerror(errno)); maxupri = ((fssinfo_t *)pcinfo.pc_clinfo)->fss_maxupri; /* * Validate the fssuprilim and fssupri arguments. */ if ((cflags & FSS_DOUPRILIM) != 0) { if (fssuprilim > maxupri || fssuprilim < -maxupri) fatalerr("%s: Specified user priority limit %d out of " "configured range\n", basenm, fssuprilim); ADDKEYVAL(argsp, FSS_KY_UPRILIM, fssuprilim); } if ((cflags & FSS_DOUPRI) != 0) { if (fssupri > maxupri || fssupri < -maxupri) fatalerr("%s: Specified user priority %d out of " "configured range\n", basenm, fssupri); ADDKEYVAL(argsp, FSS_KY_UPRI, fssupri); } *argsp = 0; if (idtype == P_ALL) { if (fss_priocntl(P_ALL, 0, PC_SETXPARMS, "FSS", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error " "encountered on one or more processes.\n"); error = 1; } else { fatalerr("%s: Can't reset fair sharing " "parameters\npriocntl system call failed " "(%s)\n", basenm, strerror(errno)); } } else if ((cflags & (FSS_DOUPRILIM|FSS_DOUPRI)) == FSS_DOUPRI) { (void) verifyupri(idtype, 0, "FSS", FSS_KY_UPRILIM, fssupri, basenm); } } else if (idargc == 0) { if (fss_priocntl(idtype, P_MYID, PC_SETXPARMS, "FSS", args) == -1) { if (errno == EPERM) { (void) idtyp2str(idtype, idtypnm); (void) fprintf(stderr, "Permissions error " "encountered on current %s.\n", idtypnm); error = 1; } else { fatalerr("%s: Can't reset fair sharing " "parameters\npriocntl system call failed " "(%s)\n", basenm, strerror(errno)); } } else if ((cflags & (FSS_DOUPRILIM|FSS_DOUPRI)) == FSS_DOUPRI && getmyid(idtype, &id) != -1) { (void) verifyupri(idtype, id, "FSS", FSS_KY_UPRILIM, fssupri, basenm); } } else { (void) idtyp2str(idtype, idtypnm); for (i = 0; i < idargc; i++) { if (idtype == P_CID) { (void) strcpy(pcinfo.pc_clname, idargv[i]); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Invalid or unconfigured " "class %s, priocntl system call " "failed (%s)\n", basenm, pcinfo.pc_clname, strerror(errno)); id = pcinfo.pc_cid; } else { id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX); if (errno) fatalerr("%s: Invalid id \"%s\"\n", basenm, idargv[i]); } if (fss_priocntl(idtype, id, PC_SETXPARMS, "FSS", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions " "error encountered on %s %s.\n", idtypnm, idargv[i]); error = 1; } else { fatalerr("%s: Can't reset fair sharing" " parameters\npriocntl system call" " failed (%s)\n", basenm, strerror(errno)); } } else if ((cflags & (FSS_DOUPRILIM|FSS_DOUPRI)) == FSS_DOUPRI) { (void) verifyupri(idtype, id, "FSS", FSS_KY_UPRILIM, fssupri, basenm); } } } return (error); } /* * Execute the command pointed to by cmdargv as a fair-sharing process * with the user priority limit given by fssuprilim and user priority fssupri. */ static void exec_fsscmd(char **cmdargv, uint_t cflags, pri_t fssuprilim, pri_t fssupri) { pcinfo_t pcinfo; uintptr_t args[2 * FSS_KEYCNT + 1]; uintptr_t *argsp = &args[0]; pri_t maxupri; pri_t uprilim; /* * Get the fair sharing class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "FSS"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get FSS class ID, priocntl system call " "failed (%s)\n", basenm, strerror(errno)); maxupri = ((fssinfo_t *)pcinfo.pc_clinfo)->fss_maxupri; if ((cflags & FSS_DOUPRILIM) != 0) { if (fssuprilim > maxupri || fssuprilim < -maxupri) fatalerr("%s: Specified user priority limit %d out of " "configured range\n", basenm, fssuprilim); ADDKEYVAL(argsp, FSS_KY_UPRILIM, fssuprilim); } if ((cflags & FSS_DOUPRI) != 0) { if (fssupri > maxupri || fssupri < -maxupri) fatalerr("%s: Specified user priority %d out of " "configured range\n", basenm, fssupri); ADDKEYVAL(argsp, FSS_KY_UPRI, fssupri); } *argsp = 0; if (fss_priocntl(P_PID, P_MYID, PC_SETXPARMS, "FSS", args) == -1) fatalerr("%s: Can't reset fair sharing parameters\n" "priocntl system call failed (%s)\n", basenm, strerror(errno)); if ((cflags & (FSS_DOUPRILIM|FSS_DOUPRI)) == FSS_DOUPRI) { if (priocntl(P_PID, P_MYID, PC_GETXPARMS, "FSS", FSS_KY_UPRILIM, &uprilim, 0) != -1 && fssupri > uprilim) (void) fprintf(stderr, "%s: Specified user priority %d exceeds" " limit %d; set to %d (pid %d)\n", basenm, fssupri, uprilim, uprilim, (int)getpid()); } (void) execvp(cmdargv[0], cmdargv); fatalerr("%s: Can't execute %s, exec failed (%s)\n", basenm, cmdargv[0], strerror(errno)); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2001-2002 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include #include #include #include #include #include #include #include #include #include "priocntl.h" /* * This file contains the class specific code implementing * the fixed-priority priocntl sub-command. */ #define ADDKEYVAL(p, k, v) { (p[0]) = (k); (p[1]) = (v); p += 2; } #define FX_KEYCNT 4 /* maximal number of (key, value) pairs */ /* * control flags */ #define FX_DOUPRILIM 0x01 /* user priority limit */ #define FX_DOUPRI 0x02 /* user priority */ #define FX_DOTQ 0x04 /* time quantum */ static void print_fxinfo(); static int print_fxprocs(); static int set_fxprocs(idtype_t, int, char **, uint_t, pri_t, pri_t, long, long); static void exec_fxcmd(char **, uint_t, pri_t, pri_t, long, long); static int fx_priocntl(idtype_t, id_t, int, char *, uintptr_t *); static char usage[] = "usage: priocntl -l\n\ priocntl -d [-d idtype] [idlist]\n\ priocntl -s [-c FX] [-m fxuprilim] [-p fxupri] [-t tqntm [-r res]] \ [-i idtype] [idlist]\n\ priocntl -e [-c FX] [-m fxuprilim] [-p fxupri] [-t tqntm [-r res]] \ command [argument(s)]\n"; static char cmdpath[MAXPATHLEN]; static char basenm[BASENMSZ]; int main(int argc, char *argv[]) { extern char *optarg; extern int optind; int c; int lflag, dflag, sflag, mflag, pflag, eflag, iflag, tflag; int rflag; pri_t fxuprilim; pri_t fxupri; char *idtypnm; idtype_t idtype; int idargc; long res; long tqntm; uint_t cflags; (void) strlcpy(cmdpath, argv[0], MAXPATHLEN); (void) strlcpy(basenm, basename(argv[0]), BASENMSZ); lflag = dflag = sflag = mflag = pflag = eflag = iflag = tflag = 0; rflag = 0; while ((c = getopt(argc, argv, "ldsm:p:ec:i:t:r:")) != -1) { switch (c) { case 'l': lflag++; break; case 'd': dflag++; break; case 's': sflag++; break; case 'm': mflag++; fxuprilim = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority limit %s" " out of configured range\n", basenm, optarg); break; case 'p': pflag++; fxupri = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority %s out of" " configured range\n", basenm, optarg); break; case 'e': eflag++; break; case 'c': if (strcmp(optarg, "FX") != 0) fatalerr("error: %s executed for %s class, %s" " is actually sub-command for FX class\n", cmdpath, optarg, cmdpath); break; case 'i': iflag++; idtypnm = optarg; break; case 't': tflag++; tqntm = str2num(optarg, 1, INT_MAX); if (errno) fatalerr("%s: Invalid time quantum specified;" " time quantum must be positive\n", basenm); break; case 'r': rflag++; res = str2num(optarg, 1, 1000000000); if (errno) fatalerr("%s: Invalid resolution specified;" " resolution must be between" " 1 and 1,000,000,000\n", basenm); break; case '?': fatalerr(usage); default: break; } } if (lflag) { if (dflag || sflag || mflag || pflag || eflag || iflag || tflag || rflag) fatalerr(usage); print_fxinfo(); } else if (dflag) { if (sflag || mflag || pflag || eflag) fatalerr(usage); return (print_fxprocs()); } else if (sflag) { if (eflag) fatalerr(usage); if (iflag) { if (str2idtyp(idtypnm, &idtype) == -1) fatalerr("%s: Bad idtype %s\n", basenm, idtypnm); } else idtype = P_PID; cflags = (pflag ? FX_DOUPRI : 0); if (mflag) cflags |= FX_DOUPRILIM; if (tflag) cflags |= FX_DOTQ; if (rflag == 0) res = 1000; if (optind < argc) idargc = argc - optind; else idargc = 0; return (set_fxprocs(idtype, idargc, &argv[optind], cflags, fxuprilim, fxupri, tqntm, res)); } else if (eflag) { if (iflag) fatalerr(usage); cflags = (pflag ? FX_DOUPRI : 0); if (mflag) cflags |= FX_DOUPRILIM; if (tflag) cflags |= FX_DOTQ; if (rflag == 0) res = 1000; exec_fxcmd(&argv[optind], cflags, fxuprilim, fxupri, tqntm, res); } else { fatalerr(usage); } return (0); } /* * Print our class name and the configured user priority range. */ static void print_fxinfo() { pcinfo_t pcinfo; (void) strcpy(pcinfo.pc_clname, "FX"); (void) printf("FX (Fixed priority)\n"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("\tCan't get configured FX user priority range\n"); (void) printf("\tConfigured FX User Priority Range: 0 through %d\n", ((fxinfo_t *)pcinfo.pc_clinfo)->fx_maxupri); } /* * Read a list of pids from stdin and print the user priority and user * priority limit for each of the corresponding processes. */ static int print_fxprocs() { pid_t *pidlist; size_t numread; int i; char clname[PC_CLNMSZ]; uint_t fx_tqsecs; int fx_tqnsecs; pri_t fx_uprilim; pri_t fx_upri; int error = 0; /* * Read a list of pids from stdin. */ if ((pidlist = read_pidlist(&numread, stdin)) == NULL) fatalerr("%s: Can't read pidlist.\n", basenm); (void) printf("FIXED PRIORITY PROCESSES:\n PID FXUPRILIM " "FXUPRI FXTQNTM\n"); if (numread == 0) fatalerr("%s: No pids on input\n", basenm); for (i = 0; i < numread; i++) { (void) printf("%7ld", pidlist[i]); if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, "FX", FX_KY_UPRI, &fx_upri, FX_KY_UPRILIM, &fx_uprilim, FX_KY_TQSECS, &fx_tqsecs, FX_KY_TQNSECS, &fx_tqnsecs, 0) != -1) { (void) printf(" %5d %5d", fx_uprilim, fx_upri); if (fx_tqnsecs == FX_TQINF) (void) printf(" FX_TQINF\n"); else (void) printf(" %11lld\n", (longlong_t)fx_tqsecs * 1000 + fx_tqnsecs / 1000000); } else { error = 1; if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, NULL, PC_KY_CLNAME, clname, 0) != -1 && strcmp(clname, "FX")) { /* * Process from some class other than fixed priority. * It has probably changed class while priocntl * command was executing (otherwise we wouldn't * have been passed its pid). Print the little * we know about it. */ (void) printf("\tChanged to class %s while priocntl" " command executing\n", clname); } else { (void) printf("\tCan't get FX user priority\n"); } } } free_pidlist(pidlist); return (error); } /* * Call priocntl() with command codes PC_SETXPARMS or PC_GETXPARMS. * The first parameter behind the command code is always the class name. * Each parameter is headed by a key, which determines the meaning of the * following value. There are maximal FX_KEYCNT = 4 (key, value) pairs. */ static int fx_priocntl(idtype_t idtype, id_t id, int cmd, char *clname, uintptr_t *argsp) { return (priocntl(idtype, id, cmd, clname, argsp[0], argsp[1], argsp[2], argsp[3], argsp[4], argsp[5], argsp[6], argsp[7], 0)); } /* * Set all processes in the set specified by idtype/idargv to fixed-priority * (if they aren't already fixed-priority) and set their user priority limit * and user priority to those specified by fxuprilim and fxupri. */ static int set_fxprocs(idtype_t idtype, int idargc, char **idargv, uint_t cflags, pri_t fxuprilim, pri_t fxupri, long tqntm, long res) { pcinfo_t pcinfo; uintptr_t args[2*FX_KEYCNT+1]; uintptr_t *argsp = &args[0]; pri_t maxupri; char idtypnm[PC_IDTYPNMSZ]; int i; id_t id; hrtimer_t hrtime; int error = 0; /* * Get the fixed priority class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "FX"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get FX class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxupri = ((fxinfo_t *)pcinfo.pc_clinfo)->fx_maxupri; /* * Validate the fxuprilim and fxupri arguments. */ if ((cflags & FX_DOUPRILIM) != 0) { if (fxuprilim > maxupri || fxuprilim < 0) { fatalerr("%s: Specified user priority limit %d out of" " configured range\n", basenm, fxuprilim); } ADDKEYVAL(argsp, FX_KY_UPRILIM, fxuprilim); } if ((cflags & FX_DOUPRI) != 0) { if (fxupri > maxupri || fxupri < 0) fatalerr("%s: Specified user priority %d out of " "configured range\n", basenm, fxupri); ADDKEYVAL(argsp, FX_KY_UPRI, fxupri); } if (cflags & FX_DOTQ) { hrtime.hrt_secs = 0; hrtime.hrt_rem = tqntm; hrtime.hrt_res = res; if (_hrtnewres(&hrtime, NANOSEC, HRT_RNDUP) == -1) fatalerr("%s: Can't convert resolution.\n", basenm); ADDKEYVAL(argsp, FX_KY_TQSECS, hrtime.hrt_secs); ADDKEYVAL(argsp, FX_KY_TQNSECS, hrtime.hrt_rem); } *argsp = 0; if (idtype == P_ALL) { if (fx_priocntl(P_ALL, 0, PC_SETXPARMS, "FX", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error encountered " "on one or more processes.\n"); error = 1; } else { fatalerr("%s: Can't reset fixed priority" " parameters\npriocntl system call failed " " with errno %d\n", basenm, errno); } } else if ((cflags & (FX_DOUPRILIM|FX_DOUPRI)) == FX_DOUPRI) { (void) verifyupri(idtype, 0, "FX", FX_KY_UPRILIM, fxupri, basenm); } } else if (idargc == 0) { if (fx_priocntl(idtype, P_MYID, PC_SETXPARMS, "FX", args) == -1) { if (errno == EPERM) { (void) idtyp2str(idtype, idtypnm); (void) fprintf(stderr, "Permissions error" " encountered on current %s.\n", idtypnm); error = 1; } else { fatalerr("%s: Can't reset fixed priority" " parameters\npriocntl system call failed" " with errno %d\n", basenm, errno); } } else if ((cflags & (FX_DOUPRILIM|FX_DOUPRI)) == FX_DOUPRI && getmyid(idtype, &id) != -1) { (void) verifyupri(idtype, id, "FX", FX_KY_UPRILIM, fxupri, basenm); } } else { (void) idtyp2str(idtype, idtypnm); for (i = 0; i < idargc; i++) { if (idtype == P_CID) { (void) strcpy(pcinfo.pc_clname, idargv[i]); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Invalid or unconfigured" " class %s, priocntl system call" " failed with errno %d\n", basenm, pcinfo.pc_clname, errno); id = pcinfo.pc_cid; } else { id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX); } if (fx_priocntl(idtype, id, PC_SETXPARMS, "FX", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error encountered on" " %s %s.\n", idtypnm, idargv[i]); error = 1; } else { fatalerr("%s: Can't reset fixed " "priority" " parameters\npriocntl system call" " failed with errno %d\n", basenm, errno); } } else if ((cflags & (FX_DOUPRILIM|FX_DOUPRI)) == FX_DOUPRI) { (void) verifyupri(idtype, id, "FX", FX_KY_UPRILIM, fxupri, basenm); } } } return (error); } /* * Execute the command pointed to by cmdargv as a fixed-priority process * with the user priority limit given by fxuprilim and user priority fxupri. */ static void exec_fxcmd(char **cmdargv, uint_t cflags, pri_t fxuprilim, pri_t fxupri, long tqntm, long res) { pcinfo_t pcinfo; uintptr_t args[2*FX_KEYCNT+1]; uintptr_t *argsp = &args[0]; pri_t maxupri; pri_t uprilim; hrtimer_t hrtime; /* * Get the fixed priority class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "FX"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get FX class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxupri = ((fxinfo_t *)pcinfo.pc_clinfo)->fx_maxupri; if ((cflags & FX_DOUPRILIM) != 0) { if (fxuprilim > maxupri || fxuprilim < 0) fatalerr("%s: Specified user priority limit %d out of" " configured range\n", basenm, fxuprilim); ADDKEYVAL(argsp, FX_KY_UPRILIM, fxuprilim); } if ((cflags & FX_DOUPRI) != 0) { if (fxupri > maxupri || fxupri < 0) fatalerr("%s: Specified user priority %d out of" " configured range\n", basenm, fxupri); ADDKEYVAL(argsp, FX_KY_UPRI, fxupri); } if ((cflags & FX_DOTQ) != 0) { hrtime.hrt_secs = 0; hrtime.hrt_rem = tqntm; hrtime.hrt_res = res; if (_hrtnewres(&hrtime, NANOSEC, HRT_RNDUP) == -1) fatalerr("%s: Can't convert resolution.\n", basenm); ADDKEYVAL(argsp, FX_KY_TQSECS, hrtime.hrt_secs); ADDKEYVAL(argsp, FX_KY_TQNSECS, hrtime.hrt_rem); } *argsp = 0; if (fx_priocntl(P_PID, P_MYID, PC_SETXPARMS, "FX", args) == -1) fatalerr("%s: Can't reset fixed priority parameters\n" " priocntl system call failed with errno %d\n", basenm, errno); if ((cflags & (FX_DOUPRILIM|FX_DOUPRI)) == FX_DOUPRI) { if (priocntl(P_PID, P_MYID, PC_GETXPARMS, "FX", FX_KY_UPRILIM, &uprilim, 0) != -1 && fxupri > uprilim) (void) fprintf(stderr, "%s: Specified user priority %d exceeds" " limit %d; set to %d (pid %d)\n", basenm, fxupri, uprilim, uprilim, (int)getpid()); } (void) execvp(cmdargv[0], cmdargv); fatalerr("%s: Can't execute %s, exec failed with errno %d\n", basenm, cmdargv[0], errno); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include #include #include #include #include #include #include #include #include #include #include "priocntl.h" /* * This file contains the class specific code implementing * the interactive class priocntl sub-command. */ #define ADDKEYVAL(p, k, v) { (p[0]) = (k); (p[1]) = (v); p += 2; } #define IA_KEYCNT 3 /* maximal number of (key, value) pairs */ /* * control flags */ #define IA_DOUPRILIM 0x01 /* user priority limit */ #define IA_DOUPRI 0x02 /* user priority */ #define IA_DOMODE 0x04 /* interactive on/off */ static void print_iainfo(void); static int print_iaprocs(void); static int ia_priocntl(idtype_t, id_t, int, char *, uintptr_t *); static int set_iaprocs(idtype_t, int, char **, uint_t, pri_t, pri_t, int); static void exec_iacmd(char **, uint_t, pri_t, pri_t, int); static char usage[] = "usage: priocntl -l\n\ priocntl -d [-i idtype] [idlist]\n\ priocntl -s [-c IA] [-m iauprilim] [-p iaupri] [-t iamode]\n\ [-i idtype] [idlist]\n\ priocntl -e [-c IA] [-m iauprilim] [-p iaupri] [-t iamode]\n\ command [argument(s)]\n"; static char cmdpath[MAXPATHLEN]; static char basenm[BASENMSZ]; int main(int argc, char *argv[]) { int c; int lflag, dflag, sflag, mflag, pflag, eflag, iflag, tflag; int iamode; pri_t iauprilim; pri_t iaupri; char *idtypnm; idtype_t idtype; int idargc; uint_t cflags; (void) strlcpy(cmdpath, argv[0], MAXPATHLEN); (void) strlcpy(basenm, basename(argv[0]), BASENMSZ); lflag = dflag = sflag = mflag = pflag = eflag = iflag = tflag = 0; while ((c = getopt(argc, argv, "ldsm:p:t:ec:i:")) != -1) { switch (c) { case 'l': lflag++; break; case 'd': dflag++; break; case 's': sflag++; break; case 'm': mflag++; iauprilim = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority limit %s" " out of configured range\n", basenm, optarg); break; case 'p': pflag++; iaupri = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority %s out of" " configured range\n", basenm, optarg); break; case 't': tflag++; iamode = (int)str2num(optarg, INT_MIN, INT_MAX); if (errno || (iamode != IA_INTERACTIVE_OFF && iamode != IA_SET_INTERACTIVE)) fatalerr("%s: Specified illegal mode %s\n", basenm, optarg); break; case 'e': eflag++; break; case 'c': if (strcmp(optarg, "IA") != 0) fatalerr("error: %s executed for %s class, %s" " is actually sub-command for IA class\n", cmdpath, optarg, cmdpath); break; case 'i': iflag++; idtypnm = optarg; break; case '?': fatalerr(usage); default: break; } } if (lflag) { if (dflag || sflag || mflag || pflag || tflag || eflag || iflag) fatalerr(usage); print_iainfo(); } else if (dflag) { if (lflag || sflag || mflag || pflag || tflag || eflag) fatalerr(usage); return (print_iaprocs()); } else if (sflag) { if (lflag || dflag || eflag) fatalerr(usage); if (iflag) { if (str2idtyp(idtypnm, &idtype) == -1) fatalerr("%s: Bad idtype %s\n", basenm, idtypnm); } else { idtype = P_PID; } cflags = (pflag ? IA_DOUPRI : 0); if (mflag) cflags |= IA_DOUPRILIM; if (tflag) cflags |= IA_DOMODE; if (optind < argc) idargc = argc - optind; else idargc = 0; return (set_iaprocs(idtype, idargc, &argv[optind], cflags, iauprilim, iaupri, iamode)); } else if (eflag) { if (lflag || dflag || sflag || iflag) fatalerr(usage); cflags = (pflag ? IA_DOUPRI : 0); if (mflag) cflags |= IA_DOUPRILIM; if (tflag) cflags |= IA_DOMODE; exec_iacmd(&argv[optind], cflags, iauprilim, iaupri, iamode); } else { fatalerr(usage); } return (0); } /* * Print our class name and the configured user priority range. */ static void print_iainfo(void) { pcinfo_t pcinfo; (void) strcpy(pcinfo.pc_clname, "IA"); (void) printf("IA (Interactive)\n"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("\tCan't get configured IA user priority range\n"); (void) printf("\tConfigured IA User Priority Range: -%d through %d\n", ((iainfo_t *)pcinfo.pc_clinfo)->ia_maxupri, ((iainfo_t *)pcinfo.pc_clinfo)->ia_maxupri); } /* * Read a list of pids from stdin and print the user priority and user * priority limit for each of the corresponding processes. * print their interactive mode and nice values */ static int print_iaprocs(void) { pid_t *pidlist; size_t numread; int i; char clname[PC_CLNMSZ]; pri_t ia_uprilim; pri_t ia_upri; int ia_mode; int error = 0; /* * Read a list of pids from stdin. */ if ((pidlist = read_pidlist(&numread, stdin)) == NULL) fatalerr("%s: Can't read pidlist.\n", basenm); (void) printf("INTERACTIVE CLASS PROCESSES:"); (void) printf("\n PID IAUPRILIM IAUPRI IAMODE\n"); if (numread == 0) fatalerr("%s: No pids on input\n", basenm); for (i = 0; i < numread; i++) { (void) printf("%7ld", pidlist[i]); if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, "IA", IA_KY_UPRI, &ia_upri, IA_KY_UPRILIM, &ia_uprilim, IA_KY_MODE, &ia_mode, 0) != -1) { (void) printf(" %5d %5d %5d\n", ia_uprilim, ia_upri, ia_mode); } else { error = 1; if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, NULL, PC_KY_CLNAME, clname, 0) != -1 && strcmp(clname, "IA")) /* * Process from some class other than * interactive. It has probably changed class * while priocntl command was executing * (otherwise we wouldn't have been passed its * pid). Print the little we know about it. */ (void) printf("\tChanged to class %s while" " priocntl command executing\n", clname); else (void) printf("\tCan't get IA user priority\n"); } } free_pidlist(pidlist); return (error); } /* * Call priocntl() with command codes PC_SETXPARMS or PC_GETXPARMS. * The first parameter behind the command code is always the class name. * Each parameter is headed by a key, which determines the meaning of the * following value. There are maximal IA_KEYCNT = 3 (key, value) pairs. */ static int ia_priocntl(idtype_t idtype, id_t id, int cmd, char *clname, uintptr_t *argsp) { return (priocntl(idtype, id, cmd, clname, argsp[0], argsp[1], argsp[2], argsp[3], argsp[4], argsp[5], 0)); } /* * Set all processes in the set specified by idtype/idargv to interactive * (if they aren't already interactive ) and set their user priority limit * and user priority to those specified by iauprilim and iaupri. */ static int set_iaprocs(idtype_t idtype, int idargc, char **idargv, uint_t cflags, pri_t iauprilim, pri_t iaupri, int iamode) { pcinfo_t pcinfo; uintptr_t args[2*IA_KEYCNT+1]; uintptr_t *argsp = &args[0]; int maxupri; char idtypnm[PC_IDTYPNMSZ]; int i; int error = 0; id_t id; /* * Get the interactive class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "IA"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get IA class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxupri = ((iainfo_t *)pcinfo.pc_clinfo)->ia_maxupri; /* * Validate the iauprilim and iaupri arguments. */ if ((cflags & IA_DOUPRILIM) != 0) { if (iauprilim > maxupri || iauprilim < -maxupri) fatalerr("%s: Specified user priority limit %d out of" " configured range\n", basenm, iauprilim); ADDKEYVAL(argsp, IA_KY_UPRILIM, iauprilim); } if ((cflags & IA_DOUPRI) != 0) { if (iaupri > maxupri || iaupri < -maxupri) fatalerr("%s: Specified user priority %d out of" " configured range\n", basenm, iaupri); ADDKEYVAL(argsp, IA_KY_UPRI, iaupri); } if ((cflags & IA_DOMODE) != 0) ADDKEYVAL(argsp, IA_KY_MODE, iamode); *argsp = 0; if (idtype == P_ALL) { if (ia_priocntl(P_ALL, 0, PC_SETXPARMS, "IA", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error encountered" " on one or more processes.\n"); error = 1; } else { fatalerr("%s: Can't reset interactive" " parameters\npriocntl system call failed" " with errno %d\n", basenm, errno); } } else if ((cflags & (IA_DOUPRILIM|IA_DOUPRI)) == IA_DOUPRI) { (void) verifyupri(idtype, 0, "IA", IA_KY_UPRILIM, iaupri, basenm); } } else if (idargc == 0) { if (ia_priocntl(idtype, P_MYID, PC_SETXPARMS, "IA", args) == -1) { if (errno == EPERM) { (void) idtyp2str(idtype, idtypnm); (void) fprintf(stderr, "Permissions error encountered" " on current %s.\n", idtypnm); error = 1; } else { fatalerr("%s: Can't reset interactive" " parameters\npriocntl system call failed" " with errno %d\n", basenm, errno); } } else if ((cflags & (IA_DOUPRILIM|IA_DOUPRI)) == IA_DOUPRI && getmyid(idtype, &id) != -1) { (void) verifyupri(idtype, id, "IA", IA_KY_UPRILIM, iaupri, basenm); } } else { (void) idtyp2str(idtype, idtypnm); for (i = 0; i < idargc; i++) { if (idtype == P_CID) { (void) strcpy(pcinfo.pc_clname, idargv[i]); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Invalid or unconfigured" " class %s, priocntl system call" " failed with errno %d\n", basenm, pcinfo.pc_clname, errno); id = pcinfo.pc_cid; } else { id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX); if (errno) fatalerr("%s: Invalid id \"%s\"\n", basenm, idargv[i]); } if (ia_priocntl(idtype, id, PC_SETXPARMS, "IA", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error" " encountered on %s %s.\n", idtypnm, idargv[i]); error = 1; } else { fatalerr("%s: Can't reset interactive" " parameters\npriocntl system call" " failed with errno %d\n", basenm, errno); } } else if ((cflags & (IA_DOUPRILIM|IA_DOUPRI)) == IA_DOUPRI) { (void) verifyupri(idtype, id, "IA", IA_KY_UPRILIM, iaupri, basenm); } } } return (error); } /* * Execute the command pointed to by cmdargv as a interactive process * with the user priority limit given by iauprilim and user priority iaupri. */ static void exec_iacmd(char **cmdargv, uint_t cflags, pri_t iauprilim, pri_t iaupri, int iamode) { pcinfo_t pcinfo; uintptr_t args[2*IA_KEYCNT+1]; uintptr_t *argsp = &args[0]; pri_t maxupri; pri_t uprilim; /* * Get the time sharing class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "IA"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get IA class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxupri = ((iainfo_t *)pcinfo.pc_clinfo)->ia_maxupri; /* * Validate the iauprilim and iaupri arguments. */ if ((cflags & IA_DOUPRILIM) != 0) { if (iauprilim > maxupri || iauprilim < -maxupri) fatalerr("%s: Specified user priority limit %d out of" " configured range\n", basenm, iauprilim); ADDKEYVAL(argsp, IA_KY_UPRILIM, iauprilim); } if ((cflags & IA_DOUPRI) != 0) { if (iaupri > maxupri || iaupri < -maxupri) fatalerr("%s: Specified user priority %d out of" " configured range\n", basenm, iaupri); ADDKEYVAL(argsp, IA_KY_UPRI, iaupri); } if ((cflags & IA_DOMODE) != 0) ADDKEYVAL(argsp, IA_KY_MODE, iamode); *argsp = 0; if (ia_priocntl(P_PID, P_MYID, PC_SETXPARMS, "IA", args) == -1) fatalerr("%s: Can't reset interactive parameters\n" "priocntl system call failed with errno %d\n", basenm, errno); if ((cflags & (IA_DOUPRILIM|IA_DOUPRI)) == IA_DOUPRI) { if (priocntl(P_PID, P_MYID, PC_GETXPARMS, "IA", IA_KY_UPRILIM, &uprilim, 0) != -1 && iaupri > uprilim) (void) fprintf(stderr, "%s: Specified user priority %d exceeds" " limit %d; set to %d (pid %d)\n", basenm, iaupri, uprilim, uprilim, (int)getpid()); } (void) execvp(cmdargv[0], cmdargv); fatalerr("%s: Can't execute %s, exec failed with errno %d\n", basenm, cmdargv[0], errno); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "priocntl.h" /* * This file contains the code implementing the class independent part * of the priocntl command. Most of the useful work for the priocntl * command is done by the class specific sub-commands, the code for * which is elsewhere. The class independent part of the command is * responsible for executing the appropriate class specific sub-commands * and providing any necessary input to the sub-commands. * Code in this file should never assume any knowledge of any specific * scheduler class (other than the SYS class). */ #define CLASSPATH "/usr/lib/class" typedef struct classpids { char clp_clname[PC_CLNMSZ]; pid_t *clp_pidlist; int clp_pidlistsz; int clp_npids; } classpids_t; static char usage[] = "usage: priocntl -l\n\ priocntl -d [-i idtype] [idlist]\n\ priocntl -s [-c class] [c.s.o.] [-i idtype] [idlist]\n\ priocntl -e [-c class] [c.s.o.] command [argument(s)]\n"; static char basenm[BASENMSZ]; static char cmdpath[MAXPATHLEN]; static char *procdir = "/proc"; static int print_classlist(void); static void set_procs(char *, idtype_t, int, char **, char **); static void exec_cmd(char *, char **); static int print_procs(idtype_t, int, char *[]); static void ids2pids(idtype_t, id_t *, int, classpids_t *, int); static void add_pid_tolist(classpids_t *, int, char *, pid_t); static void increase_pidlist(classpids_t *); static boolean_t idmatch(char *, char *, int, char **); /* * These variables are defined to be used in prio_getopt() below. */ static int prio_getopt(); /* LINTED static unused */ static int prio_optopt = 0; static char *prio_optarg = 0; static int prio_optind = 1; static int prio_sp = 1; int main(int argc, char *argv[]) { int c; int lflag, dflag, sflag, eflag, cflag, iflag, csoptsflag; char *clname; char *idtypnm; idtype_t idtype; int idargc; char **idargv; (void) strlcpy(cmdpath, argv[0], MAXPATHLEN); (void) strlcpy(basenm, basename(argv[0]), BASENMSZ); lflag = dflag = sflag = eflag = cflag = iflag = csoptsflag = 0; while ((c = prio_getopt(argc, argv, "ldsec:i:")) != -1) { switch (c) { case 'l': lflag++; break; case 'd': dflag++; break; case 's': sflag++; break; case 'e': eflag++; break; case 'c': cflag++; clname = prio_optarg; break; case 'i': iflag++; idtypnm = prio_optarg; break; case '?': if (strcmp(argv[prio_optind - 1], "-c") == 0 || strcmp(argv[prio_optind - 1], "-i") == 0) { /* * getopt() will return ? if either * of these appear without an argument. */ fatalerr(usage); } /* * We assume for now that any option that * getopt() doesn't recognize (with the * exception of c and i) is intended for a * class specific subcommand. For now we also * require that all class specific options * take an argument (until we can get smarter * about parsing our options). */ csoptsflag++; prio_optind++; prio_sp = 1; break; default: break; } } if (lflag) { if (dflag || sflag || eflag || cflag || iflag || csoptsflag) fatalerr(usage); return (print_classlist()); } else if (dflag) { if (lflag || sflag || eflag || cflag || csoptsflag) fatalerr(usage); if (iflag) { if (str2idtyp(idtypnm, &idtype) == -1) fatalerr("%s: bad idtype %s\n", cmdpath, idtypnm); } else { idtype = P_PID; } if (prio_optind < argc) { idargc = argc - prio_optind; idargv = &argv[prio_optind]; } else { idargc = 0; } return (print_procs(idtype, idargc, idargv)); } else if (sflag) { if (lflag || dflag || eflag) fatalerr(usage); if (iflag) { if (str2idtyp(idtypnm, &idtype) == -1) fatalerr("%s: bad idtype %s\n", cmdpath, idtypnm); } else { idtype = P_PID; } if (cflag == 0) clname = NULL; if (prio_optind < argc) { idargc = argc - prio_optind; idargv = &argv[prio_optind]; } else { idargc = 0; } set_procs(clname, idtype, idargc, idargv, argv); } else if (eflag) { if (lflag || dflag || sflag || iflag) fatalerr(usage); if (cflag == 0) clname = NULL; if (prio_optind >= argc) fatalerr(usage); exec_cmd(clname, argv); } else { fatalerr(usage); } return (0); } /* * Print the heading for the class list and execute the class * specific sub-command with the -l option for each configured class. */ static int print_classlist(void) { id_t cid; int nclass; pcinfo_t pcinfo; static char subcmdpath[128]; int status; pid_t pid; int error = 0; /* * No special privileges required for this operation. * Set the effective UID back to the real UID. */ if (setuid(getuid()) == -1) fatalerr("%s: Can't set effective UID back to real UID\n", cmdpath); if ((nclass = priocntl(0, 0, PC_GETCLINFO, NULL)) == -1) fatalerr("%s: Can't get number of configured classes, priocntl" " system call failed with errno %d\n", cmdpath, errno); (void) printf("CONFIGURED CLASSES\n==================\n\n"); (void) printf("SYS (System Class)\n"); for (cid = 1; cid < nclass; cid++) { (void) printf("\n"); (void) fflush(stdout); pcinfo.pc_cid = cid; if (priocntl(0, 0, PC_GETCLINFO, (caddr_t)&pcinfo) == -1) fatalerr("%s: can't get class name (class ID = %ld)\n", cmdpath, cid); if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s", CLASSPATH, pcinfo.pc_clname, pcinfo.pc_clname, basenm) >= sizeof (subcmdpath)) fatalerr("%s: can't generate %s specific subcommand\n", cmdpath, pcinfo.pc_clname); if ((pid = fork()) == 0) { (void) execl(subcmdpath, subcmdpath, "-l", (char *)0); (void) printf("%s\n", pcinfo.pc_clname); fatalerr("\tCan't execute %s specific subcommand\n", pcinfo.pc_clname); } else if (pid == (pid_t)-1) { (void) printf("%s\n", pcinfo.pc_clname); (void) fprintf(stderr, "Can't execute %s specific subcommand)\n", pcinfo.pc_clname); error = 1; } else { (void) wait(&status); if (status) error = 1; } } return (error); } /* * For each class represented within the set of processes specified by * idtype/idargv, print_procs() executes the class specific sub-command * with the -d option. We pipe to each sub-command a list of pids in * the set belonging to that class. */ static int print_procs(idtype_t idtype, int idargc, char *idargv[]) { int i; id_t id; id_t idlist[NIDS]; int nids; classpids_t *clpids; int nclass; id_t cid; pcinfo_t pcinfo; int pidexists; FILE *pipe_to_subcmd; char subcmd[128]; int error = 0; /* * Build a list of ids eliminating any duplicates in idargv. */ if (idtype == P_ALL) { /* * No idlist should be specified. If one is specified, * it is ignored. */ nids = 0; } else if (idargc == 0) { /* * No ids supplied by user; use current id. */ if (getmyid(idtype, &idlist[0]) == -1) fatalerr("%s: Can't get ID for current process," " idtype = %d\n", cmdpath, idtype); nids = 1; } else { nids = 0; for (i = 0; i < idargc && nids < NIDS; i++) { if (idtype == P_CID) { if ((id = clname2cid(idargv[i])) == -1) { (void) fprintf(stderr, "%s: Invalid or" " unconfigured class %s in idlist" " - ignored\n", cmdpath, idargv[i]); error = 1; } } else { id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX); if (errno) { (void) fprintf(stderr, "%s: Invalid id \"%s\"\n", cmdpath, idargv[i]); error = 1; id = BADPID; } } /* * lsearch(3C) adds ids to the idlist, * eliminating duplicates. */ (void) lsearch((void *)&id, (void *)idlist, (size_t *)&nids, sizeof (id), (int (*)())idcompar); } } if ((nclass = priocntl(0, 0, PC_GETCLINFO, NULL)) == -1) fatalerr("%s: Can't get number of configured classes, priocntl" " system call failed with errno %d\n", cmdpath, errno); if ((clpids = (classpids_t *)malloc(sizeof (classpids_t) * nclass)) == NULL) fatalerr("%s: Can't allocate memory for clpids.\n", cmdpath); for (cid = 1; cid < nclass; cid++) { pcinfo.pc_cid = cid; if (priocntl(0, 0, PC_GETCLINFO, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get class name, cid = %ld\n", cmdpath, cid); (void) strncpy(clpids[cid].clp_clname, pcinfo.pc_clname, PC_CLNMSZ); /* * The memory allocation for the pidlist uses realloc(). * A realloc() call is required, when "clp_npids" is * equal to "clp_pidlistsz". */ clpids[cid].clp_pidlist = (pid_t *)NULL; clpids[cid].clp_pidlistsz = 0; clpids[cid].clp_npids = 0; } /* * Build the pidlist. */ ids2pids(idtype, idlist, nids, clpids, nclass); /* * No need for special privileges any more. * Set the effective UID back to the real UID. */ if (setuid(getuid()) == -1) fatalerr("%s: Can't set effective UID back to real UID\n", cmdpath); pidexists = 0; for (cid = 1; cid < nclass; cid++) { if (clpids[cid].clp_npids == 0) continue; pidexists = 1; if (snprintf(subcmd, sizeof (subcmd), "%s/%s/%s%s -d", CLASSPATH, clpids[cid].clp_clname, clpids[cid].clp_clname, basenm) >= sizeof (subcmd)) { (void) fprintf(stderr, "Can't generate %s specific subcommand\n", clpids[cid].clp_clname); error = 1; free(clpids[cid].clp_pidlist); continue; } if ((pipe_to_subcmd = popen(subcmd, "w")) == NULL) { (void) printf("%s\n", clpids[cid].clp_clname); (void) fprintf(stderr, "Can't execute %s specific subcommand\n", clpids[cid].clp_clname); error = 1; free(clpids[cid].clp_pidlist); continue; } (void) fwrite(clpids[cid].clp_pidlist, sizeof (pid_t), clpids[cid].clp_npids, pipe_to_subcmd); if (pclose(pipe_to_subcmd)) error = 1; free(clpids[cid].clp_pidlist); } free(clpids); if (pidexists == 0) fatalerr("%s: Process(es) not found.\n", cmdpath); return (error); } /* * Execute the appropriate class specific sub-command with the arguments * pointed to by subcmdargv. If the user specified a class we simply * exec the sub-command for that class. If no class was specified we * verify that the processes in the set specified by idtype/idargv are * all in the same class and then execute the sub-command for that class. */ static void set_procs(char *clname, idtype_t idtype, int idargc, char **idargv, char **subcmdargv) { char idstr[PC_IDTYPNMSZ]; char myidstr[PC_IDTYPNMSZ]; char clnmbuf[PC_CLNMSZ]; pcinfo_t pcinfo; static psinfo_t prinfo; static prcred_t prcred; DIR *dirp; struct dirent *dentp; static char pname[100]; char *fname; int procfd; int saverr; static char subcmdpath[128]; boolean_t procinset; id_t id; size_t len; if (clname == NULL && idtype == P_PID && idargc <= 1) { /* * No class specified by user but only one process * in specified set. Get the class the easy way. */ if (idargc == 0) { if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL, PC_KY_CLNAME, clnmbuf, 0) == -1) if (errno == ESRCH) fatalerr("%s: Process not found.\n", cmdpath); else fatalerr("%s: Can't get class of" " current process\npriocntl" " system call failed with" " errno %d\n", cmdpath, errno); } else { /* idargc == 1 */ id = (id_t)str2num(idargv[0], INT_MIN, INT_MAX); if (errno) fatalerr("%s: Invalid id \"%s\"\n", cmdpath, idargv[0]); if (priocntl(P_PID, id, PC_GETXPARMS, NULL, PC_KY_CLNAME, clnmbuf, 0) == -1) if (errno == ESRCH) fatalerr("%s: Process not found.\n", cmdpath); else fatalerr("%s: Can't get class of " " specified process\npriocntl" " system call failed with" " errno %d\n", cmdpath, errno); } clname = clnmbuf; } else if (clname == NULL) { /* * No class specified by user and potentially more * than one process in specified set. Verify that * all procs in set are in the same class. */ if (idargc == 0 && idtype != P_ALL) { /* * No ids supplied by user; use current id. */ if (getmyidstr(idtype, myidstr) == -1) fatalerr("%s: Can't get ID string for current" " process, idtype = %d\n", cmdpath, idtype); } if ((dirp = opendir(procdir)) == NULL) fatalerr("%s: Can't open PROC directory %s\n", cmdpath, procdir); while ((dentp = readdir(dirp)) != NULL) { if (dentp->d_name[0] == '.') /* skip . and .. */ continue; len = snprintf(pname, sizeof (pname), "%s/%s/", procdir, dentp->d_name); /* Really max(sizeof ("psinfo"), sizeof ("cred")) */ if (len + sizeof ("psinfo") > sizeof (pname)) { (void) fprintf(stderr, "%s: skipping %s, name too long.\n", cmdpath, dentp->d_name); continue; } fname = pname + len; retry: (void) strcpy(fname, "psinfo"); if ((procfd = open(pname, O_RDONLY)) < 0) continue; if (read(procfd, &prinfo, sizeof (prinfo)) != sizeof (prinfo)) { saverr = errno; (void) close(procfd); if (saverr == EAGAIN) goto retry; if (saverr != ENOENT) { (void) fprintf(stderr, "%s: Can't get process info for" " %s\n", cmdpath, pname); } continue; } (void) close(procfd); if (idtype == P_UID || idtype == P_GID) { (void) strcpy(fname, "cred"); if ((procfd = open(pname, O_RDONLY)) < 0 || read(procfd, &prcred, sizeof (prcred)) != sizeof (prcred)) { saverr = errno; if (procfd >= 0) (void) close(procfd); if (saverr == EAGAIN) goto retry; if (saverr != ENOENT) { (void) fprintf(stderr, "%s: Can't get process" " credentials for %s\n", cmdpath, pname); } continue; } (void) close(procfd); } if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0) continue; switch (idtype) { case P_PID: itoa((long)prinfo.pr_pid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_PPID: itoa((long)prinfo.pr_ppid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_PGID: itoa((long)prinfo.pr_pgid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_SID: itoa((long)prinfo.pr_sid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_CID: procinset = idmatch(prinfo.pr_lwp.pr_clname, myidstr, idargc, idargv); break; case P_UID: itoa((long)prcred.pr_euid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_GID: itoa((long)prcred.pr_egid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_PROJID: itoa((long)prinfo.pr_projid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_TASKID: itoa((long)prinfo.pr_taskid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_ZONEID: itoa((long)prinfo.pr_zoneid, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_CTID: itoa((long)prinfo.pr_contract, idstr); procinset = idmatch(idstr, myidstr, idargc, idargv); break; case P_ALL: procinset = B_TRUE; break; default: fatalerr("%s: Bad idtype %d in set_procs()\n", cmdpath, idtype); } if (procinset == B_TRUE) { if (clname == NULL) { /* * First proc found in set. */ (void) strcpy(clnmbuf, prinfo.pr_lwp.pr_clname); clname = clnmbuf; } else if (strcmp(clname, prinfo.pr_lwp.pr_clname) != 0) { fatalerr("%s: Specified processes" " from different classes.\n", cmdpath); } } } (void) closedir(dirp); if (clname == NULL) fatalerr("%s: Process(es) not found.\n", cmdpath); } else { /* * User specified class. Check it for validity. */ (void) strcpy(pcinfo.pc_clname, clname); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Invalid or unconfigured class %s\n", cmdpath, clname); } /* * No need for special privileges any more. * Set the effective UID back to the real UID. */ if (setuid(getuid()) == -1) fatalerr("%s: Can't set effective UID back to real UID\n", cmdpath); if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s", CLASSPATH, clname, clname, basenm) >= sizeof (subcmdpath)) fatalerr("%s: can't generate %s specific subcommand\n", cmdpath, clname); subcmdargv[0] = subcmdpath; (void) execv(subcmdpath, subcmdargv); fatalerr("%s: Can't execute %s sub-command\n", cmdpath, clname); } /* * Execute the appropriate class specific sub-command with the arguments * pointed to by subcmdargv. If the user specified a class we simply * exec the sub-command for that class. If no class was specified we * execute the sub-command for our own current class. */ static void exec_cmd(char *clname, char **subcmdargv) { pcinfo_t pcinfo; char clnmbuf[PC_CLNMSZ]; char subcmdpath[128]; /* * No special privileges required for this operation. * Set the effective UID back to the real UID. */ if (setuid(getuid()) == -1) fatalerr("%s: Can't set effective UID back to real UID\n", cmdpath); if (clname == NULL) { if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL, PC_KY_CLNAME, clnmbuf, 0) == -1) fatalerr("%s: Can't get class name of current process\n" "priocntl system call failed with errno %d\n", cmdpath, errno); clname = clnmbuf; } else { /* * User specified class. Check it for validity. */ (void) strcpy(pcinfo.pc_clname, clname); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Invalid or unconfigured class %s\n", cmdpath, clname); } if (snprintf(subcmdpath, sizeof (subcmdpath), "%s/%s/%s%s", CLASSPATH, clname, clname, basenm) >= sizeof (subcmdpath)) fatalerr("%s: can't generate %s specific subcommand\n", cmdpath, clname); subcmdargv[0] = subcmdpath; (void) execv(subcmdpath, subcmdargv); fatalerr("%s: Can't execute %s sub-command\n", cmdpath, clname); } /* * Fill in the classpids structures in the array pointed to by clpids * with pids for the processes in the set specified by idtype/idlist. * We read the /proc//psinfo file to get the necessary process * information. */ static void ids2pids(idtype_t idtype, id_t *idlist, int nids, classpids_t *clpids, int nclass) { static psinfo_t prinfo; static prcred_t prcred; DIR *dirp; struct dirent *dentp; char pname[100]; char *fname; int procfd; int saverr; int i; char *clname; size_t len; if ((dirp = opendir(procdir)) == NULL) fatalerr("%s: Can't open PROC directory %s\n", cmdpath, procdir); while ((dentp = readdir(dirp)) != NULL) { if (dentp->d_name[0] == '.') /* skip . and .. */ continue; len = snprintf(pname, sizeof (pname), "%s/%s/", procdir, dentp->d_name); /* Really max(sizeof ("psinfo"), sizeof ("cred")) */ if (len + sizeof ("psinfo") > sizeof (pname)) { (void) fprintf(stderr, "%s: skipping %s, name too long.\n", cmdpath, dentp->d_name); continue; } fname = pname + len; retry: (void) strcpy(fname, "psinfo"); if ((procfd = open(pname, O_RDONLY)) < 0) continue; if (read(procfd, &prinfo, sizeof (prinfo)) != sizeof (prinfo)) { saverr = errno; (void) close(procfd); if (saverr == EAGAIN) goto retry; if (saverr != ENOENT) { (void) fprintf(stderr, "%s: Can't get process info for %s\n", cmdpath, pname); } continue; } (void) close(procfd); if (idtype == P_UID || idtype == P_GID) { (void) strcpy(fname, "cred"); if ((procfd = open(pname, O_RDONLY)) < 0 || read(procfd, &prcred, sizeof (prcred)) != sizeof (prcred)) { saverr = errno; (void) close(procfd); if (saverr == EAGAIN) goto retry; if (saverr != ENOENT) { (void) fprintf(stderr, "%s: Can't get process credentials" " for %s\n", cmdpath, pname); } continue; } (void) close(procfd); } if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0) continue; switch (idtype) { case P_PID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_pid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_PPID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_ppid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_PGID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_pgid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_SID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_sid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_CID: for (i = 0; i < nids; i++) { clname = clpids[idlist[i]].clp_clname; if (strcmp(clname, prinfo.pr_lwp.pr_clname) == 0) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_UID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prcred.pr_euid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_GID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prcred.pr_egid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_PROJID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_projid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_TASKID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_taskid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_ZONEID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_zoneid) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_CTID: for (i = 0; i < nids; i++) { if (idlist[i] == (id_t)prinfo.pr_contract) add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); } break; case P_ALL: add_pid_tolist(clpids, nclass, prinfo.pr_lwp.pr_clname, prinfo.pr_pid); break; default: fatalerr("%s: Bad idtype %d in ids2pids()\n", cmdpath, idtype); } } (void) closedir(dirp); } /* * Search the array pointed to by clpids for the classpids * structure corresponding to clname and add pid to its * pidlist. */ static void add_pid_tolist(classpids_t *clpids, int nclass, char *clname, pid_t pid) { classpids_t *clp; for (clp = clpids; clp != &clpids[nclass]; clp++) { if (strcmp(clp->clp_clname, clname) == 0) { if (clp->clp_npids == clp->clp_pidlistsz) increase_pidlist(clp); (clp->clp_pidlist)[clp->clp_npids] = pid; clp->clp_npids++; return; } } } static void increase_pidlist(classpids_t *clp) { if ((clp->clp_pidlist = realloc(clp->clp_pidlist, (clp->clp_pidlistsz + NPIDS) * sizeof (pid_t))) == NULL) /* * The pidlist is filled up and we cannot increase the size. */ fatalerr("%s: Can't allocate memory for pidlist.\n", cmdpath); clp->clp_pidlistsz += NPIDS; } /* * Compare id strings for equality. If idargv contains ids * (idargc > 0) compare idstr to each id in idargv, otherwise * just compare to curidstr. */ static boolean_t idmatch(char *idstr, char *curidstr, int idargc, char **idargv) { int i; if (idargc == 0) { if (strcmp(curidstr, idstr) == 0) return (B_TRUE); } else { for (i = 0; i < idargc; i++) { if (strcmp(idargv[i], idstr) == 0) return (B_TRUE); } } return (B_FALSE); } /* * This is a copy of the getopt() function found in libc:getopt.c. A separate * copy is required to fix the bug id #1114636. To fix the problem we need to * reset the _sp to 1. Since _sp in libc:getopt() is not exposed, a copy of * the getopt() is kept so that prio_sp can be reset to 1. */ static int prio_getopt(int argc, char * const *argv, char *opts) { char c; char *cp; if (prio_sp == 1) if (prio_optind >= argc || argv[prio_optind][0] != '-' || argv[prio_optind][1] == '\0') return (EOF); else if (strcmp(argv[prio_optind], "--") == 0) { prio_optind++; return (EOF); } prio_optopt = c = (unsigned char)argv[prio_optind][prio_sp]; if (c == ':' || (cp = strchr(opts, c)) == NULL) { if (argv[prio_optind][++prio_sp] == '\0') { prio_optind++; prio_sp = 1; } return ('?'); } if (*++cp == ':') { if (argv[prio_optind][prio_sp+1] != '\0') prio_optarg = &argv[prio_optind++][prio_sp+1]; else if (++prio_optind >= argc) { prio_sp = 1; return ('?'); } else prio_optarg = argv[prio_optind++]; prio_sp = 1; } else { if (argv[prio_optind][++prio_sp] == '\0') { prio_sp = 1; prio_optind++; } prio_optarg = NULL; } return (c); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ /* * Copyright 2001-2002 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #ifndef _PRIOCNTL_H #define _PRIOCNTL_H #ifdef __cplusplus extern "C" { #endif #define NPIDS 1024 /* number of additional pids allocated by realloc(). */ #define NIDS 1024 /* max number of id arguments we handle */ #define BASENMSZ 16 #define CSOPTSLN 128 /* max length of class specific opts string */ #define PC_IDTYPNMSZ 12 /* max length of an idtype name */ /* * The command string for the sub-command must be big enough for the * path, the class specific options, and plenty of space for arguments. */ #define SUBCMDSZ 512 #define BADPID (-2) extern void fatalerr(); extern int str2idtyp(char *, idtype_t *); extern int idtyp2str(idtype_t, char *); extern int idcompar(id_t *, id_t *); extern id_t clname2cid(char *); extern int getmyid(idtype_t, id_t *); extern int getmyidstr(idtype_t, char *); extern int verifyupri(idtype_t, id_t, char *, int, pri_t, char *); extern pid_t *read_pidlist(size_t *, FILE *); extern void free_pidlist(pid_t *); extern long str2num(char *, long, long); extern void itoa(long, char *); /* * The following is an excerpt from . HRT timers are not * supported by SunOS (which will support the POSIX definition). Priocntl * uses the hrt routine _hrtnewres because it coincidentally does the * right thing. These defines allow this routine to be locally included * in priocntl (rather than exported in libc). This should be improved in * the long term. */ #define HRT_TRUNC 0 /* Round results down. */ #define HRT_RND 1 /* Round results (rnd up if fractional */ /* part >= .5 otherwise round down). */ #define HRT_RNDUP 2 /* Always round results up. */ /* * Structure used to represent a high-resolution time-of-day * or interval. */ typedef struct hrtimer { ulong_t hrt_secs; /* Seconds. */ long hrt_rem; /* A value less than a second. */ ulong_t hrt_res; /* The resolution of hrt_rem. */ } hrtimer_t; extern int _hrtnewres(hrtimer_t *, ulong_t, long); #ifdef __cplusplus } #endif #endif /* _PRIOCNTL_H */ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "priocntl.h" /* * This file contains the class specific code implementing * the real-time priocntl sub-command. */ #define ADDKEYVAL(p, k, v) { (p[0]) = (k); (p[1]) = (v); p += 2; } #define RT_KEYCNT 4 /* maximal number of (key, value) pairs */ /* * control flags */ #define RT_DOPRI 0x01 /* change priority */ #define RT_DOTQ 0x02 /* change RT time quantum */ #define RT_DOSIG 0x10 /* change RT time quantum signal */ static void print_rtinfo(void); static int print_rtprocs(void); static int rt_priocntl(idtype_t, id_t, int, char *, uintptr_t *); static int set_rtprocs(idtype_t, int, char **, uint_t, pri_t, long, long, int); static void exec_rtcmd(char **, uint_t, pri_t, long, long, int); static char usage[] = "usage: priocntl -l\n" " priocntl -d [-i idtype] [idlist]\n" " priocntl -s [-c RT] [-p rtpri] [-t tqntm [-r res]] [-q tqsig]\n" " [-i idtype] [idlist]\n" " priocntl -e [-c RT] [-p rtpri] [-t tqntm [-r res]] [-q tqsig]\n" " command [argument(s)]\n"; static char cmdpath[MAXPATHLEN]; static char basenm[BASENMSZ]; int main(int argc, char *argv[]) { int c; int lflag, dflag, sflag, pflag; int tflag, rflag, eflag, iflag, qflag; pri_t rtpri; long tqntm; long res; int tqsig; char *idtypnm; idtype_t idtype; int idargc; uint_t cflags; (void) strlcpy(cmdpath, argv[0], MAXPATHLEN); (void) strlcpy(basenm, basename(argv[0]), BASENMSZ); lflag = dflag = sflag = pflag = 0; tflag = rflag = eflag = iflag = qflag = 0; while ((c = getopt(argc, argv, "ldsp:t:r:q:ec:i:")) != -1) { switch (c) { case 'l': lflag++; break; case 'd': dflag++; break; case 's': sflag++; break; case 'p': pflag++; rtpri = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified real time priority %s" " out of configured range\n", basenm, optarg); break; case 't': tflag++; tqntm = str2num(optarg, 1, INT_MAX); if (errno) fatalerr("%s: Invalid time quantum specified;" " time quantum must be positive\n", basenm); break; case 'r': rflag++; res = str2num(optarg, 1, 1000000000); if (errno) fatalerr("%s: Invalid resolution specified;" " resolution must be between" " 1 and 1,000,000,000\n", basenm); break; case 'q': qflag++; if (str2sig(optarg, &tqsig) != 0) fatalerr("%s: Invalid real time quantum signal" " specified\n", basenm); break; case 'e': eflag++; break; case 'c': if (strcmp(optarg, "RT") != 0) fatalerr("error: %s executed for %s class, %s" " is actually sub-command for RT class\n", cmdpath, optarg, cmdpath); break; case 'i': iflag++; idtypnm = optarg; break; case '?': fatalerr(usage); default: break; } } if (lflag) { if (dflag || sflag || pflag || tflag || rflag || eflag || iflag || qflag) fatalerr(usage); print_rtinfo(); } else if (dflag) { if (lflag || sflag || pflag || tflag || rflag || eflag || qflag) fatalerr(usage); return (print_rtprocs()); } else if (sflag) { if (lflag || dflag || eflag) fatalerr(usage); if (iflag) { if (str2idtyp(idtypnm, &idtype) == -1) fatalerr("%s: Bad idtype %s\n", basenm, idtypnm); } else { idtype = P_PID; } cflags = (pflag ? RT_DOPRI : 0); if (tflag) cflags |= RT_DOTQ; if (rflag == 0) res = 1000; if (optind < argc) idargc = argc - optind; else idargc = 0; if (qflag) cflags |= RT_DOSIG; return (set_rtprocs(idtype, idargc, &argv[optind], cflags, rtpri, tqntm, res, tqsig)); } else if (eflag) { if (lflag || dflag || sflag || iflag) fatalerr(usage); cflags = (pflag ? RT_DOPRI : 0); if (tflag) cflags |= RT_DOTQ; if (rflag == 0) res = 1000; if (qflag) cflags |= RT_DOSIG; exec_rtcmd(&argv[optind], cflags, rtpri, tqntm, res, tqsig); } else { fatalerr(usage); } return (0); } /* * Print our class name and the configured user priority range. */ static void print_rtinfo(void) { pcinfo_t pcinfo; (void) strcpy(pcinfo.pc_clname, "RT"); (void) printf("RT (Real Time)\n"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("\tCan't get maximum configured RT priority\n"); (void) printf("\tConfigured RT User Priority Range: 0 through %d\n", ((rtinfo_t *)pcinfo.pc_clinfo)->rt_maxpri); } /* * Read a list of pids from stdin and print the real-time priority and time * quantum (in millisecond resolution) for each of the corresponding processes. */ static int print_rtprocs(void) { pid_t *pidlist; size_t numread; int i; char clname[PC_CLNMSZ]; pri_t rt_pri; uint_t rt_tqsecs; int rt_tqnsecs; int rt_tqsig; int error = 0; /* * Read a list of pids from stdin. */ if ((pidlist = read_pidlist(&numread, stdin)) == NULL) fatalerr("%s: Can't read pidlist.\n", basenm); (void) printf("REAL TIME PROCESSES:\n" " PID RTPRI TQNTM TQSIG\n"); if (numread == 0) fatalerr("%s: No pids on input\n", basenm); for (i = 0; i < numread; i++) { (void) printf("%7ld", pidlist[i]); if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, "RT", RT_KY_TQSECS, &rt_tqsecs, RT_KY_TQNSECS, &rt_tqnsecs, RT_KY_PRI, &rt_pri, RT_KY_TQSIG, &rt_tqsig, 0) != -1) { (void) printf(" %5d", rt_pri); if (rt_tqnsecs == RT_TQINF) (void) printf(" RT_TQINF"); else (void) printf(" %11lld", (longlong_t)rt_tqsecs * 1000 + rt_tqnsecs / 1000000); (void) printf(" %3d\n", rt_tqsig); } else { error = 1; if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, NULL, PC_KY_CLNAME, clname, 0) != -1 && strcmp(clname, "RT")) /* * Process from some class other than real time. * It has probably changed class while priocntl * command was executing (otherwise we wouldn't * have been passed its pid). Print the little * we know about it. */ (void) printf("\tChanged to class %s while" " priocntl command executing\n", clname); else (void) printf("\tCan't get real time" " parameters\n"); } } free_pidlist(pidlist); return (error); } /* * Call priocntl() with command codes PC_SETXPARMS or PC_GETXPARMS. * The first parameter behind the command code is always the class name. * Each parameter is headed by a key, which determines the meaning of the * following value. There are maximal RT_KEYCNT = 4 (key, value) pairs. */ static int rt_priocntl(idtype_t idtype, id_t id, int cmd, char *clname, uintptr_t *argsp) { return (priocntl(idtype, id, cmd, clname, argsp[0], argsp[1], argsp[2], argsp[3], argsp[4], argsp[5], argsp[6], argsp[7], 0)); } /* * Set all processes in the set specified by idtype/idargv to real time * (if they aren't already real time) and set their real-time priority, * real-time quantum and real-time quantum signal to those specified by * rtpri, tqntm/res and rtqsig. */ static int set_rtprocs(idtype_t idtype, int idargc, char **idargv, uint_t cflags, pri_t rtpri, long tqntm, long res, int rtqsig) { pcinfo_t pcinfo; uintptr_t args[2*RT_KEYCNT+1]; uintptr_t *argsp = &args[0]; pri_t maxrtpri; hrtimer_t hrtime; char idtypnm[PC_IDTYPNMSZ]; int i; id_t id; int error = 0; /* * Get the real time class ID and max configured RT priority. */ (void) strcpy(pcinfo.pc_clname, "RT"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get RT class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxrtpri = ((rtinfo_t *)pcinfo.pc_clinfo)->rt_maxpri; /* * Validate the rtpri and res arguments. */ if ((cflags & RT_DOPRI) != 0) { if (rtpri > maxrtpri || rtpri < 0) fatalerr("%s: Specified real time priority %d out of" " configured range\n", basenm, rtpri); ADDKEYVAL(argsp, RT_KY_PRI, rtpri); } if ((cflags & RT_DOTQ) != 0) { hrtime.hrt_secs = 0; hrtime.hrt_rem = tqntm; hrtime.hrt_res = res; if (_hrtnewres(&hrtime, NANOSEC, HRT_RNDUP) == -1) fatalerr("%s: Can't convert resolution.\n", basenm); ADDKEYVAL(argsp, RT_KY_TQSECS, hrtime.hrt_secs); ADDKEYVAL(argsp, RT_KY_TQNSECS, hrtime.hrt_rem); } if ((cflags & RT_DOSIG) != 0) ADDKEYVAL(argsp, RT_KY_TQSIG, rtqsig); *argsp = 0; if (idtype == P_ALL) { if (rt_priocntl(P_ALL, 0, PC_SETXPARMS, "RT", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error encountered" " on one or more processes.\n"); error = 1; } else { fatalerr("%s: Can't reset real time parameters" "\npriocntl system call failed with" " errno %d\n", basenm, errno); } } } else if (idargc == 0) { if (rt_priocntl(idtype, P_MYID, PC_SETXPARMS, "RT", args) == -1) { if (errno == EPERM) { (void) idtyp2str(idtype, idtypnm); (void) fprintf(stderr, "Permissions error" " encountered on current %s.\n", idtypnm); error = 1; } else { fatalerr("%s: Can't reset real time parameters" "\npriocntl system call failed with" " errno %d\n", basenm, errno); } } } else { (void) idtyp2str(idtype, idtypnm); for (i = 0; i < idargc; i++) { if (idtype == P_CID) { (void) strcpy(pcinfo.pc_clname, idargv[i]); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Invalid or unconfigured" " class %s, priocntl system call" " failed with errno %d\n", basenm, pcinfo.pc_clname, errno); id = pcinfo.pc_cid; } else { id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX); if (errno) fatalerr("%s: Invalid id \"%s\"\n", basenm, idargv[i]); } if (rt_priocntl(idtype, id, PC_SETXPARMS, "RT", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error encountered on" " %s %s.\n", idtypnm, idargv[i]); error = 1; } else { fatalerr("%s: Can't reset real time" " parameters\npriocntl system call" " failed with errno %d\n", basenm, errno); } } } } return (error); } /* * Execute the command pointed to by cmdargv as a real-time process * with real time priority rtpri, quantum tqntm/res and quantum signal rtqsig. */ static void exec_rtcmd(char **cmdargv, uint_t cflags, pri_t rtpri, long tqntm, long res, int rtqsig) { pcinfo_t pcinfo; uintptr_t args[2*RT_KEYCNT+1]; uintptr_t *argsp = &args[0]; pri_t maxrtpri; hrtimer_t hrtime; /* * Get the real time class ID and max configured RT priority. */ (void) strcpy(pcinfo.pc_clname, "RT"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get RT class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxrtpri = ((rtinfo_t *)pcinfo.pc_clinfo)->rt_maxpri; if ((cflags & RT_DOPRI) != 0) { if (rtpri > maxrtpri || rtpri < 0) fatalerr("%s: Specified real time priority %d out of" " configured range\n", basenm, rtpri); ADDKEYVAL(argsp, RT_KY_PRI, rtpri); } if ((cflags & RT_DOTQ) != 0) { hrtime.hrt_secs = 0; hrtime.hrt_rem = tqntm; hrtime.hrt_res = res; if (_hrtnewres(&hrtime, NANOSEC, HRT_RNDUP) == -1) fatalerr("%s: Can't convert resolution.\n", basenm); ADDKEYVAL(argsp, RT_KY_TQSECS, hrtime.hrt_secs); ADDKEYVAL(argsp, RT_KY_TQNSECS, hrtime.hrt_rem); } if ((cflags & RT_DOSIG) != 0) ADDKEYVAL(argsp, RT_KY_TQSIG, rtqsig); *argsp = 0; if (rt_priocntl(P_PID, P_MYID, PC_SETXPARMS, "RT", args) == -1) fatalerr("%s: Can't reset real time parameters\n" "priocntl system call failed with errno %d\n", basenm, errno); (void) execvp(cmdargv[0], cmdargv); fatalerr("%s: Can't execute %s, exec failed with errno %d\n", basenm, cmdargv[0], errno); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include #include #include #include #include #include #include #include "priocntl.h" static char usage[] = "usage: priocntl -l\n\ priocntl -d [-i idtype] [idlist]\n"; /* * A whole lot of to-do for a scheduling class that can't actually be * configured or used by user processes. */ int main(int argc, char *argv[]) { int dflag, eflag, iflag, lflag, sflag; int c; char cmdpath[MAXPATHLEN]; char basenm[BASENMSZ]; (void) strlcpy(cmdpath, argv[0], MAXPATHLEN); (void) strlcpy(basenm, basename(argv[0]), BASENMSZ); dflag = eflag = iflag = lflag = sflag = 0; while ((c = getopt(argc, argv, "c:dei:ls")) != -1) { switch (c) { case 'c': if (strcmp(optarg, "SDC") != 0) fatalerr("error: %s executed for %s class, " "%s is actually sub-command for %s class\n", cmdpath, optarg, cmdpath, "SDC"); break; case 'd': dflag++; break; case 'e': eflag++; break; case 'i': iflag++; /* optarg is parsed, but ignored */ break; case 'l': lflag++; break; case 's': sflag++; break; case '?': fatalerr(usage); /*NOTREACHED*/ default: break; } } if (sflag && eflag) { fatalerr(usage); } if (sflag || eflag) { fatalerr( "priocntl: \"-%c\" may not be used with the %s class\n", (sflag ? 's' : 'e'), "SDC"); } if ((!dflag && !lflag) || (dflag && lflag)) { fatalerr(usage); } if (dflag) { pid_t *pidlist; size_t numread, i; /* * No scheduling-class-specific information to print, * but we read the pidlist to avoid generating a SIGPIPE * in the main priocntl process. Once we've read it, * we might as well print it. */ if ((pidlist = read_pidlist(&numread, stdin)) == NULL) { fatalerr("%s: Can't read pidlist.\n", basenm); } else if (numread == 0) { fatalerr("%s: No pids on input.\n", basenm); } else { (void) printf("SYSTEM DUTY-CYCLE PROCESSES:\n"); (void) printf("%7s\n", "PID"); for (i = 0; i < numread; i++) { (void) printf("%7ld\n", pidlist[i]); } } free_pidlist(pidlist); } else { (void) printf("SDC (System Duty-Cycle Class)\n"); } return (0); } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "priocntl.h" /*LINTLIBRARY*/ /* * Utility functions for priocntl command. */ static char *procdir = "/proc"; /*PRINTFLIKE1*/ void fatalerr(format, a1, a2, a3, a4, a5) char *format; int a1, a2, a3, a4, a5; { (void) fprintf(stderr, format, a1, a2, a3, a4, a5); exit(1); } /* * Structure defining idtypes known to the priocntl command * along with the corresponding names * The idtype values themselves are defined in . */ static struct idtypes { idtype_t idtype; char *idtypnm; } idtypes [] = { { P_PID, "pid" }, { P_PPID, "ppid" }, { P_PGID, "pgid" }, { P_SID, "sid" }, { P_CID, "class" }, { P_UID, "uid" }, { P_GID, "gid" }, { P_PROJID, "projid" }, { P_TASKID, "taskid" }, { P_ZONEID, "zoneid" }, { P_CTID, "ctid" }, { P_ALL, "all" } }; #define IDCNT (sizeof (idtypes) / sizeof (struct idtypes)) int str2idtyp(idtypnm, idtypep) char *idtypnm; idtype_t *idtypep; { register struct idtypes *curp; register struct idtypes *endp; for (curp = idtypes, endp = &idtypes[IDCNT]; curp < endp; curp++) { if (strcmp(curp->idtypnm, idtypnm) == 0) { *idtypep = curp->idtype; return (0); } } return (-1); } int idtyp2str(idtype, idtypnm) idtype_t idtype; char *idtypnm; { register struct idtypes *curp; register struct idtypes *endp; for (curp = idtypes, endp = &idtypes[IDCNT]; curp < endp; curp++) { if (idtype == curp->idtype) { (void) strncpy(idtypnm, curp->idtypnm, PC_IDTYPNMSZ); return (0); } } return (-1); } /* * Compare two IDs for equality. */ int idcompar(id1p, id2p) id_t *id1p; id_t *id2p; { if (*id1p == *id2p) return (0); else return (-1); } id_t clname2cid(clname) char *clname; { pcinfo_t pcinfo; (void) strncpy(pcinfo.pc_clname, clname, PC_CLNMSZ); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) return ((id_t)-1); return (pcinfo.pc_cid); } int getmyid(idtype, idptr) idtype_t idtype; id_t *idptr; { pcinfo_t pcinfo; switch (idtype) { case P_PID: *idptr = (id_t)getpid(); break; case P_PPID: *idptr = (id_t)getppid(); break; case P_PGID: *idptr = (id_t)getpgrp(); break; case P_SID: *idptr = (id_t)getsid(getpid()); break; case P_CID: if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL, PC_KY_CLNAME, pcinfo.pc_clname, 0) == -1 || priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) return (-1); *idptr = pcinfo.pc_cid; break; case P_UID: *idptr = (id_t)getuid(); break; case P_GID: *idptr = (id_t)getgid(); break; case P_PROJID: *idptr = (id_t)getprojid(); break; case P_TASKID: *idptr = (id_t)gettaskid(); break; case P_ZONEID: *idptr = (id_t)getzoneid(); break; case P_CTID: { ctid_t id = getctid(); if (id == -1) return (-1); *idptr = id; break; } default: return (-1); } return (0); } int getmyidstr(idtype, idstr) idtype_t idtype; char *idstr; { char clname[PC_CLNMSZ]; switch (idtype) { case P_PID: itoa((long)getpid(), idstr); break; case P_PPID: itoa((long)getppid(), idstr); break; case P_PGID: itoa((long)getpgrp(), idstr); break; case P_SID: itoa((long)getsid(getpid()), idstr); break; case P_CID: if (priocntl(P_PID, P_MYID, PC_GETXPARMS, NULL, PC_KY_CLNAME, clname, 0) == -1) return (-1); (void) strncpy(idstr, clname, PC_CLNMSZ); break; case P_UID: itoa((long)getuid(), idstr); break; case P_GID: itoa((long)getgid(), idstr); break; case P_PROJID: itoa((long)getprojid(), idstr); break; case P_TASKID: itoa((long)gettaskid(), idstr); break; case P_ZONEID: itoa((long)getzoneid(), idstr); break; case P_CTID: { id_t id; if ((id = getctid()) == -1) return (-1); itoa((long)id, idstr); break; } default: return (-1); } return (0); } /* * Look for pids with "upri > uprilim" in the set specified by idtype/id. * If upri exceeds uprilim then print a warning. */ int verifyupri(idtype_t idtype, id_t id, char *clname, int key, pri_t upri, char *basenm) { psinfo_t prinfo; prcred_t prcred; DIR *dirp; struct dirent *dentp; char pname[MAXNAMLEN]; char *fname; int procfd; int saverr; pri_t uprilim; int verify; int error = 0; if (idtype == P_PID) { if (priocntl(P_PID, id, PC_GETXPARMS, clname, key, &uprilim, 0) == -1) error = -1; else if (upri > uprilim) (void) fprintf(stderr, "%s: Specified user priority %d exceeds" " limit %d; set to %d (pid %d)\n", basenm, upri, uprilim, uprilim, (int)id); return (error); } /* * Look for the processes in the set specified by idtype/id. * We read the /proc//psinfo file to get the necessary * process information. */ if ((dirp = opendir(procdir)) == NULL) fatalerr("%s: Can't open PROC directory %s\n", basenm, procdir); while ((dentp = readdir(dirp)) != NULL) { if (dentp->d_name[0] == '.') /* skip . and .. */ continue; (void) snprintf(pname, MAXNAMLEN, "%s/%s/", procdir, dentp->d_name); fname = pname + strlen(pname); retry: (void) strncpy(fname, "psinfo", strlen("psinfo") + 1); if ((procfd = open(pname, O_RDONLY)) < 0) continue; if (read(procfd, &prinfo, sizeof (prinfo)) != sizeof (prinfo)) { saverr = errno; (void) close(procfd); if (saverr == EAGAIN) goto retry; continue; } (void) close(procfd); if (idtype == P_UID || idtype == P_GID) { (void) strncpy(fname, "cred", strlen("cred") + 1); if ((procfd = open(pname, O_RDONLY)) < 0 || read(procfd, &prcred, sizeof (prcred)) != sizeof (prcred)) { saverr = errno; (void) close(procfd); if (saverr == EAGAIN) goto retry; continue; } (void) close(procfd); } if (prinfo.pr_lwp.pr_state == 0 || prinfo.pr_nlwp == 0) continue; /* * The lwp must be in the correct class. */ if (strncmp(clname, prinfo.pr_lwp.pr_clname, PC_CLNMSZ) != 0) continue; verify = 0; switch (idtype) { case P_PPID: if (id == (id_t)prinfo.pr_ppid) verify++; break; case P_PGID: if (id == (id_t)prinfo.pr_pgid) verify++; break; case P_SID: if (id == (id_t)prinfo.pr_sid) verify++; break; case P_UID: if (id == (id_t)prcred.pr_euid) verify++; break; case P_GID: if (id == (id_t)prcred.pr_egid) verify++; break; case P_PROJID: if (id == (id_t)prinfo.pr_projid) verify++; break; case P_TASKID: if (id == (id_t)prinfo.pr_taskid) verify++; break; case P_ZONEID: if (id == (id_t)prinfo.pr_zoneid) verify++; break; case P_CTID: if (id == (id_t)prinfo.pr_contract) verify++; break; case P_CID: case P_ALL: verify++; break; default: fatalerr("%s: Bad idtype %d in verifyupri()\n", basenm, idtype); } if (verify) { if (priocntl(P_PID, prinfo.pr_pid, PC_GETXPARMS, clname, key, &uprilim, 0) == -1) error = -1; else if (upri > uprilim) (void) fprintf(stderr, "%s: Specified user priority %d exceeds" " limit %d; set to %d (pid %d)\n", basenm, upri, uprilim, uprilim, (int)prinfo.pr_pid); } } (void) closedir(dirp); return (error); } /* * Read a list of pids from a stream. */ pid_t * read_pidlist(size_t *npidsp, FILE *filep) { size_t nitems; pid_t *pidlist = NULL; *npidsp = 0; do { if ((pidlist = (pid_t *)realloc(pidlist, (*npidsp + NPIDS) * sizeof (pid_t))) == NULL) return (NULL); nitems = fread(pidlist + *npidsp, sizeof (pid_t), NPIDS, filep); if (ferror(filep)) return (NULL); *npidsp += nitems; } while (nitems == NPIDS); return (pidlist); } void free_pidlist(pid_t *pidlist) { free(pidlist); } long str2num(char *p, long min, long max) { long val; char *q; errno = 0; val = strtol(p, &q, 10); if (errno != 0 || q == p || *q != '\0' || val < min || val > max) errno = EINVAL; return (val); } /* * itoa() and reverse() taken almost verbatim from K & R Chapter 3. */ static void reverse(); /* * itoa(): Convert n to characters in s. */ void itoa(n, s) long n; char *s; { long i, sign; if ((sign = n) < 0) /* record sign */ n = -n; /* make sign positive */ i = 0; do { /* generate digits in reverse order */ s[i++] = n % 10 + '0'; /* get next digit */ } while ((n /= 10) > 0); /* delete it */ if (sign < 0) s[i++] = '-'; s[i] = '\0'; reverse(s); } /* * reverse(): Reverse string s in place. */ static void reverse(s) char *s; { int c, i, j; for (i = 0, j = strlen(s) - 1; i < j; i++, j--) { c = s[i]; s[i] = s[j]; s[j] = (char)c; } } /* * The following routine was removed from libc (libc/port/gen/hrtnewres.c). * It has also been added to disadmin, so if you fix it here, you should * also probably fix it there. In the long term, this should be recoded to * not be hrt'ish. */ /* * Convert interval expressed in htp->hrt_res to new_res. * * Calculate: (interval * new_res) / htp->hrt_res rounding off as * specified by round. * * Note: All args are assumed to be positive. If * the last divide results in something bigger than * a long, then -1 is returned instead. */ int _hrtnewres(htp, new_res, round) register hrtimer_t *htp; register ulong_t new_res; long round; { register long interval; longlong_t dint; longlong_t dto_res; longlong_t drem; longlong_t dfrom_res; longlong_t prod; longlong_t quot; register long numerator; register long result; ulong_t modulus; ulong_t twomodulus; long temp; if (new_res > NANOSEC || htp->hrt_rem < 0) return (-1); if (htp->hrt_rem >= htp->hrt_res) { htp->hrt_secs += htp->hrt_rem / htp->hrt_res; htp->hrt_rem = htp->hrt_rem % htp->hrt_res; } interval = htp->hrt_rem; if (interval == 0) { htp->hrt_res = new_res; return (0); } /* * Try to do the calculations in single precision first * (for speed). If they overflow, use double precision. * What we want to compute is: * * (interval * new_res) / hrt->hrt_res */ numerator = interval * new_res; if (numerator / new_res == interval) { /* * The above multiply didn't give overflow since * the division got back the original number. Go * ahead and compute the result. */ result = numerator / htp->hrt_res; /* * For HRT_RND, compute the value of: * * (interval * new_res) % htp->hrt_res * * If it is greater than half of the htp->hrt_res, * then rounding increases the result by 1. * * For HRT_RNDUP, we increase the result by 1 if: * * result * htp->hrt_res != numerator * * because this tells us we truncated when calculating * result above. * * We also check for overflow when incrementing result * although this is extremely rare. */ if (round == HRT_RND) { modulus = numerator - result * htp->hrt_res; if ((twomodulus = 2 * modulus) / 2 == modulus) { /* * No overflow (if we overflow in calculation * of twomodulus we fall through and use * double precision). */ if (twomodulus >= htp->hrt_res) { temp = result + 1; if (temp - 1 == result) result++; else return (-1); } htp->hrt_res = new_res; htp->hrt_rem = result; return (0); } } else if (round == HRT_RNDUP) { if (result * htp->hrt_res != numerator) { temp = result + 1; if (temp - 1 == result) result++; else return (-1); } htp->hrt_res = new_res; htp->hrt_rem = result; return (0); } else { /* round == HRT_TRUNC */ htp->hrt_res = new_res; htp->hrt_rem = result; return (0); } } /* * We would get overflow doing the calculation is * single precision so do it the slow but careful way. * * Compute the interval times the resolution we are * going to. */ dint = interval; dto_res = new_res; prod = dint * dto_res; /* * For HRT_RND the result will be equal to: * * ((interval * new_res) + htp->hrt_res / 2) / htp->hrt_res * * and for HRT_RNDUP we use: * * ((interval * new_res) + htp->hrt_res - 1) / htp->hrt_res * * This is a different but equivalent way of rounding. */ if (round == HRT_RND) { drem = htp->hrt_res / 2; prod = prod + drem; } else if (round == HRT_RNDUP) { drem = htp->hrt_res - 1; prod = prod + drem; } dfrom_res = htp->hrt_res; quot = prod / dfrom_res; /* * If the quotient won't fit in a long, then we have * overflow. Otherwise, return the result. */ if (quot > UINT_MAX) { return (-1); } else { htp->hrt_res = new_res; htp->hrt_rem = (int)quot; return (0); } } /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include #include #include #include #include #include #include #include #include #include #include "priocntl.h" /* * This file contains the class specific code implementing * the time-sharing priocntl sub-command. */ #define ADDKEYVAL(p, k, v) { (p[0]) = (k); (p[1]) = (v); p += 2; } #define TS_KEYCNT 2 /* maximal number of (key, value) pairs */ /* * control flags */ #define TS_DOUPRILIM 0x01 /* user priority limit */ #define TS_DOUPRI 0x02 /* user priority */ static void print_tsinfo(void); static int print_tsprocs(void); static int ts_priocntl(idtype_t, id_t, int, char *, uintptr_t *); static int set_tsprocs(idtype_t, int, char **, uint_t, pri_t, pri_t); static void exec_tscmd(char **, uint_t, pri_t, pri_t); static char usage[] = "usage: priocntl -l\n\ priocntl -d [-d idtype] [idlist]\n\ priocntl -s [-c TS] [-m tsuprilim] [-p tsupri] [-i idtype] [idlist]\n\ priocntl -e [-c TS] [-m tsuprilim] [-p tsupri] command [argument(s)]\n"; static char cmdpath[MAXPATHLEN]; static char basenm[BASENMSZ]; int main(int argc, char *argv[]) { int c; int lflag, dflag, sflag, mflag, pflag, eflag, iflag; pri_t tsuprilim; pri_t tsupri; char *idtypnm; idtype_t idtype; int idargc; uint_t cflags; (void) strlcpy(cmdpath, argv[0], MAXPATHLEN); (void) strlcpy(basenm, basename(argv[0]), BASENMSZ); lflag = dflag = sflag = mflag = pflag = eflag = iflag = 0; while ((c = getopt(argc, argv, "ldsm:p:ec:i:")) != -1) { switch (c) { case 'l': lflag++; break; case 'd': dflag++; break; case 's': sflag++; break; case 'm': mflag++; tsuprilim = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority limit %s" " out of configured range\n", basenm, optarg); break; case 'p': pflag++; tsupri = (pri_t)str2num(optarg, SHRT_MIN, SHRT_MAX); if (errno) fatalerr("%s: Specified user priority %s out of" " configured range\n", basenm, optarg); break; case 'e': eflag++; break; case 'c': if (strcmp(optarg, "TS") != 0) fatalerr("error: %s executed for %s class, %s" " is actually sub-command for TS class\n", cmdpath, optarg, cmdpath); break; case 'i': iflag++; idtypnm = optarg; break; case '?': fatalerr(usage); default: break; } } if (lflag) { if (dflag || sflag || mflag || pflag || eflag || iflag) fatalerr(usage); print_tsinfo(); } else if (dflag) { if (lflag || sflag || mflag || pflag || eflag) fatalerr(usage); return (print_tsprocs()); } else if (sflag) { if (lflag || dflag || eflag) fatalerr(usage); if (iflag) { if (str2idtyp(idtypnm, &idtype) == -1) fatalerr("%s: Bad idtype %s\n", basenm, idtypnm); } else { idtype = P_PID; } cflags = (pflag ? TS_DOUPRI : 0); if (mflag) cflags |= TS_DOUPRILIM; if (optind < argc) idargc = argc - optind; else idargc = 0; return (set_tsprocs(idtype, idargc, &argv[optind], cflags, tsuprilim, tsupri)); } else if (eflag) { if (lflag || dflag || sflag || iflag) fatalerr(usage); cflags = (pflag ? TS_DOUPRI : 0); if (mflag) cflags |= TS_DOUPRILIM; exec_tscmd(&argv[optind], cflags, tsuprilim, tsupri); } else { fatalerr(usage); } return (0); } /* * Print our class name and the configured user priority range. */ static void print_tsinfo(void) { pcinfo_t pcinfo; (void) strcpy(pcinfo.pc_clname, "TS"); (void) printf("TS (Time Sharing)\n"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("\tCan't get configured TS user priority range\n"); (void) printf("\tConfigured TS User Priority Range: -%d through %d\n", ((tsinfo_t *)pcinfo.pc_clinfo)->ts_maxupri, ((tsinfo_t *)pcinfo.pc_clinfo)->ts_maxupri); } /* * Read a list of pids from stdin and print the user priority and user * priority limit for each of the corresponding processes. */ static int print_tsprocs(void) { pid_t *pidlist; size_t numread; int i; char clname[PC_CLNMSZ]; pri_t ts_uprilim; pri_t ts_upri; int error = 0; /* * Read a list of pids from stdin. */ if ((pidlist = read_pidlist(&numread, stdin)) == NULL) fatalerr("%s: Can't read pidlist.\n", basenm); (void) printf( "TIME SHARING PROCESSES:\n PID TSUPRILIM TSUPRI\n"); if (numread == 0) fatalerr("%s: No pids on input\n", basenm); for (i = 0; i < numread; i++) { (void) printf("%7ld", pidlist[i]); if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, "TS", TS_KY_UPRI, &ts_upri, TS_KY_UPRILIM, &ts_uprilim, 0) != -1) { (void) printf(" %5d %5d\n", ts_uprilim, ts_upri); } else { error = 1; if (priocntl(P_PID, pidlist[i], PC_GETXPARMS, NULL, PC_KY_CLNAME, clname, 0) != -1 && strcmp(clname, "TS")) /* * Process from some class other than time * sharing. It has probably changed class while * priocntl command was executing (otherwise * we wouldn't have been passed its pid). * Print the little we know about it. */ (void) printf("\tChanged to class %s while" " priocntl command executing\n", clname); else (void) printf("\tCan't get TS user priority\n"); } } free_pidlist(pidlist); return (error); } /* * Call priocntl() with command codes PC_SETXPARMS or PC_GETXPARMS. * The first parameter behind the command code is always the class name. * Each parameter is headed by a key, which determines the meaning of the * following value. There are maximal TS_KEYCNT = 2 (key, value) pairs. */ static int ts_priocntl(idtype_t idtype, id_t id, int cmd, char *clname, uintptr_t *argsp) { return (priocntl(idtype, id, cmd, clname, argsp[0], argsp[1], argsp[2], argsp[3], 0)); } /* * Set all processes in the set specified by idtype/idargv to time-sharing * (if they aren't already time-sharing) and set their user priority limit * and user priority to those specified by tsuprilim and tsupri. */ static int set_tsprocs(idtype_t idtype, int idargc, char **idargv, uint_t cflags, pri_t tsuprilim, pri_t tsupri) { pcinfo_t pcinfo; uintptr_t args[2*TS_KEYCNT+1]; uintptr_t *argsp = &args[0]; pri_t maxupri; char idtypnm[PC_IDTYPNMSZ]; int i; int error = 0; id_t id; /* * Get the time sharing class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "TS"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get TS class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxupri = ((tsinfo_t *)pcinfo.pc_clinfo)->ts_maxupri; /* * Validate the tsuprilim and tsupri arguments. */ if ((cflags & TS_DOUPRILIM) != 0) { if (tsuprilim > maxupri || tsuprilim < -maxupri) fatalerr("%s: Specified user priority limit %d out of" " configured range\n", basenm, tsuprilim); ADDKEYVAL(argsp, TS_KY_UPRILIM, tsuprilim); } if ((cflags & TS_DOUPRI) != 0) { if (tsupri > maxupri || tsupri < -maxupri) fatalerr("%s: Specified user priority %d out of" " configured range\n", basenm, tsupri); ADDKEYVAL(argsp, TS_KY_UPRI, tsupri); } *argsp = 0; if (idtype == P_ALL) { if (ts_priocntl(P_ALL, 0, PC_SETXPARMS, "TS", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error encountered" " on one or more processes.\n"); error = 1; } else { fatalerr("%s: Can't reset time sharing" " parameters\npriocntl system call failed" " with errno %d\n", basenm, errno); } } else if ((cflags & (TS_DOUPRILIM|TS_DOUPRI)) == TS_DOUPRI) { (void) verifyupri(idtype, 0, "TS", TS_KY_UPRILIM, tsupri, basenm); } } else if (idargc == 0) { if (ts_priocntl(idtype, P_MYID, PC_SETXPARMS, "TS", args) == -1) { if (errno == EPERM) { (void) idtyp2str(idtype, idtypnm); (void) fprintf(stderr, "Permissions error" " encountered on current %s.\n", idtypnm); error = 1; } else { fatalerr("%s: Can't reset time sharing" " parameters\npriocntl system call failed" " with errno %d\n", basenm, errno); } } else if ((cflags & (TS_DOUPRILIM|TS_DOUPRI)) == TS_DOUPRI && getmyid(idtype, &id) != -1) { (void) verifyupri(idtype, id, "TS", TS_KY_UPRILIM, tsupri, basenm); } } else { (void) idtyp2str(idtype, idtypnm); for (i = 0; i < idargc; i++) { if (idtype == P_CID) { (void) strcpy(pcinfo.pc_clname, idargv[i]); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Invalid or unconfigured" " class %s, priocntl system call" " failed with errno %d\n", basenm, pcinfo.pc_clname, errno); id = pcinfo.pc_cid; } else { id = (id_t)str2num(idargv[i], INT_MIN, INT_MAX); if (errno) fatalerr("%s: Invalid id \"%s\"\n", basenm, idargv[i]); } if (ts_priocntl(idtype, id, PC_SETXPARMS, "TS", args) == -1) { if (errno == EPERM) { (void) fprintf(stderr, "Permissions error encountered on" " %s %s.\n", idtypnm, idargv[i]); error = 1; } else { fatalerr("%s: Can't reset time sharing" " parameters\npriocntl system call" " failed with errno %d\n", basenm, errno); } } else if ((cflags & (TS_DOUPRILIM|TS_DOUPRI)) == TS_DOUPRI) { (void) verifyupri(idtype, id, "TS", TS_KY_UPRILIM, tsupri, basenm); } } } return (error); } /* * Execute the command pointed to by cmdargv as a time-sharing process * with the user priority limit given by tsuprilim and user priority tsupri. */ static void exec_tscmd(char **cmdargv, uint_t cflags, pri_t tsuprilim, pri_t tsupri) { pcinfo_t pcinfo; uintptr_t args[2*TS_KEYCNT+1]; uintptr_t *argsp = &args[0]; pri_t maxupri; pri_t uprilim; /* * Get the time sharing class ID and max configured user priority. */ (void) strcpy(pcinfo.pc_clname, "TS"); if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1) fatalerr("%s: Can't get TS class ID, priocntl system call" " failed with errno %d\n", basenm, errno); maxupri = ((tsinfo_t *)pcinfo.pc_clinfo)->ts_maxupri; if ((cflags & TS_DOUPRILIM) != 0) { if (tsuprilim > maxupri || tsuprilim < -maxupri) fatalerr("%s: Specified user priority limit %d out of" " configured range\n", basenm, tsuprilim); ADDKEYVAL(argsp, TS_KY_UPRILIM, tsuprilim); } if ((cflags & TS_DOUPRI) != 0) { if (tsupri > maxupri || tsupri < -maxupri) fatalerr("%s: Specified user priority %d out of" " configured range\n", basenm, tsupri); ADDKEYVAL(argsp, TS_KY_UPRI, tsupri); } *argsp = 0; if (ts_priocntl(P_PID, P_MYID, PC_SETXPARMS, "TS", args) == -1) fatalerr("%s: Can't reset time sharing parameters\n" "priocntl system call failed with errno %d\n", basenm, errno); if ((cflags & (TS_DOUPRILIM|TS_DOUPRI)) == TS_DOUPRI) { if (priocntl(P_PID, P_MYID, PC_GETXPARMS, "TS", TS_KY_UPRILIM, &uprilim, 0) != -1 && tsupri > uprilim) (void) fprintf(stderr, "%s: Specified user priority %d exceeds" " limit %d; set to %d (pid %d)\n", basenm, tsupri, uprilim, uprilim, (int)getpid()); } (void) execvp(cmdargv[0], cmdargv); fatalerr("%s: Can't execute %s, exec failed with errno %d\n", basenm, cmdargv[0], errno); }