1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2015 Ryan Zezeski
24 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 /*
29 * pbind - bind a process to a processor (non-exclusively)
30 */
31
32 #include <sys/types.h>
33 #include <sys/procset.h>
34 #include <sys/processor.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <procfs.h>
39 #include <fcntl.h>
40 #include <errno.h>
41 #include <dirent.h>
42 #include <locale.h>
43 #include <libproc.h>
44 #include <stdarg.h>
45
46 #if !defined(TEXT_DOMAIN) /* should be defined by cc -D */
47 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
48 #endif
49
50 #define ERR_OK 0 /* exit status for success */
51 #define ERR_FAIL 1 /* exit status for errors */
52 #define ERR_USAGE 2 /* exit status for usage errors */
53
54 static char *progname;
55 static char bflag;
56 static char eflag;
57 static char qflag;
58 static char Qflag;
59 static char uflag;
60 static char Uflag;
61 static int errors;
62
63 #define MAX_PROCFS_PATH 80
64
65 /*PRINTFLIKE1*/
66 static void
warn(char * format,...)67 warn(char *format, ...)
68 {
69 int err = errno;
70 va_list alist;
71
72 (void) fprintf(stderr, "%s: ", progname);
73 va_start(alist, format);
74 (void) vfprintf(stderr, format, alist);
75 va_end(alist);
76 if (strchr(format, '\n') == NULL)
77 (void) fprintf(stderr, ": %s\n", strerror(err));
78 }
79
80 /*PRINTFLIKE1*/
81 static void
die(char * format,...)82 die(char *format, ...)
83 {
84 int err = errno;
85 va_list alist;
86
87 (void) fprintf(stderr, "%s: ", progname);
88 va_start(alist, format);
89 (void) vfprintf(stderr, format, alist);
90 va_end(alist);
91 if (strchr(format, '\n') == NULL)
92 (void) fprintf(stderr, ": %s\n", strerror(err));
93 exit(ERR_FAIL);
94 }
95
96 /*
97 * Output for query.
98 */
99 static void
query_out(id_t pid,id_t lwpid,processorid_t cpu)100 query_out(id_t pid, id_t lwpid, processorid_t cpu)
101 {
102 char *proclwp;
103 char pidstr[21];
104
105 if (lwpid == -1) {
106 (void) snprintf(pidstr, 20, "%d", (int)pid);
107 proclwp = "process";
108 } else {
109 (void) snprintf(pidstr, 20, "%d/%d", (int)pid, (int)lwpid);
110 proclwp = "lwp";
111 }
112
113 if (cpu == PBIND_NONE)
114 (void) printf(gettext("%s id %s: not bound\n"),
115 proclwp, pidstr);
116 else
117 (void) printf(gettext("%s id %s: %d\n"),
118 proclwp, pidstr, cpu);
119 }
120
121 /*
122 * Binding error.
123 */
124 static void
bind_err(processorid_t cpu,id_t pid,id_t lwpid,int err)125 bind_err(processorid_t cpu, id_t pid, id_t lwpid, int err)
126 {
127 char *msg;
128
129 switch (cpu) {
130 case PBIND_NONE:
131 msg = gettext("unbind");
132 break;
133 case PBIND_QUERY:
134 msg = gettext("query");
135 break;
136 default:
137 msg = gettext("bind");
138 break;
139 }
140 if (lwpid == -1)
141 warn(gettext("cannot %s pid %d: %s\n"), msg,
142 (int)pid, strerror(err));
143 else
144 warn(gettext("cannot %s lwpid %d/%d: %s\n"), msg,
145 (int)pid, (int)lwpid, strerror(err));
146 }
147
148 /*
149 * Output for bind.
150 */
151 static void
bind_out(id_t pid,id_t lwpid,processorid_t old,processorid_t new)152 bind_out(id_t pid, id_t lwpid, processorid_t old, processorid_t new)
153 {
154 char *proclwp;
155 char pidstr[21];
156
157 if (lwpid == -1) {
158 (void) snprintf(pidstr, 20, "%d", (int)pid);
159 proclwp = "process";
160 } else {
161 (void) snprintf(pidstr, 20, "%d/%d", (int)pid, (int)lwpid);
162 proclwp = "lwp";
163 }
164
165 if (old == PBIND_NONE) {
166 if (new == PBIND_NONE)
167 (void) printf(gettext("%s id %s: was not bound, "
168 "now not bound\n"), proclwp, pidstr);
169 else
170 (void) printf(gettext("%s id %s: was not bound, "
171 "now %d\n"), proclwp, pidstr, new);
172 } else {
173 if (new == PBIND_NONE)
174 (void) printf(gettext("%s id %s: was %d, "
175 "now not bound\n"), proclwp, pidstr, old);
176 else
177 (void) printf(gettext("%s id %s: was %d, "
178 "now %d\n"), proclwp, pidstr, old, new);
179 }
180 }
181
182 static struct ps_prochandle *
grab_proc(id_t pid)183 grab_proc(id_t pid)
184 {
185 int ret;
186 struct ps_prochandle *Pr;
187
188 if ((Pr = Pgrab(pid, 0, &ret)) == NULL) {
189 warn(gettext("cannot control process %d: %s\n"),
190 (int)pid, Pgrab_error(ret));
191 errors = ERR_FAIL;
192 return (NULL);
193 }
194
195 /*
196 * Set run-on-last-close flag so the controlled process
197 * runs even if we die on a signal, and create an agent LWP.
198 */
199 if (Psetflags(Pr, PR_RLC) != 0 || Pcreate_agent(Pr) != 0) {
200 warn(gettext("cannot control process %d\n"), (int)pid);
201 errors = ERR_FAIL;
202 Prelease(Pr, 0);
203 return (NULL);
204 }
205 return (Pr);
206 }
207
208 static void
rele_proc(struct ps_prochandle * Pr)209 rele_proc(struct ps_prochandle *Pr)
210 {
211 if (Pr == NULL)
212 return;
213 Pdestroy_agent(Pr);
214 Prelease(Pr, 0);
215 }
216
217 static void
bind_lwp(struct ps_prochandle * Pr,id_t pid,id_t lwpid,processorid_t cpu)218 bind_lwp(struct ps_prochandle *Pr, id_t pid, id_t lwpid, processorid_t cpu)
219 {
220 processorid_t old_cpu;
221
222 if (pr_processor_bind(Pr, P_LWPID, lwpid, cpu, &old_cpu) < 0) {
223 bind_err(cpu, pid, lwpid, errno);
224 errors = ERR_FAIL;
225 } else {
226 if (qflag)
227 query_out(pid, lwpid, old_cpu);
228 else
229 bind_out(pid, lwpid, old_cpu, cpu);
230 }
231 }
232
233 /*
234 * Query, set, or clear bindings for the range of LWPs in the given process.
235 */
236 static int
do_lwps(id_t pid,const char * range,processorid_t cpu)237 do_lwps(id_t pid, const char *range, processorid_t cpu)
238 {
239 char procfile[MAX_PROCFS_PATH];
240 struct ps_prochandle *Pr;
241 struct prheader header;
242 processorid_t binding;
243 struct lwpsinfo *lwp;
244 char *lpsinfo, *ptr;
245 int nent, size;
246 int i, fd, found;
247
248 /*
249 * Report bindings for LWPs in process 'pid'.
250 */
251 (void) snprintf(procfile, MAX_PROCFS_PATH,
252 "/proc/%d/lpsinfo", (int)pid);
253 if ((fd = open(procfile, O_RDONLY)) < 0) {
254 if (errno == ENOENT)
255 errno = ESRCH;
256 bind_err(cpu, pid, -1, errno);
257 return (ERR_FAIL);
258 }
259 if (pread(fd, &header, sizeof (header), 0) != sizeof (header)) {
260 (void) close(fd);
261 bind_err(cpu, pid, -1, errno);
262 return (ERR_FAIL);
263 }
264 nent = header.pr_nent;
265 size = header.pr_entsize * nent;
266 ptr = lpsinfo = malloc(size);
267 if (lpsinfo == NULL) {
268 bind_err(cpu, pid, -1, errno);
269 return (ERR_FAIL);
270 }
271 if (pread(fd, lpsinfo, size, sizeof (header)) != size) {
272 bind_err(cpu, pid, -1, errno);
273 free(lpsinfo);
274 (void) close(fd);
275 return (ERR_FAIL);
276 }
277
278 if ((bflag || uflag) && (Pr = grab_proc(pid)) == NULL) {
279 free(lpsinfo);
280 (void) close(fd);
281 return (ERR_FAIL);
282 }
283 found = 0;
284 for (i = 0; i < nent; i++, ptr += header.pr_entsize) {
285 /*LINTED ALIGNMENT*/
286 lwp = (lwpsinfo_t *)ptr;
287 binding = lwp->pr_bindpro;
288 if (!proc_lwp_in_set(range, lwp->pr_lwpid))
289 continue;
290 found++;
291 if (bflag || uflag)
292 bind_lwp(Pr, pid, lwp->pr_lwpid, cpu);
293 else if (binding != PBIND_NONE)
294 query_out(pid, lwp->pr_lwpid, binding);
295 }
296 if (bflag || uflag)
297 rele_proc(Pr);
298 free(lpsinfo);
299 (void) close(fd);
300 if (found == 0) {
301 warn(gettext("cannot %s lwpid %d/%s: "
302 "No matching LWPs found\n"),
303 bflag ? "bind" : "query", pid, range);
304 return (ERR_FAIL);
305 }
306 return (ERR_OK);
307 }
308
309 /*ARGSUSED*/
310 static int
query_all_proc(psinfo_t * psinfo,lwpsinfo_t * lwpsinfo,void * arg)311 query_all_proc(psinfo_t *psinfo, lwpsinfo_t *lwpsinfo, void *arg)
312 {
313 id_t pid = psinfo->pr_pid;
314 processorid_t binding;
315
316 if (processor_bind(P_PID, pid, PBIND_QUERY, &binding) < 0) {
317 /*
318 * Ignore search errors. The process may have exited
319 * since we read the directory.
320 */
321 if (errno == ESRCH)
322 return (0);
323 bind_err(PBIND_QUERY, pid, -1, errno);
324 errors = ERR_FAIL;
325 return (0);
326 }
327 if (binding != PBIND_NONE)
328 query_out(pid, -1, binding);
329 return (0);
330 }
331
332 static int
query_all_lwp(psinfo_t * psinfo,lwpsinfo_t * lwpsinfo,void * arg)333 query_all_lwp(psinfo_t *psinfo, lwpsinfo_t *lwpsinfo, void *arg)
334 {
335 id_t pid = psinfo->pr_pid;
336 id_t lwpid = lwpsinfo->pr_lwpid;
337 processorid_t *cpuid = arg;
338 processorid_t binding = lwpsinfo->pr_bindpro;
339
340 if (psinfo->pr_nlwp == 1)
341 lwpid = -1; /* report process bindings if only 1 lwp */
342 if ((cpuid != NULL && *cpuid == binding) ||
343 (cpuid == NULL && binding != PBIND_NONE))
344 query_out(pid, lwpid, binding);
345 return (0);
346 }
347
348 /*
349 * Execute the cmd with args while bound to cpu. Does not return:
350 * either executes cmd successfully or dies trying.
351 */
352 static void
exec_cmd(processorid_t cpu,char * cmd,char ** args)353 exec_cmd(processorid_t cpu, char *cmd, char **args)
354 {
355 if (processor_bind(P_PID, P_MYID, cpu, NULL) == -1) {
356 bind_err(cpu, getpid(), -1, errno);
357 exit(ERR_FAIL);
358 }
359
360 if (execvp(cmd, args) == -1)
361 die(gettext("failed to exec %s\n"), cmd);
362 }
363
364 /*
365 * Attempt to parse str as a CPU identifier. Return the identifier or
366 * die.
367 */
368 static processorid_t
parse_cpu(char * str)369 parse_cpu(char *str)
370 {
371 processorid_t cpu;
372 char *endstr;
373
374 cpu = strtol(str, &endstr, 10);
375 if (endstr != NULL && *endstr != '\0' || cpu < 0)
376 die(gettext("invalid processor ID %s\n"), optarg);
377
378 return (cpu);
379 }
380
381 static int
usage(void)382 usage(void)
383 {
384 (void) fprintf(stderr,
385 gettext("usage: \n\t%1$s -b processor_id pid[/lwpids] ...\n"
386 "\t%1$s -e processor_id cmd [args...]\n"
387 "\t%1$s -U [processor_id] ...\n"
388 "\t%1$s -Q [processor_id] ...\n"
389 "\t%1$s -u pid[/lwpids] ...\n"
390 "\t%1$s [-q] [pid[/lwpids] ...]\n"),
391 progname);
392 return (ERR_USAGE);
393 }
394
395 int
main(int argc,char * argv[])396 main(int argc, char *argv[])
397 {
398 int c;
399 int ret;
400 id_t pid;
401 processorid_t cpu, old_cpu;
402 char *endstr;
403
404 progname = argv[0]; /* put actual command name in messages */
405
406 (void) setlocale(LC_ALL, ""); /* setup localization */
407 (void) textdomain(TEXT_DOMAIN);
408
409 while ((c = getopt(argc, argv, "b:e:qQuU")) != EOF) {
410 switch (c) {
411
412 case 'b':
413 bflag = 1;
414 cpu = parse_cpu(optarg);
415 break;
416
417 case 'e':
418 eflag = 1;
419 cpu = parse_cpu(optarg);
420 break;
421
422 case 'q':
423 qflag = 1;
424 cpu = PBIND_QUERY;
425 break;
426
427 case 'Q':
428 Qflag = 1;
429 cpu = PBIND_QUERY;
430 break;
431
432 case 'u':
433 uflag = 1;
434 cpu = PBIND_NONE;
435 break;
436
437 case 'U':
438 Uflag = 1;
439 break;
440
441 default:
442 return (usage());
443 }
444 }
445
446
447 /*
448 * Make sure that at most one of the options b, e, q, Q, u, or
449 * U was specified.
450 */
451 c = bflag + eflag + qflag + Qflag + uflag + Uflag;
452 if (c < 1) { /* nothing specified */
453 qflag = 1; /* default to query */
454 cpu = PBIND_QUERY;
455 } else if (c > 1) {
456 warn(gettext("options -b, -e, -q, -Q, -u and -U "
457 "are mutually exclusive\n"));
458 return (usage());
459 }
460
461 errors = 0;
462 argc -= optind;
463 argv += optind;
464
465 /*
466 * Handle query of all processes.
467 */
468 if (argc == 0) {
469 if (bflag || uflag) {
470 warn(gettext("must specify at least one pid\n"));
471 return (usage());
472 }
473 if (eflag) {
474 warn(gettext("must specify command\n"));
475 return (usage());
476 }
477 if (Uflag) {
478 if (processor_bind(P_ALL, 0, PBIND_NONE, &old_cpu) != 0)
479 die(gettext("failed to unbind some LWPs"));
480 }
481 if (Qflag) {
482 (void) proc_walk(query_all_lwp, NULL, PR_WALK_LWP);
483 return (errors);
484 } else {
485 (void) proc_walk(query_all_proc, NULL, PR_WALK_PROC);
486 return (errors);
487 }
488 }
489
490 if (eflag)
491 exec_cmd(cpu, argv[0], argv);
492
493 if (Qflag || Uflag) {
494 /*
495 * Go through listed processor IDs.
496 */
497 for (; argc > 0; argv++, argc--) {
498 errno = 0;
499 cpu = (id_t)strtol(*argv, &endstr, 10);
500 if (errno != 0 || (endstr != NULL && *endstr != '\0') ||
501 p_online(cpu, P_STATUS) == -1) {
502 warn(gettext("invalid processor ID\n"));
503 continue;
504 }
505 if (Qflag) {
506 (void) proc_walk(query_all_lwp,
507 &cpu, PR_WALK_LWP);
508 continue;
509 }
510 if (Uflag) {
511 if (processor_bind(P_CPUID, cpu,
512 PBIND_NONE, &old_cpu) != 0) {
513 warn(gettext("failed to unbind from "
514 "processor %d"), (int)cpu);
515 errors = ERR_FAIL;
516 }
517 continue;
518 }
519 }
520 return (errors);
521 }
522
523 /*
524 * Go through listed process[/lwp_ranges].
525 */
526 for (; argc > 0; argv++, argc--) {
527 errno = 0;
528 pid = (id_t)strtol(*argv, &endstr, 10);
529 if (errno != 0 ||
530 (endstr != NULL && *endstr != '\0' && *endstr != '/')) {
531 warn(gettext("invalid process ID: %s\n"), *argv);
532 continue;
533 }
534 if (endstr != NULL && *endstr == '/') {
535 /*
536 * Handle lwp range case
537 */
538 const char *lwps = (const char *)(++endstr);
539 if (*lwps == '\0' ||
540 proc_lwp_range_valid(lwps) != 0) {
541 warn(gettext("invalid lwp range "
542 "for pid %d\n"), (int)pid);
543 errors = ERR_FAIL;
544 continue;
545 }
546 if (!qflag)
547 (void) proc_initstdio();
548 ret = do_lwps(pid, lwps, qflag ? PBIND_QUERY : cpu);
549 if (!qflag)
550 (void) proc_finistdio();
551 if (ret != ERR_OK)
552 errors = ret;
553 } else {
554 /*
555 * Handle whole process case.
556 */
557 if (processor_bind(P_PID, pid, cpu, &old_cpu) < 0) {
558 bind_err(cpu, pid, -1, errno);
559 errors = ERR_FAIL;
560 continue;
561 }
562 if (qflag)
563 query_out(pid, -1, old_cpu);
564 else
565 bind_out(pid, -1, old_cpu, cpu);
566 }
567 }
568 return (errors);
569 }
570