schedctl.c revision 1.9
1 /* $NetBSD: schedctl.c,v 1.9 2008/05/29 11:32:07 ad Exp $ */ 2 3 /* 4 * Copyright (c) 2008, Mindaugas Rasiukevicius <rmind at NetBSD org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* 30 * schedctl(8) - a program to control scheduling of processes and threads. 31 */ 32 33 #include <sys/cdefs.h> 34 35 #ifndef lint 36 __RCSID("$NetBSD: schedctl.c,v 1.9 2008/05/29 11:32:07 ad Exp $"); 37 #endif 38 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <string.h> 42 43 #include <err.h> 44 #include <fcntl.h> 45 #include <kvm.h> 46 #include <unistd.h> 47 48 #include <sys/pset.h> 49 #include <sys/sched.h> 50 #include <sys/sysctl.h> 51 #include <sys/types.h> 52 53 static const char *class_str[] = { 54 "SCHED_OTHER", 55 "SCHED_FIFO", 56 "SCHED_RR", 57 NULL 58 }; 59 60 static void sched_set(pid_t, lwpid_t, int, struct sched_param *, cpuset_t *); 61 static void thread_info(pid_t, lwpid_t); 62 static cpuset_t *makecpuset(char *); 63 static char *showcpuset(cpuset_t *); 64 static void usage(void); 65 66 static u_int ncpu; 67 68 int 69 main(int argc, char **argv) 70 { 71 kvm_t *kd; 72 struct kinfo_lwp *lwp_list, *lwp; 73 struct sched_param *sp; 74 cpuset_t *cpuset; 75 int i, count, ch, policy; 76 pid_t pid; 77 lwpid_t lid; 78 bool set; 79 80 ncpu = sysconf(_SC_NPROCESSORS_CONF); 81 82 pid = lid = 0; 83 cpuset = NULL; 84 set = false; 85 86 sp = calloc(1, sizeof(struct sched_param)); 87 if (sp == NULL) 88 err(EXIT_FAILURE, "calloc"); 89 90 sp->sched_priority = PRI_NONE; 91 policy = SCHED_NONE; 92 93 while ((ch = getopt(argc, argv, "A:C:P:p:t:")) != -1) { 94 switch (ch) { 95 case 'p': 96 /* PID */ 97 pid = atoi(optarg); 98 break; 99 case 't': 100 /* Thread (LWP) ID */ 101 lid = atoi(optarg); 102 break; 103 case 'A': 104 /* Affinity */ 105 cpuset = makecpuset(optarg); 106 if (cpuset == NULL) { 107 fprintf(stderr, "%s: invalid CPU value\n", 108 getprogname()); 109 exit(EXIT_FAILURE); 110 } 111 break; 112 case 'C': 113 /* Scheduling class */ 114 for (policy = 0; class_str[policy] != NULL; policy++) { 115 if (strcasecmp(optarg, class_str[policy]) == 0) 116 break; 117 } 118 if (class_str[policy] == NULL) 119 policy = atoi(optarg); 120 if (policy < SCHED_OTHER || policy > SCHED_RR) { 121 fprintf(stderr, 122 "%s: invalid scheduling class\n", 123 getprogname()); 124 exit(EXIT_FAILURE); 125 } 126 set = true; 127 break; 128 case 'P': 129 /* Priority */ 130 sp->sched_priority = atoi(optarg); 131 if (sp->sched_priority < sysconf(_SC_SCHED_PRI_MIN) || 132 sp->sched_priority > sysconf(_SC_SCHED_PRI_MAX)) { 133 fprintf(stderr, "%s: invalid priority\n", 134 getprogname()); 135 exit(EXIT_FAILURE); 136 } 137 set = true; 138 break; 139 default: 140 usage(); 141 } 142 } 143 144 /* At least PID must be specified */ 145 if (pid == 0) { 146 if (argv[optind] == NULL || lid != 0) 147 usage(); 148 pid = getpid(); 149 } else { 150 if (argv[optind] != NULL) 151 usage(); 152 } 153 154 /* Set the scheduling information for thread/process */ 155 sched_set(pid, lid, policy, set ? sp : NULL, cpuset); 156 157 /* Show information about each thread */ 158 if (pid != getpid()) { 159 kd = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, "kvm_open"); 160 if (kd == NULL) 161 err(EXIT_FAILURE, "kvm_open"); 162 lwp_list = kvm_getlwps(kd, pid, 0, sizeof(struct kinfo_lwp), &count); 163 if (lwp_list == NULL) 164 err(EXIT_FAILURE, "kvm_getlwps"); 165 for (lwp = lwp_list, i = 0; i < count; lwp++, i++) { 166 if (lid && lid != lwp->l_lid) 167 continue; 168 thread_info(pid, lwp->l_lid); 169 } 170 kvm_close(kd); 171 free(sp); 172 free(cpuset); 173 return 0; 174 } 175 176 (void)execvp(argv[optind], argv + optind); 177 err(EXIT_FAILURE, "execvp"); 178 } 179 180 static void 181 sched_set(pid_t pid, lwpid_t lid, int policy, 182 struct sched_param *sp, cpuset_t *cpuset) 183 { 184 int error; 185 186 if (sp) { 187 /* Set the scheduling parameters for the thread */ 188 error = _sched_setparam(pid, lid, policy, sp); 189 if (error < 0) 190 err(EXIT_FAILURE, "_sched_setparam"); 191 } 192 if (cpuset) { 193 /* Set the CPU-set for affinity */ 194 error = _sched_setaffinity(pid, lid, 195 sizeof(cpuset_t), cpuset); 196 if (error < 0) 197 err(EXIT_FAILURE, "_sched_setaffinity"); 198 } 199 } 200 201 static void 202 thread_info(pid_t pid, lwpid_t lid) 203 { 204 struct sched_param sp; 205 cpuset_t *cpuset; 206 char *cpus; 207 int error, policy; 208 209 cpuset = malloc(sizeof(cpuset_t)); 210 if (cpuset == NULL) 211 err(EXIT_FAILURE, "malloc"); 212 213 error = _sched_getparam(pid, lid, &policy, &sp); 214 if (error < 0) 215 err(EXIT_FAILURE, "_sched_getparam"); 216 217 error = _sched_getaffinity(pid, lid, sizeof(cpuset_t), cpuset); 218 if (error < 0) 219 err(EXIT_FAILURE, "_sched_getaffinity"); 220 221 printf(" LID: %d\n", lid); 222 printf(" Priority: %d\n", sp.sched_priority); 223 printf(" Class: %s\n", class_str[policy]); 224 225 cpus = showcpuset(cpuset); 226 printf(" Affinity (CPUs): %s\n", cpus); 227 free(cpus); 228 229 free(cpuset); 230 } 231 232 static cpuset_t * 233 makecpuset(char *str) 234 { 235 cpuset_t *cpuset; 236 char *cpustr, *s; 237 238 if (str == NULL) 239 return NULL; 240 241 cpuset = calloc(1, sizeof(cpuset_t)); 242 if (cpuset == NULL) 243 err(EXIT_FAILURE, "malloc"); 244 245 cpustr = strdup(str); 246 if (cpustr == NULL) 247 err(EXIT_FAILURE, "strdup"); 248 s = cpustr; 249 250 while (s != NULL) { 251 char *p; 252 int i; 253 254 /* Get the CPU number and validate the range */ 255 p = strsep(&s, ","); 256 if (p == NULL) { 257 free(cpuset); 258 cpuset = NULL; 259 break; 260 } 261 i = atoi(p); 262 if (i == -1) { 263 memset(cpuset, 0, sizeof(cpuset_t)); 264 break; 265 } 266 if ((unsigned int)i >= ncpu) { 267 free(cpuset); 268 cpuset = NULL; 269 break; 270 } 271 272 /* Set the bit */ 273 CPU_SET(i, cpuset); 274 } 275 276 free(cpustr); 277 return cpuset; 278 } 279 280 static char * 281 showcpuset(cpuset_t *cpuset) 282 { 283 char *buf; 284 size_t size; 285 int i; 286 287 size = 3 * ncpu; /* XXX */ 288 buf = malloc(size + 1); 289 if (buf == NULL) 290 err(EXIT_FAILURE, "malloc"); 291 memset(buf, '\0', size + 1); 292 293 for (i = 0; i < ncpu; i++) 294 if (CPU_ISSET(i, cpuset)) 295 snprintf(buf, size, "%s%d,", buf, i); 296 297 i = strlen(buf); 298 if (i != 0) { 299 buf[i - 1] = '\0'; 300 } else { 301 strncpy(buf, "<none>", size); 302 } 303 304 return buf; 305 } 306 307 static void 308 usage(void) 309 { 310 311 fprintf(stderr, "usage: %s [-A processor] [-C class] " 312 "[-P priority] [-t lid] {-p pid|command}\n", getprogname()); 313 exit(EXIT_FAILURE); 314 } 315
Indexes created Sun Sep 21 20:09:37 GMT 2025