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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <unistd.h>
31 #include <ctype.h>
32 #include <fcntl.h>
33 #include <string.h>
34 #include <memory.h>
35 #include <errno.h>
36 #include <dirent.h>
37 #include <limits.h>
38 #include <signal.h>
39 #include <sys/types.h>
40 #include <sys/uio.h>
41 #include <sys/stat.h>
42 #include <sys/resource.h>
43 #include <sys/param.h>
44 #include <sys/stack.h>
45 #include <sys/fault.h>
46 #include <sys/syscall.h>
47 #include <sys/sysmacros.h>
48
49 #include "libproc.h"
50 #include "Pcontrol.h"
51 #include "Putil.h"
52 #include "P32ton.h"
53 #include "Pisadep.h"
54
55 extern sigset_t blockable_sigs;
56
57 static void
58 Pabort_agent(struct ps_prochandle *P)
59 {
60 int sysnum = P->status.pr_lwp.pr_syscall;
61 int stop;
62
63 dprintf("agent LWP is asleep in syscall %d\n", sysnum);
64 (void) Pstop(P, 0);
65 stop = Psysexit(P, sysnum, TRUE);
66
67 if (Psetrun(P, 0, PRSABORT) == 0) {
68 while (Pwait(P, 0) == -1 && errno == EINTR)
69 continue;
70 (void) Psysexit(P, sysnum, stop);
71 dprintf("agent LWP system call aborted\n");
72 }
73 }
74
75 /*
76 * Create the /proc agent LWP for further operations.
77 */
78 int
79 Pcreate_agent(struct ps_prochandle *P)
80 {
81 int fd;
82 char pathname[PATH_MAX];
83 char *fname;
84 struct {
85 long cmd;
86 prgregset_t regs;
87 } cmd;
88
89 /*
90 * If not first reference, we already have the /proc agent LWP active.
91 */
92 if (P->agentcnt > 0) {
93 P->agentcnt++;
94 return (0);
95 }
96
97 /*
98 * The agent is not available for use as a mortician or as an
99 * obstetrician.
100 */
101 if (P->state == PS_DEAD || P->state == PS_UNDEAD ||
102 P->state == PS_IDLE) {
103 errno = ENOENT;
104 return (-1);
105 }
106
107 /*
108 * Create the special /proc agent LWP if it doesn't already exist.
109 * Give it the registers of the representative LWP.
110 */
111 (void) Pstop(P, 0);
112 Psync(P);
113 if (!(P->status.pr_lwp.pr_flags & PR_AGENT)) {
114 cmd.cmd = PCAGENT;
115 (void) memcpy(&cmd.regs, &P->status.pr_lwp.pr_reg[0],
116 sizeof (P->status.pr_lwp.pr_reg));
117 if (write(P->ctlfd, &cmd, sizeof (cmd)) != sizeof (cmd))
118 goto bad;
119 }
120
121 /* refresh the process status */
122 (void) Pstopstatus(P, PCNULL, 0);
123
124 /* open the agent LWP files */
125 (void) snprintf(pathname, sizeof (pathname), "%s/%d/lwp/agent/",
126 procfs_path, (int)P->pid);
127 fname = pathname + strlen(pathname);
128 (void) set_minfd();
129
130 /*
131 * It is difficult to know how to recover from the two errors
132 * that follow. The agent LWP exists and we need to kill it,
133 * but we can't because we need it active in order to kill it.
134 * We just hope that these failures never occur.
135 */
136 (void) strcpy(fname, "lwpstatus");
137 if ((fd = open(pathname, O_RDONLY)) < 0 ||
138 (fd = dupfd(fd, 0)) < 0)
139 goto bad;
140 P->agentstatfd = fd;
141
142 (void) strcpy(fname, "lwpctl");
143 if ((fd = open(pathname, O_WRONLY)) < 0 ||
144 (fd = dupfd(fd, 0)) < 0)
145 goto bad;
146 P->agentctlfd = fd;
147
148 /*
149 * If the agent is currently asleep in a system call, attempt
150 * to abort the system call so it's ready to serve.
151 */
152 if (P->status.pr_lwp.pr_flags & PR_ASLEEP) {
153 dprintf("Pcreate_agent: aborting agent syscall\n");
154 Pabort_agent(P);
155 }
156
157 /* get the agent LWP status */
158 P->agentcnt++;
159 if (Pstopstatus(P, PCNULL, 0) != 0) {
160 Pdestroy_agent(P);
161 return (-1);
162 }
163
164 return (0);
165
166 bad:
167 if (P->agentstatfd >= 0)
168 (void) close(P->agentstatfd);
169 if (P->agentctlfd >= 0)
170 (void) close(P->agentctlfd);
171 P->agentstatfd = -1;
172 P->agentctlfd = -1;
173 /* refresh the process status */
174 (void) Pstopstatus(P, PCNULL, 0);
175 return (-1);
176 }
177
178 /*
179 * Decrement the /proc agent agent reference count.
180 * On last reference, destroy the agent.
181 */
182 void
183 Pdestroy_agent(struct ps_prochandle *P)
184 {
185 if (P->agentcnt > 1)
186 P->agentcnt--;
187 else {
188 int flags;
189
190 Psync(P); /* Flush out any pending changes */
191
192 (void) Pstopstatus(P, PCNULL, 0);
193 flags = P->status.pr_lwp.pr_flags;
194
195 /*
196 * If the agent is currently asleep in a system call, attempt
197 * to abort the system call so we can terminate the agent.
198 */
199 if ((flags & (PR_AGENT|PR_ASLEEP)) == (PR_AGENT|PR_ASLEEP)) {
200 dprintf("Pdestroy_agent: aborting agent syscall\n");
201 Pabort_agent(P);
202 }
203
204 /*
205 * The agent itself is destroyed by forcing it to execute
206 * the _lwp_exit(2) system call. Close our agent descriptors
207 * regardless of whether this is successful.
208 */
209 (void) pr_lwp_exit(P);
210 (void) close(P->agentctlfd);
211 (void) close(P->agentstatfd);
212 P->agentctlfd = -1;
213 P->agentstatfd = -1;
214 P->agentcnt = 0;
215
216 /*
217 * Now that (hopefully) the agent has exited, refresh the
218 * status: the representative LWP is no longer the agent.
219 */
220 (void) Pstopstatus(P, PCNULL, 0);
221 }
222 }
223
224 /*
225 * Execute the syscall instruction.
226 */
227 static int
228 execute(struct ps_prochandle *P, int sysindex)
229 {
230 int ctlfd = (P->agentctlfd >= 0)? P->agentctlfd : P->ctlfd;
231 int washeld = FALSE;
232 sigset_t hold; /* mask of held signals */
233 int cursig;
234 struct {
235 long cmd;
236 siginfo_t siginfo;
237 } ctl;
238 int sentry; /* old value of stop-on-syscall-entry */
239
240 sentry = Psysentry(P, sysindex, TRUE); /* set stop-on-syscall-entry */
241
242 /*
243 * If not already blocked, block all signals now.
244 */
245 if (memcmp(&P->status.pr_lwp.pr_lwphold, &blockable_sigs,
246 sizeof (sigset_t)) != 0) {
247 hold = P->status.pr_lwp.pr_lwphold;
248 P->status.pr_lwp.pr_lwphold = blockable_sigs;
249 P->flags |= SETHOLD;
250 washeld = TRUE;
251 }
252
253 /*
254 * If there is a current signal, remember it and cancel it.
255 */
256 if ((cursig = P->status.pr_lwp.pr_cursig) != 0) {
257 ctl.cmd = PCSSIG;
258 ctl.siginfo = P->status.pr_lwp.pr_info;
259 }
260
261 if (Psetrun(P, 0, PRCSIG | PRCFAULT) == -1)
262 goto bad;
263
264 while (P->state == PS_RUN) {
265 (void) Pwait(P, 0);
266 }
267 if (P->state != PS_STOP)
268 goto bad;
269
270 if (cursig) /* restore cursig */
271 (void) write(ctlfd, &ctl, sizeof (ctl));
272 if (washeld) { /* restore the signal mask if we set it */
273 P->status.pr_lwp.pr_lwphold = hold;
274 P->flags |= SETHOLD;
275 }
276
277 (void) Psysentry(P, sysindex, sentry); /* restore sysentry stop */
278
279 if (P->status.pr_lwp.pr_why == PR_SYSENTRY &&
280 P->status.pr_lwp.pr_what == sysindex)
281 return (0);
282 bad:
283 return (-1);
284 }
285
286
287 /*
288 * Perform system call in controlled process.
289 */
290 int
291 Psyscall(struct ps_prochandle *P,
292 sysret_t *rval, /* syscall return values */
293 int sysindex, /* system call index */
294 uint_t nargs, /* number of arguments to system call */
295 argdes_t *argp) /* argument descriptor array */
296 {
297 int agent_created = FALSE;
298 pstatus_t save_pstatus;
299 argdes_t *adp; /* pointer to argument descriptor */
300 int i; /* general index value */
301 int model; /* data model */
302 int error = 0; /* syscall errno */
303 int Perr = 0; /* local error number */
304 int sexit; /* old value of stop-on-syscall-exit */
305 prgreg_t sp; /* adjusted stack pointer */
306 prgreg_t ap; /* adjusted argument pointer */
307 sigset_t unblock;
308
309 (void) sigprocmask(SIG_BLOCK, &blockable_sigs, &unblock);
310
311 rval->sys_rval1 = 0; /* initialize return values */
312 rval->sys_rval2 = 0;
313
314 if (sysindex <= 0 || sysindex > PRMAXSYS || nargs > MAXARGS)
315 goto bad1; /* programming error */
316
317 if (P->state == PS_DEAD || P->state == PS_UNDEAD || P->state == PS_IDLE)
318 goto bad1; /* dead processes can't perform system calls */
319
320 model = P->status.pr_dmodel;
321 #ifndef _LP64
322 /* We must be a 64-bit process to deal with a 64-bit process */
323 if (model == PR_MODEL_LP64)
324 goto bad9;
325 #endif
326
327 /*
328 * Create the /proc agent LWP in the process to do all the work.
329 * (It may already exist; nested create/destroy is permitted
330 * by virtue of the reference count.)
331 */
332 if (Pcreate_agent(P) != 0)
333 goto bad8;
334
335 /*
336 * Save agent's status to restore on exit.
337 */
338 agent_created = TRUE;
339 save_pstatus = P->status;
340
341 if (P->state != PS_STOP || /* check state of LWP */
342 (P->status.pr_flags & PR_ASLEEP))
343 goto bad2;
344
345 if (Pscantext(P)) /* bad text ? */
346 goto bad3;
347
348 /*
349 * Validate arguments and compute the stack frame parameters.
350 * Begin with the current stack pointer.
351 */
352 #ifdef _LP64
353 if (model == PR_MODEL_LP64) {
354 sp = P->status.pr_lwp.pr_reg[R_SP] + STACK_BIAS;
355 sp = PSTACK_ALIGN64(sp);
356 } else {
357 #endif
358 sp = (uint32_t)P->status.pr_lwp.pr_reg[R_SP];
359 sp = PSTACK_ALIGN32(sp);
360 #ifdef _LP64
361 }
362 #endif
363
364 /*
365 * For each AT_BYREF argument, compute the necessary
366 * stack space and the object's stack address.
367 */
368 for (i = 0, adp = argp; i < nargs; i++, adp++) {
369 rval->sys_rval1 = i; /* in case of error */
370 switch (adp->arg_type) {
371 default: /* programming error */
372 goto bad4;
373 case AT_BYVAL: /* simple argument */
374 break;
375 case AT_BYREF: /* must allocate space */
376 switch (adp->arg_inout) {
377 case AI_INPUT:
378 case AI_OUTPUT:
379 case AI_INOUT:
380 if (adp->arg_object == NULL)
381 goto bad5; /* programming error */
382 break;
383 default: /* programming error */
384 goto bad6;
385 }
386 /* allocate stack space for BYREF argument */
387 if (adp->arg_size == 0 || adp->arg_size > MAXARGL)
388 goto bad7; /* programming error */
389 #ifdef _LP64
390 if (model == PR_MODEL_LP64)
391 sp = PSTACK_ALIGN64(sp - adp->arg_size);
392 else
393 #endif
394 sp = PSTACK_ALIGN32(sp - adp->arg_size);
395 adp->arg_value = sp; /* stack address for object */
396 break;
397 }
398 }
399 rval->sys_rval1 = 0; /* in case of error */
400 /*
401 * Point of no return.
402 * Perform the system call entry, adjusting %sp.
403 * This moves the LWP to the stopped-on-syscall-entry state
404 * just before the arguments to the system call are fetched.
405 */
406 ap = Psyscall_setup(P, nargs, sysindex, sp);
407 P->flags |= SETREGS; /* set registers before continuing */
408 dprintf("Psyscall(): execute(sysindex = %d)\n", sysindex);
409
410 /*
411 * Execute the syscall instruction and stop on syscall entry.
412 */
413 if (execute(P, sysindex) != 0 ||
414 (!Pissyscall(P, P->status.pr_lwp.pr_reg[R_PC]) &&
415 !Pissyscall_prev(P, P->status.pr_lwp.pr_reg[R_PC], NULL)))
416 goto bad10;
417
418 dprintf("Psyscall(): copying arguments\n");
419
420 /*
421 * The LWP is stopped at syscall entry.
422 * Copy objects to stack frame for each argument.
423 */
424 for (i = 0, adp = argp; i < nargs; i++, adp++) {
425 rval->sys_rval1 = i; /* in case of error */
426 if (adp->arg_type != AT_BYVAL &&
427 adp->arg_inout != AI_OUTPUT) {
428 /* copy input byref parameter to process */
429 if (Pwrite(P, adp->arg_object, adp->arg_size,
430 (uintptr_t)adp->arg_value) != adp->arg_size)
431 goto bad17;
432 }
433 }
434 rval->sys_rval1 = 0; /* in case of error */
435 if (Psyscall_copyinargs(P, nargs, argp, ap) != 0)
436 goto bad18;
437
438 /*
439 * Complete the system call.
440 * This moves the LWP to the stopped-on-syscall-exit state.
441 */
442 dprintf("Psyscall(): set running at sysentry\n");
443
444 sexit = Psysexit(P, sysindex, TRUE); /* catch this syscall exit */
445 do {
446 if (Psetrun(P, 0, 0) == -1)
447 goto bad21;
448 while (P->state == PS_RUN)
449 (void) Pwait(P, 0);
450 } while (P->state == PS_STOP && P->status.pr_lwp.pr_why != PR_SYSEXIT);
451 (void) Psysexit(P, sysindex, sexit); /* restore original setting */
452
453 /*
454 * If the system call was _lwp_exit(), we expect that our last call
455 * to Pwait() will yield ENOENT because the LWP no longer exists.
456 */
457 if (sysindex == SYS_lwp_exit && errno == ENOENT) {
458 dprintf("Psyscall(): _lwp_exit successful\n");
459 rval->sys_rval1 = rval->sys_rval2 = 0;
460 goto out;
461 }
462
463 if (P->state != PS_STOP || P->status.pr_lwp.pr_why != PR_SYSEXIT)
464 goto bad22;
465
466 if (P->status.pr_lwp.pr_what != sysindex)
467 goto bad23;
468
469 if (!Pissyscall_prev(P, P->status.pr_lwp.pr_reg[R_PC], NULL)) {
470 dprintf("Pissyscall_prev() failed\n");
471 goto bad24;
472 }
473
474 dprintf("Psyscall(): caught at sysexit\n");
475
476 /*
477 * For each argument.
478 */
479 for (i = 0, adp = argp; i < nargs; i++, adp++) {
480 rval->sys_rval1 = i; /* in case of error */
481 if (adp->arg_type != AT_BYVAL &&
482 adp->arg_inout != AI_INPUT) {
483 /* copy output byref parameter from process */
484 if (Pread(P, adp->arg_object, adp->arg_size,
485 (uintptr_t)adp->arg_value) != adp->arg_size)
486 goto bad25;
487 }
488 }
489
490 if (Psyscall_copyoutargs(P, nargs, argp, ap) != 0)
491 goto bad26;
492
493 /*
494 * Get the return values from the syscall.
495 */
496 if (P->status.pr_lwp.pr_errno) { /* error return */
497 error = P->status.pr_lwp.pr_errno;
498 rval->sys_rval1 = -1L;
499 rval->sys_rval2 = -1L;
500 dprintf("Psyscall(%d) fails with errno %d\n",
501 sysindex, error);
502 } else { /* normal return */
503 rval->sys_rval1 = P->status.pr_lwp.pr_rval1;
504 rval->sys_rval2 = P->status.pr_lwp.pr_rval2;
505 dprintf("Psyscall(%d) returns 0x%lx 0x%lx\n", sysindex,
506 P->status.pr_lwp.pr_rval1, P->status.pr_lwp.pr_rval2);
507 }
508
509 goto out;
510
511 bad26: Perr++;
512 bad25: Perr++;
513 bad24: Perr++;
514 bad23: Perr++;
515 bad22: Perr++;
516 bad21: Perr++;
517 Perr++;
518 Perr++;
519 bad18: Perr++;
520 bad17: Perr++;
521 Perr++;
522 Perr++;
523 Perr++;
524 Perr++;
525 Perr++;
526 Perr++;
527 bad10: Perr++;
528 bad9: Perr++;
529 bad8: Perr++;
530 bad7: Perr++;
531 bad6: Perr++;
532 bad5: Perr++;
533 bad4: Perr++;
534 bad3: Perr++;
535 bad2: Perr++;
536 bad1: Perr++;
537 error = -1;
538 dprintf("Psyscall(%d) fails with local error %d\n", sysindex, Perr);
539
540 out:
541 /*
542 * Destroy the /proc agent LWP now (or just bump down the ref count).
543 */
544 if (agent_created) {
545 if (P->state != PS_UNDEAD) {
546 P->status = save_pstatus;
547 P->flags |= SETREGS;
548 Psync(P);
549 }
550 Pdestroy_agent(P);
551 }
552
553 (void) sigprocmask(SIG_SETMASK, &unblock, NULL);
554 return (error);
555 }