?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update copyright year range in header of all files managed by GDB
[binutils-gdb.git] / sim / ppc / emul_unix.c
blob1d8b7814ffc62d0cdada4e316cacb57872fd4282
1 /* This file is part of the program psim.
2
3 Copyright (C) 1996-1998, Andrew Cagney <cagney@highland.com.au>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <http://www.gnu.org/licenses/>.
17
18 */
19
20
21 #ifndef _EMUL_UNIX_C_
22 #define _EMUL_UNIX_C_
23
24
25 /* Note: this module is called via a table. There is no benefit in
26 making it inline */
27
28 #include "defs.h"
29
30 #include <string.h>
31 #ifdef HAVE_SYS_TYPES_H
32 #include <sys/types.h>
33 #endif
34
35 #ifdef HAVE_SYS_TYPES_H
36 #include <sys/stat.h>
37 #else
38 #undef HAVE_STAT
39 #undef HAVE_LSTAT
40 #undef HAVE_FSTAT
41 #endif
42
43 #include <stdio.h>
44 #include <signal.h>
45 #include <errno.h>
46
47 #ifdef HAVE_FCNTL_H
48 #include <fcntl.h>
49 #endif
50
51 #ifdef HAVE_SYS_PARAM_H
52 #include <sys/param.h>
53 #endif
54
55 #include <sys/time.h>
56
57 #ifndef HAVE_TERMIOS_STRUCTURE
58 #undef HAVE_SYS_TERMIOS_H
59 #undef HAVE_TCGETATTR
60 #else
61 #ifndef HAVE_SYS_TERMIOS_H
62 #undef HAVE_TERMIOS_STRUCTURE
63 #endif
64 #endif
65
66 #ifdef HAVE_TERMIOS_STRUCTURE
67 #include <sys/termios.h>
68
69 /* If we have TERMIOS, use that for the termio structure, since some systems
70 don't like including both sys/termios.h and sys/termio.h at the same
71 time. */
72 #undef HAVE_TERMIO_STRUCTURE
73 #undef TCGETA
74 #undef termio
75 #define termio termios
76 #endif
77
78 #ifndef HAVE_TERMIO_STRUCTURE
79 #undef HAVE_SYS_TERMIO_H
80 #else
81 #ifndef HAVE_SYS_TERMIO_H
82 #undef HAVE_TERMIO_STRUCTURE
83 #endif
84 #endif
85
86 #ifdef HAVE_TERMIO_STRUCTURE
87 #include <sys/termio.h>
88 #endif
89
90 #ifdef HAVE_GETRUSAGE
91 #ifndef HAVE_SYS_RESOURCE_H
92 #undef HAVE_GETRUSAGE
93 #endif
94 #endif
95
96 #ifdef HAVE_GETRUSAGE
97 #include <sys/resource.h>
98 int getrusage();
99 #endif
100
101 #if HAVE_DIRENT_H
102 # include <dirent.h>
103 # define NAMLEN(dirent) strlen((dirent)->d_name)
104 #else
105 # define dirent direct
106 # define NAMLEN(dirent) (dirent)->d_namlen
107 # if HAVE_SYS_NDIR_H
108 # include <sys/ndir.h>
109 # endif
110 # if HAVE_SYS_DIR_H
111 # include <sys/dir.h>
112 # endif
113 # if HAVE_NDIR_H
114 # include <ndir.h>
115 # endif
116 #endif
117
118 #ifdef HAVE_UNISTD_H
119 #undef MAXPATHLEN /* sys/param.h might define this also */
120 #include <unistd.h>
121 #endif
122
123 #include <stdlib.h>
124 #include <time.h>
125
126 #include "emul_generic.h"
127 #include "emul_unix.h"
128
129 #ifndef STATIC_INLINE_EMUL_UNIX
130 #define STATIC_INLINE_EMUL_UNIX STATIC_INLINE
131 #endif
132
133 #ifndef PATH_MAX
134 #define PATH_MAX 1024
135 #endif
136
137 #ifndef EINVAL
138 #define EINVAL -1
139 #endif
140
141 /* UNIX's idea of what is needed to implement emulations */
142
143 struct _os_emul_data {
144 device *vm;
145 emul_syscall *syscalls;
146 };
147
148 \f
149 /* Emulation of simple UNIX system calls that are common on all systems. */
150
151 /* Structures that are common agmonst the UNIX varients */
152 struct unix_timeval {
153 int32_t tv_sec; /* seconds */
154 int32_t tv_usec; /* microseconds */
155 };
156
157 struct unix_timezone {
158 int32_t tz_minuteswest; /* minutes west of Greenwich */
159 int32_t tz_dsttime; /* type of dst correction */
160 };
161
162 #define UNIX_RUSAGE_SELF 0
163 #define UNIX_RUSAGE_CHILDREN (-1)
164 #define UNIX_RUSAGE_BOTH (-2) /* sys_wait4() uses this */
165
166 struct unix_rusage {
167 struct unix_timeval ru_utime; /* user time used */
168 struct unix_timeval ru_stime; /* system time used */
169 int32_t ru_maxrss; /* maximum resident set size */
170 int32_t ru_ixrss; /* integral shared memory size */
171 int32_t ru_idrss; /* integral unshared data size */
172 int32_t ru_isrss; /* integral unshared stack size */
173 int32_t ru_minflt; /* any page faults not requiring I/O */
174 int32_t ru_majflt; /* any page faults requiring I/O */
175 int32_t ru_nswap; /* swaps */
176 int32_t ru_inblock; /* block input operations */
177 int32_t ru_oublock; /* block output operations */
178 int32_t ru_msgsnd; /* messages sent */
179 int32_t ru_msgrcv; /* messages received */
180 int32_t ru_nsignals; /* signals received */
181 int32_t ru_nvcsw; /* voluntary context switches */
182 int32_t ru_nivcsw; /* involuntary " */
183 };
184
185
186 /* File descriptors 0, 1, and 2 should not be closed. fd_closed[]
187 tracks whether these descriptors have been closed in do_close()
188 below. */
189
190 static int fd_closed[3];
191
192 /* Check for some occurrences of bad file descriptors. We only check
193 whether fd 0, 1, or 2 are "closed". By "closed" we mean that these
194 descriptors aren't actually closed, but are considered to be closed
195 by this layer.
196
197 Other checks are performed by the underlying OS call. */
198
199 static int
200 fdbad (int fd)
201 {
202 if (fd >=0 && fd <= 2 && fd_closed[fd])
203 {
204 errno = EBADF;
205 return -1;
206 }
207 return 0;
208 }
209
210 static void
211 do_unix_exit(os_emul_data *emul,
212 unsigned call,
213 const int arg0,
214 cpu *processor,
215 unsigned_word cia)
216 {
217 int status = (int)cpu_registers(processor)->gpr[arg0];
218 if (WITH_TRACE && ppc_trace[trace_os_emul])
219 printf_filtered ("%d)\n", status);
220
221 cpu_halt(processor, cia, was_exited, status);
222 }
223
224
225 static void
226 do_unix_read(os_emul_data *emul,
227 unsigned call,
228 const int arg0,
229 cpu *processor,
230 unsigned_word cia)
231 {
232 void *scratch_buffer;
233 int d = (int)cpu_registers(processor)->gpr[arg0];
234 unsigned_word buf = cpu_registers(processor)->gpr[arg0+1];
235 int nbytes = cpu_registers(processor)->gpr[arg0+2];
236 int status;
237
238 if (WITH_TRACE && ppc_trace[trace_os_emul])
239 printf_filtered ("%d, 0x%lx, %d", d, (long)buf, nbytes);
240
241 /* get a tempoary bufer */
242 scratch_buffer = zalloc(nbytes);
243
244 /* check if buffer exists by reading it */
245 emul_read_buffer(scratch_buffer, buf, nbytes, processor, cia);
246
247 status = fdbad (d);
248 /* read */
249 if (status == 0)
250 status = read (d, scratch_buffer, nbytes);
251
252 emul_write_status(processor, status, errno);
253 if (status > 0)
254 emul_write_buffer(scratch_buffer, buf, status, processor, cia);
255
256 free(scratch_buffer);
257 }
258
259
260 static void
261 do_unix_write(os_emul_data *emul,
262 unsigned call,
263 const int arg0,
264 cpu *processor,
265 unsigned_word cia)
266 {
267 void *scratch_buffer = NULL;
268 int d = (int)cpu_registers(processor)->gpr[arg0];
269 unsigned_word buf = cpu_registers(processor)->gpr[arg0+1];
270 int nbytes = cpu_registers(processor)->gpr[arg0+2];
271 int status;
272
273 if (WITH_TRACE && ppc_trace[trace_os_emul])
274 printf_filtered ("%d, 0x%lx, %d", d, (long)buf, nbytes);
275
276 /* get a tempoary bufer */
277 scratch_buffer = zalloc(nbytes); /* FIXME - nbytes == 0 */
278
279 /* copy in */
280 emul_read_buffer(scratch_buffer, buf, nbytes,
281 processor, cia);
282
283 status = fdbad (d);
284 /* write */
285 if (status == 0)
286 status = write(d, scratch_buffer, nbytes);
287 emul_write_status(processor, status, errno);
288 free(scratch_buffer);
289
290 flush_stdoutput();
291 }
292
293
294 static void
295 do_unix_open(os_emul_data *emul,
296 unsigned call,
297 const int arg0,
298 cpu *processor,
299 unsigned_word cia)
300 {
301 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
302 char path_buf[PATH_MAX];
303 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
304 int flags = (int)cpu_registers(processor)->gpr[arg0+1];
305 int mode = (int)cpu_registers(processor)->gpr[arg0+2];
306 int status;
307
308 if (WITH_TRACE && ppc_trace[trace_os_emul])
309 printf_filtered ("0x%lx [%s], 0x%x, 0x%x", (long)path_addr, path, flags, mode);
310
311 status = open(path, flags, mode);
312 emul_write_status(processor, status, errno);
313 }
314
315
316 static void
317 do_unix_close(os_emul_data *emul,
318 unsigned call,
319 const int arg0,
320 cpu *processor,
321 unsigned_word cia)
322 {
323 int d = (int)cpu_registers(processor)->gpr[arg0];
324 int status;
325
326 if (WITH_TRACE && ppc_trace[trace_os_emul])
327 printf_filtered ("%d", d);
328
329 status = fdbad (d);
330 if (status == 0)
331 {
332 /* Do not close stdin, stdout, or stderr. GDB may still need access to
333 these descriptors. */
334 if (d == 0 || d == 1 || d == 2)
335 {
336 fd_closed[d] = 1;
337 status = 0;
338 }
339 else
340 status = close(d);
341 }
342
343 emul_write_status(processor, status, errno);
344 }
345
346
347 static void
348 do_unix_break(os_emul_data *emul,
349 unsigned call,
350 const int arg0,
351 cpu *processor,
352 unsigned_word cia)
353 {
354 /* just pass this onto the `vm' device */
355 unsigned_word new_break = cpu_registers(processor)->gpr[arg0];
356 int status;
357
358 if (WITH_TRACE && ppc_trace[trace_os_emul])
359 printf_filtered ("0x%lx", (long)cpu_registers(processor)->gpr[arg0]);
360
361 status = device_ioctl(emul->vm,
362 processor,
363 cia,
364 device_ioctl_break,
365 new_break); /*ioctl-data*/
366
367 emul_write_status(processor, 0, status);
368 }
369
370 #ifndef HAVE_ACCESS
371 #define do_unix_access 0
372 #else
373 static void
374 do_unix_access(os_emul_data *emul,
375 unsigned call,
376 const int arg0,
377 cpu *processor,
378 unsigned_word cia)
379 {
380 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
381 char path_buf[PATH_MAX];
382 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
383 int mode = (int)cpu_registers(processor)->gpr[arg0+1];
384 int status;
385
386 if (WITH_TRACE && ppc_trace[trace_os_emul])
387 printf_filtered ("0x%lx [%s], 0x%x [0%o]", (long)path_addr, path, mode, mode);
388
389 status = access(path, mode);
390 emul_write_status(processor, status, errno);
391 }
392 #endif
393
394 #ifndef HAVE_GETPID
395 #define do_unix_getpid 0
396 #else
397 static void
398 do_unix_getpid(os_emul_data *emul,
399 unsigned call,
400 const int arg0,
401 cpu *processor,
402 unsigned_word cia)
403 {
404 pid_t status = getpid();
405 emul_write_status(processor, (int)status, errno);
406 }
407 #endif
408
409 #ifndef HAVE_GETPPID
410 #define do_unix_getppid 0
411 #else
412 static void
413 do_unix_getppid(os_emul_data *emul,
414 unsigned call,
415 const int arg0,
416 cpu *processor,
417 unsigned_word cia)
418 {
419 pid_t status = getppid();
420 emul_write_status(processor, (int)status, errno);
421 }
422 #endif
423
424 #if !defined(HAVE_GETPID) || !defined(HAVE_GETPPID)
425 #define do_unix_getpid2 0
426 #else
427 static void
428 do_unix_getpid2(os_emul_data *emul,
429 unsigned call,
430 const int arg0,
431 cpu *processor,
432 unsigned_word cia)
433 {
434 int pid = (int)getpid();
435 int ppid = (int)getppid();
436 emul_write2_status(processor, pid, ppid, errno);
437 }
438 #endif
439
440 #if !defined(HAVE_GETUID) || !defined(HAVE_GETEUID)
441 #define do_unix_getuid2 0
442 #else
443 static void
444 do_unix_getuid2(os_emul_data *emul,
445 unsigned call,
446 const int arg0,
447 cpu *processor,
448 unsigned_word cia)
449 {
450 uid_t uid = getuid();
451 uid_t euid = geteuid();
452 emul_write2_status(processor, (int)uid, (int)euid, errno);
453 }
454 #endif
455
456 #ifndef HAVE_GETUID
457 #define do_unix_getuid 0
458 #else
459 static void
460 do_unix_getuid(os_emul_data *emul,
461 unsigned call,
462 const int arg0,
463 cpu *processor,
464 unsigned_word cia)
465 {
466 uid_t status = getuid();
467 emul_write_status(processor, (int)status, errno);
468 }
469 #endif
470
471 #ifndef HAVE_GETEUID
472 #define do_unix_geteuid 0
473 #else
474 static void
475 do_unix_geteuid(os_emul_data *emul,
476 unsigned call,
477 const int arg0,
478 cpu *processor,
479 unsigned_word cia)
480 {
481 uid_t status = geteuid();
482 emul_write_status(processor, (int)status, errno);
483 }
484 #endif
485
486 #if 0
487 #ifndef HAVE_KILL
488 #define do_unix_kill 0
489 #else
490 static void
491 do_unix_kill(os_emul_data *emul,
492 unsigned call,
493 const int arg0,
494 cpu *processor,
495 unsigned_word cia)
496 {
497 pid_t pid = cpu_registers(processor)->gpr[arg0];
498 int sig = cpu_registers(processor)->gpr[arg0+1];
499
500 if (WITH_TRACE && ppc_trace[trace_os_emul])
501 printf_filtered ("%d, %d", (int)pid, sig);
502
503 printf_filtered("SYS_kill at 0x%lx - more to this than just being killed\n",
504 (long)cia);
505
506 cpu_halt(processor, cia, was_signalled, sig);
507 }
508 #endif
509 #endif
510
511 #ifndef HAVE_DUP
512 #define do_unix_dup 0
513 #else
514 static void
515 do_unix_dup(os_emul_data *emul,
516 unsigned call,
517 const int arg0,
518 cpu *processor,
519 unsigned_word cia)
520 {
521 int oldd = cpu_registers(processor)->gpr[arg0];
522 int status = (fdbad (oldd) < 0) ? -1 : dup(oldd);
523 int err = errno;
524
525 if (WITH_TRACE && ppc_trace[trace_os_emul])
526 printf_filtered ("%d", oldd);
527
528 emul_write_status(processor, status, err);
529 }
530 #endif
531
532 #ifndef HAVE_DUP2
533 #define do_unix_dup2 0
534 #else
535 static void
536 do_unix_dup2(os_emul_data *emul,
537 unsigned call,
538 const int arg0,
539 cpu *processor,
540 unsigned_word cia)
541 {
542 int oldd = cpu_registers(processor)->gpr[arg0];
543 int newd = cpu_registers(processor)->gpr[arg0+1];
544 int status = (fdbad (oldd) < 0) ? -1 : dup2(oldd, newd);
545 int err = errno;
546
547 if (WITH_TRACE && ppc_trace[trace_os_emul])
548 printf_filtered ("%d, %d", oldd, newd);
549
550 emul_write_status(processor, status, err);
551 }
552 #endif
553
554 #ifndef HAVE_LSEEK
555 #define do_unix_lseek 0
556 #else
557 static void
558 do_unix_lseek(os_emul_data *emul,
559 unsigned call,
560 const int arg0,
561 cpu *processor,
562 unsigned_word cia)
563 {
564 int fildes = (int)cpu_registers(processor)->gpr[arg0];
565 off_t offset = (off_t)cpu_registers(processor)->gpr[arg0+1];
566 int whence = (int)cpu_registers(processor)->gpr[arg0+2];
567 off_t status;
568
569 if (WITH_TRACE && ppc_trace[trace_os_emul])
570 printf_filtered ("%d %ld %d", fildes, (long)offset, whence);
571
572 status = fdbad (fildes);
573 if (status == 0)
574 status = lseek(fildes, offset, whence);
575 emul_write_status(processor, (int)status, errno);
576 }
577 #endif
578
579
580 #if !defined(HAVE_GETGID) || !defined(HAVE_GETEGID)
581 #define do_unix_getgid2 0
582 #else
583 static void
584 do_unix_getgid2(os_emul_data *emul,
585 unsigned call,
586 const int arg0,
587 cpu *processor,
588 unsigned_word cia)
589 {
590 gid_t gid = getgid();
591 gid_t egid = getegid();
592 emul_write2_status(processor, (int)gid, (int)egid, errno);
593 }
594 #endif
595
596 #ifndef HAVE_GETGID
597 #define do_unix_getgid 0
598 #else
599 static void
600 do_unix_getgid(os_emul_data *emul,
601 unsigned call,
602 const int arg0,
603 cpu *processor,
604 unsigned_word cia)
605 {
606 gid_t status = getgid();
607 emul_write_status(processor, (int)status, errno);
608 }
609 #endif
610
611 #ifndef HAVE_GETEGID
612 #define do_unix_getegid 0
613 #else
614 static void
615 do_unix_getegid(os_emul_data *emul,
616 unsigned call,
617 const int arg0,
618 cpu *processor,
619 unsigned_word cia)
620 {
621 gid_t status = getegid();
622 emul_write_status(processor, (int)status, errno);
623 }
624 #endif
625
626 #ifndef HAVE_UMASK
627 #define do_unix_umask 0
628 #else
629 static void
630 do_unix_umask(os_emul_data *emul,
631 unsigned call,
632 const int arg0,
633 cpu *processor,
634 unsigned_word cia)
635 {
636 mode_t mask = (mode_t)cpu_registers(processor)->gpr[arg0];
637 int status = umask(mask);
638
639 if (WITH_TRACE && ppc_trace[trace_os_emul])
640 printf_filtered ("0%o", (unsigned int)mask);
641
642 emul_write_status(processor, status, errno);
643 }
644 #endif
645
646 #ifndef HAVE_CHDIR
647 #define do_unix_chdir 0
648 #else
649 static void
650 do_unix_chdir(os_emul_data *emul,
651 unsigned call,
652 const int arg0,
653 cpu *processor,
654 unsigned_word cia)
655 {
656 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
657 char path_buf[PATH_MAX];
658 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
659 int status;
660
661 if (WITH_TRACE && ppc_trace[trace_os_emul])
662 printf_filtered ("0x%lx [%s]", (long)path_addr, path);
663
664 status = chdir(path);
665 emul_write_status(processor, status, errno);
666 }
667 #endif
668
669 #ifndef HAVE_LINK
670 #define do_unix_link 0
671 #else
672 static void
673 do_unix_link(os_emul_data *emul,
674 unsigned call,
675 const int arg0,
676 cpu *processor,
677 unsigned_word cia)
678 {
679 unsigned_word path1_addr = cpu_registers(processor)->gpr[arg0];
680 char path1_buf[PATH_MAX];
681 char *path1 = emul_read_string(path1_buf, path1_addr, PATH_MAX, processor, cia);
682 unsigned_word path2_addr = cpu_registers(processor)->gpr[arg0+1];
683 char path2_buf[PATH_MAX];
684 char *path2 = emul_read_string(path2_buf, path2_addr, PATH_MAX, processor, cia);
685 int status;
686
687 if (WITH_TRACE && ppc_trace[trace_os_emul])
688 printf_filtered ("0x%lx [%s], 0x%lx [%s]", (long)path1_addr, path1, (long)path2_addr, path2);
689
690 status = link(path1, path2);
691 emul_write_status(processor, status, errno);
692 }
693 #endif
694
695 #ifndef HAVE_SYMLINK
696 #define do_unix_symlink 0
697 #else
698 static void
699 do_unix_symlink(os_emul_data *emul,
700 unsigned call,
701 const int arg0,
702 cpu *processor,
703 unsigned_word cia)
704 {
705 unsigned_word path1_addr = cpu_registers(processor)->gpr[arg0];
706 char path1_buf[PATH_MAX];
707 char *path1 = emul_read_string(path1_buf, path1_addr, PATH_MAX, processor, cia);
708 unsigned_word path2_addr = cpu_registers(processor)->gpr[arg0+1];
709 char path2_buf[PATH_MAX];
710 char *path2 = emul_read_string(path2_buf, path2_addr, PATH_MAX, processor, cia);
711 int status;
712
713 if (WITH_TRACE && ppc_trace[trace_os_emul])
714 printf_filtered ("0x%lx [%s], 0x%lx [%s]", (long)path1_addr, path1, (long)path2_addr, path2);
715
716 status = symlink(path1, path2);
717 emul_write_status(processor, status, errno);
718 }
719 #endif
720
721 #ifndef HAVE_UNLINK
722 #define do_unix_unlink 0
723 #else
724 static void
725 do_unix_unlink(os_emul_data *emul,
726 unsigned call,
727 const int arg0,
728 cpu *processor,
729 unsigned_word cia)
730 {
731 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
732 char path_buf[PATH_MAX];
733 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
734 int status;
735
736 if (WITH_TRACE && ppc_trace[trace_os_emul])
737 printf_filtered ("0x%lx [%s]", (long)path_addr, path);
738
739 status = unlink(path);
740 emul_write_status(processor, status, errno);
741 }
742 #endif
743
744 #ifndef HAVE_MKDIR
745 #define do_unix_mkdir 0
746 #else
747 static void
748 do_unix_mkdir(os_emul_data *emul,
749 unsigned call,
750 const int arg0,
751 cpu *processor,
752 unsigned_word cia)
753 {
754 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
755 char path_buf[PATH_MAX];
756 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
757 int mode = (int)cpu_registers(processor)->gpr[arg0+1];
758 int status;
759
760 if (WITH_TRACE && ppc_trace[trace_os_emul])
761 printf_filtered ("0x%lx [%s], 0%3o", (long)path_addr, path, mode);
762
763 status = mkdir(path, mode);
764 emul_write_status(processor, status, errno);
765 }
766 #endif
767
768 #ifndef HAVE_RMDIR
769 #define do_unix_rmdir 0
770 #else
771 static void
772 do_unix_rmdir(os_emul_data *emul,
773 unsigned call,
774 const int arg0,
775 cpu *processor,
776 unsigned_word cia)
777 {
778 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
779 char path_buf[PATH_MAX];
780 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
781 int status;
782
783 if (WITH_TRACE && ppc_trace[trace_os_emul])
784 printf_filtered ("0x%lx [%s]", (long)path_addr, path);
785
786 status = rmdir(path);
787 emul_write_status(processor, status, errno);
788 }
789 #endif
790
791 #ifndef HAVE_TIME
792 #define do_unix_time 0
793 #else
794 static void
795 do_unix_time(os_emul_data *emul,
796 unsigned call,
797 const int arg0,
798 cpu *processor,
799 unsigned_word cia)
800 {
801 unsigned_word tp = cpu_registers(processor)->gpr[arg0];
802 time_t now = time ((time_t *)0);
803 unsigned_word status = H2T_4(now);
804
805 if (WITH_TRACE && ppc_trace[trace_os_emul])
806 printf_filtered ("0x%lx", (long)tp);
807
808 emul_write_status(processor, (int)status, errno);
809
810 if (tp)
811 emul_write_buffer(&status, tp, sizeof(status), processor, cia);
812 }
813 #endif
814
815 #if !defined(HAVE_GETTIMEOFDAY)
816 #define do_unix_gettimeofday 0
817 #else
818 static void
819 do_unix_gettimeofday(os_emul_data *emul,
820 unsigned call,
821 const int arg0,
822 cpu *processor,
823 unsigned_word cia)
824 {
825 unsigned_word tv = cpu_registers(processor)->gpr[arg0];
826 unsigned_word tz = cpu_registers(processor)->gpr[arg0+1];
827 struct unix_timeval target_timeval;
828 struct timeval host_timeval;
829 struct unix_timezone target_timezone;
830 struct timezone host_timezone;
831 int status;
832
833 if (WITH_TRACE && ppc_trace[trace_os_emul])
834 printf_filtered ("0x%lx, 0x%lx", (long)tv, (long)tz);
835
836 /* Just in case the system doesn't set the timezone structure */
837 host_timezone.tz_minuteswest = 0;
838 host_timezone.tz_dsttime = 0;
839
840 status = gettimeofday(&host_timeval, &host_timezone);
841 if (status >= 0) {
842 if (tv) {
843 target_timeval.tv_sec = H2T_4(host_timeval.tv_sec);
844 target_timeval.tv_usec = H2T_4(host_timeval.tv_usec);
845 emul_write_buffer((void *) &target_timeval, tv, sizeof(target_timeval), processor, cia);
846 }
847
848 if (tz) {
849 target_timezone.tz_minuteswest = H2T_4(host_timezone.tz_minuteswest);
850 target_timezone.tz_dsttime = H2T_4(host_timezone.tz_dsttime);
851 emul_write_buffer((void *) &target_timezone, tv, sizeof(target_timezone), processor, cia);
852 }
853 }
854
855 emul_write_status(processor, (int)status, errno);
856 }
857 #endif
858
859
860 #ifndef HAVE_GETRUSAGE
861 #define do_unix_getrusage 0
862 #else
863 static void
864 do_unix_getrusage(os_emul_data *emul,
865 unsigned call,
866 const int arg0,
867 cpu *processor,
868 unsigned_word cia)
869 {
870 signed_word who = (signed_word)cpu_registers(processor)->gpr[arg0];
871 unsigned_word usage = cpu_registers(processor)->gpr[arg0+1];
872 struct rusage host_rusage, host_rusage2;
873 struct unix_rusage target_rusage;
874 int status;
875
876 if (WITH_TRACE && ppc_trace[trace_os_emul])
877 printf_filtered ("%ld, 0x%lx", (long)who, (long)usage);
878
879 switch (who) {
880 default:
881 status = -1;
882 errno = EINVAL;
883 break;
884
885 case UNIX_RUSAGE_SELF:
886 status = getrusage(RUSAGE_SELF, &host_rusage);
887 break;
888
889 case UNIX_RUSAGE_CHILDREN:
890 status = getrusage(RUSAGE_CHILDREN, &host_rusage);
891 break;
892
893 case UNIX_RUSAGE_BOTH:
894 status = getrusage(RUSAGE_SELF, &host_rusage);
895 if (status >= 0) {
896 status = getrusage(RUSAGE_CHILDREN, &host_rusage2);
897 if (status >= 0) {
898 host_rusage.ru_utime.tv_sec += host_rusage2.ru_utime.tv_sec;
899 host_rusage.ru_utime.tv_usec += host_rusage2.ru_utime.tv_usec;
900 host_rusage.ru_stime.tv_sec += host_rusage2.ru_stime.tv_sec;
901 host_rusage.ru_stime.tv_usec += host_rusage2.ru_stime.tv_usec;
902 host_rusage.ru_maxrss += host_rusage2.ru_maxrss;
903 host_rusage.ru_ixrss += host_rusage2.ru_ixrss;
904 host_rusage.ru_idrss += host_rusage2.ru_idrss;
905 host_rusage.ru_isrss += host_rusage2.ru_isrss;
906 host_rusage.ru_minflt += host_rusage2.ru_minflt;
907 host_rusage.ru_majflt += host_rusage2.ru_majflt;
908 host_rusage.ru_nswap += host_rusage2.ru_nswap;
909 host_rusage.ru_inblock += host_rusage2.ru_inblock;
910 host_rusage.ru_oublock += host_rusage2.ru_oublock;
911 host_rusage.ru_msgsnd += host_rusage2.ru_msgsnd;
912 host_rusage.ru_msgrcv += host_rusage2.ru_msgrcv;
913 host_rusage.ru_nsignals += host_rusage2.ru_nsignals;
914 host_rusage.ru_nvcsw += host_rusage2.ru_nvcsw;
915 host_rusage.ru_nivcsw += host_rusage2.ru_nivcsw;
916 }
917 }
918 }
919
920 if (status >= 0) {
921 target_rusage.ru_utime.tv_sec = H2T_4(host_rusage2.ru_utime.tv_sec);
922 target_rusage.ru_utime.tv_usec = H2T_4(host_rusage2.ru_utime.tv_usec);
923 target_rusage.ru_stime.tv_sec = H2T_4(host_rusage2.ru_stime.tv_sec);
924 target_rusage.ru_stime.tv_usec = H2T_4(host_rusage2.ru_stime.tv_usec);
925 target_rusage.ru_maxrss = H2T_4(host_rusage2.ru_maxrss);
926 target_rusage.ru_ixrss = H2T_4(host_rusage2.ru_ixrss);
927 target_rusage.ru_idrss = H2T_4(host_rusage2.ru_idrss);
928 target_rusage.ru_isrss = H2T_4(host_rusage2.ru_isrss);
929 target_rusage.ru_minflt = H2T_4(host_rusage2.ru_minflt);
930 target_rusage.ru_majflt = H2T_4(host_rusage2.ru_majflt);
931 target_rusage.ru_nswap = H2T_4(host_rusage2.ru_nswap);
932 target_rusage.ru_inblock = H2T_4(host_rusage2.ru_inblock);
933 target_rusage.ru_oublock = H2T_4(host_rusage2.ru_oublock);
934 target_rusage.ru_msgsnd = H2T_4(host_rusage2.ru_msgsnd);
935 target_rusage.ru_msgrcv = H2T_4(host_rusage2.ru_msgrcv);
936 target_rusage.ru_nsignals = H2T_4(host_rusage2.ru_nsignals);
937 target_rusage.ru_nvcsw = H2T_4(host_rusage2.ru_nvcsw);
938 target_rusage.ru_nivcsw = H2T_4(host_rusage2.ru_nivcsw);
939 emul_write_buffer((void *) &target_rusage, usage, sizeof(target_rusage), processor, cia);
940 }
941
942 emul_write_status(processor, status, errno);
943 }
944 #endif
945
946
947 static void
948 do_unix_nop(os_emul_data *emul,
949 unsigned call,
950 const int arg0,
951 cpu *processor,
952 unsigned_word cia)
953 {
954 if (WITH_TRACE && ppc_trace[trace_os_emul])
955 printf_filtered ("0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx",
956 (long)cpu_registers(processor)->gpr[arg0],
957 (long)cpu_registers(processor)->gpr[arg0+1],
958 (long)cpu_registers(processor)->gpr[arg0+2],
959 (long)cpu_registers(processor)->gpr[arg0+3],
960 (long)cpu_registers(processor)->gpr[arg0+4],
961 (long)cpu_registers(processor)->gpr[arg0+5]);
962
963 emul_write_status(processor, 0, errno);
964 }
965
966 \f
967 /* Common code for initializing the system call stuff */
968
969 static os_emul_data *
970 emul_unix_create(device *root,
971 bfd *image,
972 const char *name,
973 emul_syscall *syscall)
974 {
975 unsigned_word top_of_stack;
976 unsigned stack_size;
977 int elf_binary;
978 os_emul_data *data;
979 device *vm;
980 char *filename;
981
982 /* merge any emulation specific entries into the device tree */
983
984 /* establish a few defaults */
985 if (image->xvec->flavour == bfd_target_elf_flavour) {
986 elf_binary = 1;
987 top_of_stack = 0xe0000000;
988 stack_size = 0x00100000;
989 }
990 else {
991 elf_binary = 0;
992 top_of_stack = 0x20000000;
993 stack_size = 0x00100000;
994 }
995
996 /* options */
997 emul_add_tree_options(root, image, name,
998 (WITH_ENVIRONMENT == USER_ENVIRONMENT
999 ? "user" : "virtual"),
1000 0 /*oea-interrupt-prefix*/);
1001
1002 /* virtual memory - handles growth of stack/heap */
1003 vm = tree_parse(root, "/openprom/vm@0x%lx",
1004 (unsigned long)(top_of_stack - stack_size));
1005 tree_parse(vm, "./stack-base 0x%lx",
1006 (unsigned long)(top_of_stack - stack_size));
1007 tree_parse(vm, "./nr-bytes 0x%x", stack_size);
1008
1009 filename = tree_quote_property (bfd_get_filename(image));
1010 tree_parse(root, "/openprom/vm/map-binary/file-name %s",
1011 filename);
1012 free (filename);
1013
1014 /* finish the init */
1015 tree_parse(root, "/openprom/init/register/pc 0x%lx",
1016 (unsigned long)bfd_get_start_address(image));
1017 tree_parse(root, "/openprom/init/register/sp 0x%lx",
1018 (unsigned long)top_of_stack);
1019 tree_parse(root, "/openprom/init/register/msr 0x%x",
1020 ((tree_find_boolean_property(root, "/options/little-endian?")
1021 ? msr_little_endian_mode
1022 : 0)
1023 | (tree_find_boolean_property(root, "/openprom/options/floating-point?")
1024 ? (msr_floating_point_available
1025 | msr_floating_point_exception_mode_0
1026 | msr_floating_point_exception_mode_1)
1027 : 0)));
1028 tree_parse(root, "/openprom/init/stack/stack-type %s",
1029 (elf_binary ? "ppc-elf" : "ppc-xcoff"));
1030
1031 /* finally our emulation data */
1032 data = ZALLOC(os_emul_data);
1033 data->vm = vm;
1034 data->syscalls = syscall;
1035 return data;
1036 }
1037
1038 \f
1039 /* EMULATION
1040
1041 Solaris - Emulation of user programs for Solaris/PPC
1042
1043 DESCRIPTION
1044
1045 */
1046
1047
1048 /* Solaris specific implementation */
1049
1050 typedef int32_t solaris_uid_t;
1051 typedef int32_t solaris_gid_t;
1052 typedef int32_t solaris_off_t;
1053 typedef int32_t solaris_pid_t;
1054 typedef int32_t solaris_time_t;
1055 typedef uint32_t solaris_dev_t;
1056 typedef uint32_t solaris_ino_t;
1057 typedef uint32_t solaris_mode_t;
1058 typedef uint32_t solaris_nlink_t;
1059
1060 #ifdef HAVE_SYS_STAT_H
1061 #define SOLARIS_ST_FSTYPSZ 16 /* array size for file system type name */
1062
1063 /* AIX 7.1 defines st_pad[123] to st_[amc]tim.tv_pad, respectively */
1064 #undef st_pad1
1065 #undef st_pad2
1066 #undef st_pad3
1067
1068 struct solaris_stat {
1069 solaris_dev_t st_dev;
1070 int32_t st_pad1[3]; /* reserved for network id */
1071 solaris_ino_t st_ino;
1072 solaris_mode_t st_mode;
1073 solaris_nlink_t st_nlink;
1074 solaris_uid_t st_uid;
1075 solaris_gid_t st_gid;
1076 solaris_dev_t st_rdev;
1077 int32_t st_pad2[2];
1078 solaris_off_t st_size;
1079 int32_t st_pad3; /* future off_t expansion */
1080 struct unix_timeval st_atim;
1081 struct unix_timeval st_mtim;
1082 struct unix_timeval st_ctim;
1083 int32_t st_blksize;
1084 int32_t st_blocks;
1085 char st_fstype[SOLARIS_ST_FSTYPSZ];
1086 int32_t st_pad4[8]; /* expansion area */
1087 };
1088
1089 /* Convert from host stat structure to solaris stat structure */
1090 STATIC_INLINE_EMUL_UNIX void
1091 convert_to_solaris_stat(unsigned_word addr,
1092 struct stat *host,
1093 cpu *processor,
1094 unsigned_word cia)
1095 {
1096 struct solaris_stat target;
1097 int i;
1098
1099 target.st_dev = H2T_4(host->st_dev);
1100 target.st_ino = H2T_4(host->st_ino);
1101 target.st_mode = H2T_4(host->st_mode);
1102 target.st_nlink = H2T_4(host->st_nlink);
1103 target.st_uid = H2T_4(host->st_uid);
1104 target.st_gid = H2T_4(host->st_gid);
1105 target.st_size = H2T_4(host->st_size);
1106
1107 #ifdef HAVE_ST_RDEV
1108 target.st_rdev = H2T_4(host->st_rdev);
1109 #else
1110 target.st_rdev = 0;
1111 #endif
1112
1113 #ifdef HAVE_ST_BLKSIZE
1114 target.st_blksize = H2T_4(host->st_blksize);
1115 #else
1116 target.st_blksize = 0;
1117 #endif
1118
1119 #ifdef HAVE_ST_BLOCKS
1120 target.st_blocks = H2T_4(host->st_blocks);
1121 #else
1122 target.st_blocks = 0;
1123 #endif
1124
1125 target.st_atim.tv_sec = H2T_4(host->st_atime);
1126 target.st_atim.tv_usec = 0;
1127
1128 target.st_ctim.tv_sec = H2T_4(host->st_ctime);
1129 target.st_ctim.tv_usec = 0;
1130
1131 target.st_mtim.tv_sec = H2T_4(host->st_mtime);
1132 target.st_mtim.tv_usec = 0;
1133
1134 for (i = 0; i < ARRAY_SIZE (target.st_pad1); i++)
1135 target.st_pad1[i] = 0;
1136
1137 for (i = 0; i < ARRAY_SIZE (target.st_pad2); i++)
1138 target.st_pad2[i] = 0;
1139
1140 target.st_pad3 = 0;
1141
1142 for (i = 0; i < ARRAY_SIZE (target.st_pad4); i++)
1143 target.st_pad4[i] = 0;
1144
1145 /* For now, just punt and always say it is a ufs file */
1146 strcpy (target.st_fstype, "ufs");
1147
1148 emul_write_buffer(&target, addr, sizeof(target), processor, cia);
1149 }
1150 #endif /* HAVE_SYS_STAT_H */
1151
1152 #ifndef HAVE_STAT
1153 #define do_solaris_stat 0
1154 #else
1155 static void
1156 do_solaris_stat(os_emul_data *emul,
1157 unsigned call,
1158 const int arg0,
1159 cpu *processor,
1160 unsigned_word cia)
1161 {
1162 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
1163 unsigned_word stat_pkt = cpu_registers(processor)->gpr[arg0+1];
1164 char path_buf[PATH_MAX];
1165 struct stat buf;
1166 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
1167 int status;
1168
1169 if (WITH_TRACE && ppc_trace[trace_os_emul])
1170 printf_filtered ("0x%lx [%s], 0x%lx", (long)path_addr, path, (long)stat_pkt);
1171
1172 status = stat (path, &buf);
1173 if (status == 0)
1174 convert_to_solaris_stat (stat_pkt, &buf, processor, cia);
1175
1176 emul_write_status(processor, status, errno);
1177 }
1178 #endif
1179
1180 #ifndef HAVE_LSTAT
1181 #define do_solaris_lstat 0
1182 #else
1183 static void
1184 do_solaris_lstat(os_emul_data *emul,
1185 unsigned call,
1186 const int arg0,
1187 cpu *processor,
1188 unsigned_word cia)
1189 {
1190 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
1191 unsigned_word stat_pkt = cpu_registers(processor)->gpr[arg0+1];
1192 char path_buf[PATH_MAX];
1193 struct stat buf;
1194 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
1195 int status;
1196
1197 if (WITH_TRACE && ppc_trace[trace_os_emul])
1198 printf_filtered ("0x%lx [%s], 0x%lx", (long)path_addr, path, (long)stat_pkt);
1199
1200 status = lstat (path, &buf);
1201 if (status == 0)
1202 convert_to_solaris_stat (stat_pkt, &buf, processor, cia);
1203
1204 emul_write_status(processor, status, errno);
1205 }
1206 #endif
1207
1208 #ifndef HAVE_FSTAT
1209 #define do_solaris_fstat 0
1210 #else
1211 static void
1212 do_solaris_fstat(os_emul_data *emul,
1213 unsigned call,
1214 const int arg0,
1215 cpu *processor,
1216 unsigned_word cia)
1217 {
1218 int fildes = (int)cpu_registers(processor)->gpr[arg0];
1219 unsigned_word stat_pkt = cpu_registers(processor)->gpr[arg0+1];
1220 struct stat buf;
1221 int status;
1222
1223 if (WITH_TRACE && ppc_trace[trace_os_emul])
1224 printf_filtered ("%d, 0x%lx", fildes, (long)stat_pkt);
1225
1226 status = fdbad (fildes);
1227 if (status == 0)
1228 status = fstat (fildes, &buf);
1229 if (status == 0)
1230 convert_to_solaris_stat (stat_pkt, &buf, processor, cia);
1231
1232 emul_write_status(processor, status, errno);
1233 }
1234 #endif
1235
1236 #if defined(HAVE_TERMIO_STRUCTURE) || defined(HAVE_TERMIOS_STRUCTURE)
1237 #define SOLARIS_TIOC ('T'<<8)
1238 #define SOLARIS_NCC 8
1239 #define SOLARIS_NCCS 19
1240
1241 #define SOLARIS_VINTR 0
1242 #define SOLARIS_VQUIT 1
1243 #define SOLARIS_VERASE 2
1244 #define SOLARIS_VKILL 3
1245 #define SOLARIS_VEOF 4
1246 #define SOLARIS_VEOL 5
1247 #define SOLARIS_VEOL2 6
1248 #define SOLARIS_VSWTCH 7
1249 #define SOLARIS_VSTART 8
1250 #define SOLARIS_VSTOP 9
1251 #define SOLARIS_VSUSP 10
1252 #define SOLARIS_VDSUSP 11
1253 #define SOLARIS_VREPRINT 12
1254 #define SOLARIS_VDISCARD 13
1255 #define SOLARIS_VWERASE 14
1256 #define SOLARIS_VLNEXT 15
1257 #endif
1258
1259 #if defined(HAVE_TERMIO_STRUCTURE) || defined(HAVE_TERMIOS_STRUCTURE)
1260 /* Convert to/from host termio structure */
1261
1262 struct solaris_termio {
1263 uint16_t c_iflag; /* input modes */
1264 uint16_t c_oflag; /* output modes */
1265 uint16_t c_cflag; /* control modes */
1266 uint16_t c_lflag; /* line discipline modes */
1267 uint8_t c_line; /* line discipline */
1268 uint8_t c_cc[SOLARIS_NCC]; /* control chars */
1269 };
1270
1271 STATIC_INLINE_EMUL_UNIX void
1272 convert_to_solaris_termio(unsigned_word addr,
1273 struct termio *host,
1274 cpu *processor,
1275 unsigned_word cia)
1276 {
1277 struct solaris_termio target;
1278 int i;
1279
1280 target.c_iflag = H2T_2 (host->c_iflag);
1281 target.c_oflag = H2T_2 (host->c_oflag);
1282 target.c_cflag = H2T_2 (host->c_cflag);
1283 target.c_lflag = H2T_2 (host->c_lflag);
1284
1285 #if defined(HAVE_TERMIO_CLINE) || defined(HAVE_TERMIOS_CLINE)
1286 target.c_line = host->c_line;
1287 #else
1288 target.c_line = 0;
1289 #endif
1290
1291 for (i = 0; i < SOLARIS_NCC; i++)
1292 target.c_cc[i] = 0;
1293
1294 #ifdef VINTR
1295 target.c_cc[SOLARIS_VINTR] = host->c_cc[VINTR];
1296 #endif
1297
1298 #ifdef VQUIT
1299 target.c_cc[SOLARIS_VQUIT] = host->c_cc[VQUIT];
1300 #endif
1301
1302 #ifdef VERASE
1303 target.c_cc[SOLARIS_VERASE] = host->c_cc[VERASE];
1304 #endif
1305
1306 #ifdef VKILL
1307 target.c_cc[SOLARIS_VKILL] = host->c_cc[VKILL];
1308 #endif
1309
1310 #ifdef VEOF
1311 target.c_cc[SOLARIS_VEOF] = host->c_cc[VEOF];
1312 #endif
1313
1314 #ifdef VEOL
1315 target.c_cc[SOLARIS_VEOL] = host->c_cc[VEOL];
1316 #endif
1317
1318 #ifdef VEOL2
1319 target.c_cc[SOLARIS_VEOL2] = host->c_cc[VEOL2];
1320 #endif
1321
1322 #ifdef VSWTCH
1323 target.c_cc[SOLARIS_VSWTCH] = host->c_cc[VSWTCH];
1324
1325 #else
1326 #ifdef VSWTC
1327 target.c_cc[SOLARIS_VSWTCH] = host->c_cc[VSWTC];
1328 #endif
1329 #endif
1330
1331 emul_write_buffer(&target, addr, sizeof(target), processor, cia);
1332 }
1333 #endif /* HAVE_TERMIO_STRUCTURE || HAVE_TERMIOS_STRUCTURE */
1334
1335 #ifdef HAVE_TERMIOS_STRUCTURE
1336 /* Convert to/from host termios structure */
1337
1338 typedef uint32_t solaris_tcflag_t;
1339 typedef uint8_t solaris_cc_t;
1340 typedef uint32_t solaris_speed_t;
1341
1342 struct solaris_termios {
1343 solaris_tcflag_t c_iflag;
1344 solaris_tcflag_t c_oflag;
1345 solaris_tcflag_t c_cflag;
1346 solaris_tcflag_t c_lflag;
1347 solaris_cc_t c_cc[SOLARIS_NCCS];
1348 };
1349
1350 STATIC_INLINE_EMUL_UNIX void
1351 convert_to_solaris_termios(unsigned_word addr,
1352 struct termios *host,
1353 cpu *processor,
1354 unsigned_word cia)
1355 {
1356 struct solaris_termios target;
1357 int i;
1358
1359 target.c_iflag = H2T_4 (host->c_iflag);
1360 target.c_oflag = H2T_4 (host->c_oflag);
1361 target.c_cflag = H2T_4 (host->c_cflag);
1362 target.c_lflag = H2T_4 (host->c_lflag);
1363
1364 for (i = 0; i < SOLARIS_NCCS; i++)
1365 target.c_cc[i] = 0;
1366
1367 #ifdef VINTR
1368 target.c_cc[SOLARIS_VINTR] = host->c_cc[VINTR];
1369 #endif
1370
1371 #ifdef VQUIT
1372 target.c_cc[SOLARIS_VQUIT] = host->c_cc[VQUIT];
1373 #endif
1374
1375 #ifdef VERASE
1376 target.c_cc[SOLARIS_VERASE] = host->c_cc[VERASE];
1377 #endif
1378
1379 #ifdef VKILL
1380 target.c_cc[SOLARIS_VKILL] = host->c_cc[VKILL];
1381 #endif
1382
1383 #ifdef VEOF
1384 target.c_cc[SOLARIS_VEOF] = host->c_cc[VEOF];
1385 #endif
1386
1387 #ifdef VEOL
1388 target.c_cc[SOLARIS_VEOL] = host->c_cc[VEOL];
1389 #endif
1390
1391 #ifdef VEOL2
1392 target.c_cc[SOLARIS_VEOL2] = host->c_cc[VEOL2];
1393 #endif
1394
1395 #ifdef VSWTCH
1396 target.c_cc[SOLARIS_VSWTCH] = host->c_cc[VSWTCH];
1397
1398 #else
1399 #ifdef VSWTC
1400 target.c_cc[SOLARIS_VSWTCH] = host->c_cc[VSWTC];
1401 #endif
1402 #endif
1403
1404 #ifdef VSTART
1405 target.c_cc[SOLARIS_VSTART] = host->c_cc[VSTART];
1406 #endif
1407
1408 #ifdef VSTOP
1409 target.c_cc[SOLARIS_VSTOP] = host->c_cc[VSTOP];
1410 #endif
1411
1412 #ifdef VSUSP
1413 target.c_cc[SOLARIS_VSUSP] = host->c_cc[VSUSP];
1414 #endif
1415
1416 #ifdef VDSUSP
1417 target.c_cc[SOLARIS_VDSUSP] = host->c_cc[VDSUSP];
1418 #endif
1419
1420 #ifdef VREPRINT
1421 target.c_cc[SOLARIS_VREPRINT] = host->c_cc[VREPRINT];
1422 #endif
1423
1424 #ifdef VDISCARD
1425 target.c_cc[SOLARIS_VDISCARD] = host->c_cc[VDISCARD];
1426 #endif
1427
1428 #ifdef VWERASE
1429 target.c_cc[SOLARIS_VWERASE] = host->c_cc[VWERASE];
1430 #endif
1431
1432 #ifdef VLNEXT
1433 target.c_cc[SOLARIS_VLNEXT] = host->c_cc[VLNEXT];
1434 #endif
1435
1436 emul_write_buffer(&target, addr, sizeof(target), processor, cia);
1437 }
1438 #endif /* HAVE_TERMIOS_STRUCTURE */
1439
1440 #ifndef HAVE_IOCTL
1441 #define do_solaris_ioctl 0
1442 #else
1443 static void
1444 do_solaris_ioctl(os_emul_data *emul,
1445 unsigned call,
1446 const int arg0,
1447 cpu *processor,
1448 unsigned_word cia)
1449 {
1450 int fildes = cpu_registers(processor)->gpr[arg0];
1451 unsigned request = cpu_registers(processor)->gpr[arg0+1];
1452 unsigned_word argp_addr = cpu_registers(processor)->gpr[arg0+2];
1453 int status = 0;
1454 const char *name = "<unknown>";
1455
1456 #ifdef HAVE_TERMIOS_STRUCTURE
1457 struct termios host_termio;
1458
1459 #else
1460 #ifdef HAVE_TERMIO_STRUCTURE
1461 struct termio host_termio;
1462 #endif
1463 #endif
1464
1465 status = fdbad (fildes);
1466 if (status != 0)
1467 goto done;
1468
1469 switch (request)
1470 {
1471 case 0: /* make sure we have at least one case */
1472 default:
1473 status = -1;
1474 errno = EINVAL;
1475 break;
1476
1477 #if defined(HAVE_TERMIO_STRUCTURE) || defined(HAVE_TERMIOS_STRUCTURE)
1478 #if defined(TCGETA) || defined(TCGETS) || defined(HAVE_TCGETATTR)
1479 case SOLARIS_TIOC | 1: /* TCGETA */
1480 name = "TCGETA";
1481 #ifdef HAVE_TCGETATTR
1482 status = tcgetattr(fildes, &host_termio);
1483 #elif defined(TCGETS)
1484 status = ioctl (fildes, TCGETS, &host_termio);
1485 #else
1486 status = ioctl (fildes, TCGETA, &host_termio);
1487 #endif
1488 if (status == 0)
1489 convert_to_solaris_termio (argp_addr, &host_termio, processor, cia);
1490 break;
1491 #endif /* TCGETA */
1492 #endif /* HAVE_TERMIO_STRUCTURE */
1493
1494 #ifdef HAVE_TERMIOS_STRUCTURE
1495 #if defined(TCGETS) || defined(HAVE_TCGETATTR)
1496 case SOLARIS_TIOC | 13: /* TCGETS */
1497 name = "TCGETS";
1498 #ifdef HAVE_TCGETATTR
1499 status = tcgetattr(fildes, &host_termio);
1500 #else
1501 status = ioctl (fildes, TCGETS, &host_termio);
1502 #endif
1503 if (status == 0)
1504 convert_to_solaris_termios (argp_addr, &host_termio, processor, cia);
1505 break;
1506 #endif /* TCGETS */
1507 #endif /* HAVE_TERMIOS_STRUCTURE */
1508 }
1509
1510 done:
1511 emul_write_status(processor, status, errno);
1512
1513 if (WITH_TRACE && ppc_trace[trace_os_emul])
1514 printf_filtered ("%d, 0x%x [%s], 0x%lx", fildes, request, name, (long)argp_addr);
1515 }
1516 #endif /* HAVE_IOCTL */
1517
1518 static emul_syscall_descriptor solaris_descriptors[] = {
1519 /* 0 */ { 0, "syscall" },
1520 /* 1 */ { do_unix_exit, "exit" },
1521 /* 2 */ { 0, "fork" },
1522 /* 3 */ { do_unix_read, "read" },
1523 /* 4 */ { do_unix_write, "write" },
1524 /* 5 */ { do_unix_open, "open" },
1525 /* 6 */ { do_unix_close, "close" },
1526 /* 7 */ { 0, "wait" },
1527 /* 8 */ { 0, "creat" },
1528 /* 9 */ { do_unix_link, "link" },
1529 /* 10 */ { do_unix_unlink, "unlink" },
1530 /* 11 */ { 0, "exec" },
1531 /* 12 */ { do_unix_chdir, "chdir" },
1532 /* 13 */ { do_unix_time, "time" },
1533 /* 14 */ { 0, "mknod" },
1534 /* 15 */ { 0, "chmod" },
1535 /* 16 */ { 0, "chown" },
1536 /* 17 */ { do_unix_break, "brk" },
1537 /* 18 */ { do_solaris_stat, "stat" },
1538 /* 19 */ { do_unix_lseek, "lseek" },
1539 /* 20 */ { do_unix_getpid2, "getpid" },
1540 /* 21 */ { 0, "mount" },
1541 /* 22 */ { 0, "umount" },
1542 /* 23 */ { 0, "setuid" },
1543 /* 24 */ { do_unix_getuid2, "getuid" },
1544 /* 25 */ { 0, "stime" },
1545 /* 26 */ { 0, "ptrace" },
1546 /* 27 */ { 0, "alarm" },
1547 /* 28 */ { do_solaris_fstat, "fstat" },
1548 /* 29 */ { 0, "pause" },
1549 /* 30 */ { 0, "utime" },
1550 /* 31 */ { 0, "stty" },
1551 /* 32 */ { 0, "gtty" },
1552 /* 33 */ { do_unix_access, "access" },
1553 /* 34 */ { 0, "nice" },
1554 /* 35 */ { 0, "statfs" },
1555 /* 36 */ { 0, "sync" },
1556 /* 37 */ { 0, "kill" },
1557 /* 38 */ { 0, "fstatfs" },
1558 /* 39 */ { 0, "pgrpsys" },
1559 /* 40 */ { 0, "xenix" },
1560 /* 41 */ { do_unix_dup, "dup" },
1561 /* 42 */ { 0, "pipe" },
1562 /* 43 */ { 0, "times" },
1563 /* 44 */ { 0, "profil" },
1564 /* 45 */ { 0, "plock" },
1565 /* 46 */ { 0, "setgid" },
1566 /* 47 */ { do_unix_getgid2, "getgid" },
1567 /* 48 */ { 0, "signal" },
1568 /* 49 */ { 0, "msgsys" },
1569 /* 50 */ { 0, "syssun" },
1570 /* 51 */ { 0, "acct" },
1571 /* 52 */ { 0, "shmsys" },
1572 /* 53 */ { 0, "semsys" },
1573 /* 54 */ { do_solaris_ioctl, "ioctl" },
1574 /* 55 */ { 0, "uadmin" },
1575 /* 56 */ { 0, 0 /* reserved for exch */ },
1576 /* 57 */ { 0, "utssys" },
1577 /* 58 */ { 0, "fdsync" },
1578 /* 59 */ { 0, "execve" },
1579 /* 60 */ { do_unix_umask, "umask" },
1580 /* 61 */ { 0, "chroot" },
1581 /* 62 */ { 0, "fcntl" },
1582 /* 63 */ { 0, "ulimit" },
1583 /* 64 */ { 0, 0 /* reserved for UNIX PC */ },
1584 /* 64 */ { 0, 0 /* reserved for UNIX PC */ },
1585 /* 65 */ { 0, 0 /* reserved for UNIX PC */ },
1586 /* 66 */ { 0, 0 /* reserved for UNIX PC */ },
1587 /* 67 */ { 0, 0 /* reserved for UNIX PC */ },
1588 /* 68 */ { 0, 0 /* reserved for UNIX PC */ },
1589 /* 69 */ { 0, 0 /* reserved for UNIX PC */ },
1590 /* 70 */ { 0, 0 /* was advfs */ },
1591 /* 71 */ { 0, 0 /* was unadvfs */ },
1592 /* 72 */ { 0, 0 /* was rmount */ },
1593 /* 73 */ { 0, 0 /* was rumount */ },
1594 /* 74 */ { 0, 0 /* was rfstart */ },
1595 /* 75 */ { 0, 0 /* was sigret */ },
1596 /* 76 */ { 0, 0 /* was rdebug */ },
1597 /* 77 */ { 0, 0 /* was rfstop */ },
1598 /* 78 */ { 0, 0 /* was rfsys */ },
1599 /* 79 */ { do_unix_rmdir, "rmdir" },
1600 /* 80 */ { do_unix_mkdir, "mkdir" },
1601 /* 81 */ { 0, "getdents" },
1602 /* 82 */ { 0, 0 /* was libattach */ },
1603 /* 83 */ { 0, 0 /* was libdetach */ },
1604 /* 84 */ { 0, "sysfs" },
1605 /* 85 */ { 0, "getmsg" },
1606 /* 86 */ { 0, "putmsg" },
1607 /* 87 */ { 0, "poll" },
1608 /* 88 */ { do_solaris_lstat, "lstat" },
1609 /* 89 */ { do_unix_symlink, "symlink" },
1610 /* 90 */ { 0, "readlink" },
1611 /* 91 */ { 0, "setgroups" },
1612 /* 92 */ { 0, "getgroups" },
1613 /* 93 */ { 0, "fchmod" },
1614 /* 94 */ { 0, "fchown" },
1615 /* 95 */ { 0, "sigprocmask" },
1616 /* 96 */ { 0, "sigsuspend" },
1617 /* 97 */ { do_unix_nop, "sigaltstack" },
1618 /* 98 */ { do_unix_nop, "sigaction" },
1619 /* 99 */ { 0, "sigpending" },
1620 /* 100 */ { 0, "context" },
1621 /* 101 */ { 0, "evsys" },
1622 /* 102 */ { 0, "evtrapret" },
1623 /* 103 */ { 0, "statvfs" },
1624 /* 104 */ { 0, "fstatvfs" },
1625 /* 105 */ { 0, 0 /* reserved */ },
1626 /* 106 */ { 0, "nfssys" },
1627 /* 107 */ { 0, "waitsys" },
1628 /* 108 */ { 0, "sigsendsys" },
1629 /* 109 */ { 0, "hrtsys" },
1630 /* 110 */ { 0, "acancel" },
1631 /* 111 */ { 0, "async" },
1632 /* 112 */ { 0, "priocntlsys" },
1633 /* 113 */ { 0, "pathconf" },
1634 /* 114 */ { 0, "mincore" },
1635 /* 115 */ { 0, "mmap" },
1636 /* 116 */ { 0, "mprotect" },
1637 /* 117 */ { 0, "munmap" },
1638 /* 118 */ { 0, "fpathconf" },
1639 /* 119 */ { 0, "vfork" },
1640 /* 120 */ { 0, "fchdir" },
1641 /* 121 */ { 0, "readv" },
1642 /* 122 */ { 0, "writev" },
1643 /* 123 */ { 0, "xstat" },
1644 /* 124 */ { 0, "lxstat" },
1645 /* 125 */ { 0, "fxstat" },
1646 /* 126 */ { 0, "xmknod" },
1647 /* 127 */ { 0, "clocal" },
1648 /* 128 */ { 0, "setrlimit" },
1649 /* 129 */ { 0, "getrlimit" },
1650 /* 130 */ { 0, "lchown" },
1651 /* 131 */ { 0, "memcntl" },
1652 /* 132 */ { 0, "getpmsg" },
1653 /* 133 */ { 0, "putpmsg" },
1654 /* 134 */ { 0, "rename" },
1655 /* 135 */ { 0, "uname" },
1656 /* 136 */ { 0, "setegid" },
1657 /* 137 */ { 0, "sysconfig" },
1658 /* 138 */ { 0, "adjtime" },
1659 /* 139 */ { 0, "systeminfo" },
1660 /* 140 */ { 0, 0 /* reserved */ },
1661 /* 141 */ { 0, "seteuid" },
1662 /* 142 */ { 0, "vtrace" },
1663 /* 143 */ { 0, "fork1" },
1664 /* 144 */ { 0, "sigtimedwait" },
1665 /* 145 */ { 0, "lwp_info" },
1666 /* 146 */ { 0, "yield" },
1667 /* 147 */ { 0, "lwp_sema_wait" },
1668 /* 148 */ { 0, "lwp_sema_post" },
1669 /* 149 */ { 0, 0 /* reserved */ },
1670 /* 150 */ { 0, 0 /* reserved */ },
1671 /* 151 */ { 0, 0 /* reserved */ },
1672 /* 152 */ { 0, "modctl" },
1673 /* 153 */ { 0, "fchroot" },
1674 /* 154 */ { 0, "utimes" },
1675 /* 155 */ { 0, "vhangup" },
1676 /* 156 */ { do_unix_gettimeofday, "gettimeofday" },
1677 /* 157 */ { 0, "getitimer" },
1678 /* 158 */ { 0, "setitimer" },
1679 /* 159 */ { 0, "lwp_create" },
1680 /* 160 */ { 0, "lwp_exit" },
1681 /* 161 */ { 0, "lwp_suspend" },
1682 /* 162 */ { 0, "lwp_continue" },
1683 /* 163 */ { 0, "lwp_kill" },
1684 /* 164 */ { 0, "lwp_self" },
1685 /* 165 */ { 0, "lwp_setprivate" },
1686 /* 166 */ { 0, "lwp_getprivate" },
1687 /* 167 */ { 0, "lwp_wait" },
1688 /* 168 */ { 0, "lwp_mutex_unlock" },
1689 /* 169 */ { 0, "lwp_mutex_lock" },
1690 /* 170 */ { 0, "lwp_cond_wait" },
1691 /* 171 */ { 0, "lwp_cond_signal" },
1692 /* 172 */ { 0, "lwp_cond_broadcast" },
1693 /* 173 */ { 0, "pread" },
1694 /* 174 */ { 0, "pwrite" },
1695 /* 175 */ { 0, "llseek" },
1696 /* 176 */ { 0, "inst_sync" },
1697 /* 177 */ { 0, 0 /* reserved */ },
1698 /* 178 */ { 0, "kaio" },
1699 /* 179 */ { 0, 0 /* reserved */ },
1700 /* 180 */ { 0, 0 /* reserved */ },
1701 /* 181 */ { 0, 0 /* reserved */ },
1702 /* 182 */ { 0, 0 /* reserved */ },
1703 /* 183 */ { 0, 0 /* reserved */ },
1704 /* 184 */ { 0, "tsolsys" },
1705 /* 185 */ { 0, "acl" },
1706 /* 186 */ { 0, "auditsys" },
1707 /* 187 */ { 0, "processor_bind" },
1708 /* 188 */ { 0, "processor_info" },
1709 /* 189 */ { 0, "p_online" },
1710 /* 190 */ { 0, "sigqueue" },
1711 /* 191 */ { 0, "clock_gettime" },
1712 /* 192 */ { 0, "clock_settime" },
1713 /* 193 */ { 0, "clock_getres" },
1714 /* 194 */ { 0, "timer_create" },
1715 /* 195 */ { 0, "timer_delete" },
1716 /* 196 */ { 0, "timer_settime" },
1717 /* 197 */ { 0, "timer_gettime" },
1718 /* 198 */ { 0, "timer_getoverrun" },
1719 /* 199 */ { 0, "nanosleep" },
1720 /* 200 */ { 0, "facl" },
1721 /* 201 */ { 0, "door" },
1722 /* 202 */ { 0, "setreuid" },
1723 /* 203 */ { 0, "setregid" },
1724 /* 204 */ { 0, "install_utrap" },
1725 /* 205 */ { 0, 0 /* reserved */ },
1726 /* 206 */ { 0, 0 /* reserved */ },
1727 /* 207 */ { 0, 0 /* reserved */ },
1728 /* 208 */ { 0, 0 /* reserved */ },
1729 /* 209 */ { 0, 0 /* reserved */ },
1730 /* 210 */ { 0, "signotifywait" },
1731 /* 211 */ { 0, "lwp_sigredirect" },
1732 /* 212 */ { 0, "lwp_alarm" },
1733 };
1734
1735 static char *(solaris_error_names[]) = {
1736 /* 0 */ "ESUCCESS",
1737 /* 1 */ "EPERM",
1738 /* 2 */ "ENOENT",
1739 /* 3 */ "ESRCH",
1740 /* 4 */ "EINTR",
1741 /* 5 */ "EIO",
1742 /* 6 */ "ENXIO",
1743 /* 7 */ "E2BIG",
1744 /* 8 */ "ENOEXEC",
1745 /* 9 */ "EBADF",
1746 /* 10 */ "ECHILD",
1747 /* 11 */ "EAGAIN",
1748 /* 12 */ "ENOMEM",
1749 /* 13 */ "EACCES",
1750 /* 14 */ "EFAULT",
1751 /* 15 */ "ENOTBLK",
1752 /* 16 */ "EBUSY",
1753 /* 17 */ "EEXIST",
1754 /* 18 */ "EXDEV",
1755 /* 19 */ "ENODEV",
1756 /* 20 */ "ENOTDIR",
1757 /* 21 */ "EISDIR",
1758 /* 22 */ "EINVAL",
1759 /* 23 */ "ENFILE",
1760 /* 24 */ "EMFILE",
1761 /* 25 */ "ENOTTY",
1762 /* 26 */ "ETXTBSY",
1763 /* 27 */ "EFBIG",
1764 /* 28 */ "ENOSPC",
1765 /* 29 */ "ESPIPE",
1766 /* 30 */ "EROFS",
1767 /* 31 */ "EMLINK",
1768 /* 32 */ "EPIPE",
1769 /* 33 */ "EDOM",
1770 /* 34 */ "ERANGE",
1771 /* 35 */ "ENOMSG",
1772 /* 36 */ "EIDRM",
1773 /* 37 */ "ECHRNG",
1774 /* 38 */ "EL2NSYNC",
1775 /* 39 */ "EL3HLT",
1776 /* 40 */ "EL3RST",
1777 /* 41 */ "ELNRNG",
1778 /* 42 */ "EUNATCH",
1779 /* 43 */ "ENOCSI",
1780 /* 44 */ "EL2HLT",
1781 /* 45 */ "EDEADLK",
1782 /* 46 */ "ENOLCK",
1783 /* 47 */ "ECANCELED",
1784 /* 48 */ "ENOTSUP",
1785 /* 49 */ "EDQUOT",
1786 /* 50 */ "EBADE",
1787 /* 51 */ "EBADR",
1788 /* 52 */ "EXFULL",
1789 /* 53 */ "ENOANO",
1790 /* 54 */ "EBADRQC",
1791 /* 55 */ "EBADSLT",
1792 /* 56 */ "EDEADLOCK",
1793 /* 57 */ "EBFONT",
1794 /* 58 */ "Error code 58",
1795 /* 59 */ "Error code 59",
1796 /* 60 */ "ENOSTR",
1797 /* 61 */ "ENODATA",
1798 /* 62 */ "ETIME",
1799 /* 63 */ "ENOSR",
1800 /* 64 */ "ENONET",
1801 /* 65 */ "ENOPKG",
1802 /* 66 */ "EREMOTE",
1803 /* 67 */ "ENOLINK",
1804 /* 68 */ "EADV",
1805 /* 69 */ "ESRMNT",
1806 /* 70 */ "ECOMM",
1807 /* 71 */ "EPROTO",
1808 /* 72 */ "Error code 72",
1809 /* 73 */ "Error code 73",
1810 /* 74 */ "EMULTIHOP",
1811 /* 75 */ "Error code 75",
1812 /* 76 */ "Error code 76",
1813 /* 77 */ "EBADMSG",
1814 /* 78 */ "ENAMETOOLONG",
1815 /* 79 */ "EOVERFLOW",
1816 /* 80 */ "ENOTUNIQ",
1817 /* 81 */ "EBADFD",
1818 /* 82 */ "EREMCHG",
1819 /* 83 */ "ELIBACC",
1820 /* 84 */ "ELIBBAD",
1821 /* 85 */ "ELIBSCN",
1822 /* 86 */ "ELIBMAX",
1823 /* 87 */ "ELIBEXEC",
1824 /* 88 */ "EILSEQ",
1825 /* 89 */ "ENOSYS",
1826 /* 90 */ "ELOOP",
1827 /* 91 */ "ERESTART",
1828 /* 92 */ "ESTRPIPE",
1829 /* 93 */ "ENOTEMPTY",
1830 /* 94 */ "EUSERS",
1831 /* 95 */ "ENOTSOCK",
1832 /* 96 */ "EDESTADDRREQ",
1833 /* 97 */ "EMSGSIZE",
1834 /* 98 */ "EPROTOTYPE",
1835 /* 99 */ "ENOPROTOOPT",
1836 /* 100 */ "Error code 100",
1837 /* 101 */ "Error code 101",
1838 /* 102 */ "Error code 102",
1839 /* 103 */ "Error code 103",
1840 /* 104 */ "Error code 104",
1841 /* 105 */ "Error code 105",
1842 /* 106 */ "Error code 106",
1843 /* 107 */ "Error code 107",
1844 /* 108 */ "Error code 108",
1845 /* 109 */ "Error code 109",
1846 /* 110 */ "Error code 110",
1847 /* 111 */ "Error code 111",
1848 /* 112 */ "Error code 112",
1849 /* 113 */ "Error code 113",
1850 /* 114 */ "Error code 114",
1851 /* 115 */ "Error code 115",
1852 /* 116 */ "Error code 116",
1853 /* 117 */ "Error code 117",
1854 /* 118 */ "Error code 118",
1855 /* 119 */ "Error code 119",
1856 /* 120 */ "EPROTONOSUPPORT",
1857 /* 121 */ "ESOCKTNOSUPPORT",
1858 /* 122 */ "EOPNOTSUPP",
1859 /* 123 */ "EPFNOSUPPORT",
1860 /* 124 */ "EAFNOSUPPORT",
1861 /* 125 */ "EADDRINUSE",
1862 /* 126 */ "EADDRNOTAVAIL",
1863 /* 127 */ "ENETDOWN",
1864 /* 128 */ "ENETUNREACH",
1865 /* 129 */ "ENETRESET",
1866 /* 130 */ "ECONNABORTED",
1867 /* 131 */ "ECONNRESET",
1868 /* 132 */ "ENOBUFS",
1869 /* 133 */ "EISCONN",
1870 /* 134 */ "ENOTCONN",
1871 /* 135 */ "Error code 135", /* XENIX has 135 - 142 */
1872 /* 136 */ "Error code 136",
1873 /* 137 */ "Error code 137",
1874 /* 138 */ "Error code 138",
1875 /* 139 */ "Error code 139",
1876 /* 140 */ "Error code 140",
1877 /* 141 */ "Error code 141",
1878 /* 142 */ "Error code 142",
1879 /* 143 */ "ESHUTDOWN",
1880 /* 144 */ "ETOOMANYREFS",
1881 /* 145 */ "ETIMEDOUT",
1882 /* 146 */ "ECONNREFUSED",
1883 /* 147 */ "EHOSTDOWN",
1884 /* 148 */ "EHOSTUNREACH",
1885 /* 149 */ "EALREADY",
1886 /* 150 */ "EINPROGRESS",
1887 /* 151 */ "ESTALE",
1888 };
1889
1890 static char *(solaris_signal_names[]) = {
1891 /* 0 */ 0,
1892 /* 1 */ "SIGHUP",
1893 /* 2 */ "SIGINT",
1894 /* 3 */ "SIGQUIT",
1895 /* 4 */ "SIGILL",
1896 /* 5 */ "SIGTRAP",
1897 /* 6 */ "SIGABRT",
1898 /* 7 */ "SIGEMT",
1899 /* 8 */ "SIGFPE",
1900 /* 9 */ "SIGKILL",
1901 /* 10 */ "SIGBUS",
1902 /* 11 */ "SIGSEGV",
1903 /* 12 */ "SIGSYS",
1904 /* 13 */ "SIGPIPE",
1905 /* 14 */ "SIGALRM",
1906 /* 15 */ "SIGTERM",
1907 /* 16 */ "SIGUSR1",
1908 /* 17 */ "SIGUSR2",
1909 /* 18 */ "SIGCHLD",
1910 /* 19 */ "SIGPWR",
1911 /* 20 */ "SIGWINCH",
1912 /* 21 */ "SIGURG",
1913 /* 22 */ "SIGPOLL",
1914 /* 23 */ "SIGSTOP",
1915 /* 24 */ "SIGTSTP",
1916 /* 25 */ "SIGCONT",
1917 /* 26 */ "SIGTTIN",
1918 /* 27 */ "SIGTTOU",
1919 /* 28 */ "SIGVTALRM",
1920 /* 29 */ "SIGPROF",
1921 /* 30 */ "SIGXCPU",
1922 /* 31 */ "SIGXFSZ",
1923 /* 32 */ "SIGWAITING",
1924 /* 33 */ "SIGLWP",
1925 /* 34 */ "SIGFREEZE",
1926 /* 35 */ "SIGTHAW",
1927 /* 36 */ "SIGCANCEL",
1928 };
1929
1930 static emul_syscall emul_solaris_syscalls = {
1931 solaris_descriptors,
1932 ARRAY_SIZE (solaris_descriptors),
1933 solaris_error_names,
1934 ARRAY_SIZE (solaris_error_names),
1935 solaris_signal_names,
1936 ARRAY_SIZE (solaris_signal_names),
1937 };
1938
1939
1940 /* Solaris's os_emul interface, most are just passed on to the generic
1941 syscall stuff */
1942
1943 static os_emul_data *
1944 emul_solaris_create(device *root,
1945 bfd *image,
1946 const char *name)
1947 {
1948 /* check that this emulation is really for us */
1949 if (name != NULL && strcmp(name, "solaris") != 0)
1950 return NULL;
1951
1952 if (image == NULL)
1953 return NULL;
1954
1955 return emul_unix_create(root, image, "solaris", &emul_solaris_syscalls);
1956 }
1957
1958 static void
1959 emul_solaris_init(os_emul_data *emul_data,
1960 int nr_cpus)
1961 {
1962 fd_closed[0] = 0;
1963 fd_closed[1] = 0;
1964 fd_closed[2] = 0;
1965 }
1966
1967 static void
1968 emul_solaris_system_call(cpu *processor,
1969 unsigned_word cia,
1970 os_emul_data *emul_data)
1971 {
1972 emul_do_system_call(emul_data,
1973 emul_data->syscalls,
1974 cpu_registers(processor)->gpr[0],
1975 3, /*r3 contains arg0*/
1976 processor,
1977 cia);
1978 }
1979
1980 const os_emul emul_solaris = {
1981 "solaris",
1982 emul_solaris_create,
1983 emul_solaris_init,
1984 emul_solaris_system_call,
1985 0, /*instruction_call*/
1986 0 /*data*/
1987 };
1988
1989 \f
1990 /* EMULATION
1991
1992 Linux - Emulation of user programs for Linux/PPC
1993
1994 DESCRIPTION
1995
1996 */
1997
1998
1999 /* Linux specific implementation */
2000
2001 typedef uint32_t linux_dev_t;
2002 typedef uint32_t linux_ino_t;
2003 typedef uint32_t linux_mode_t;
2004 typedef uint16_t linux_nlink_t;
2005 typedef int32_t linux_off_t;
2006 typedef int32_t linux_pid_t;
2007 typedef uint32_t linux_uid_t;
2008 typedef uint32_t linux_gid_t;
2009 typedef uint32_t linux_size_t;
2010 typedef int32_t linux_ssize_t;
2011 typedef int32_t linux_ptrdiff_t;
2012 typedef int32_t linux_time_t;
2013 typedef int32_t linux_clock_t;
2014 typedef int32_t linux_daddr_t;
2015
2016 #ifdef HAVE_SYS_STAT_H
2017 /* For the PowerPC, don't both with the 'old' stat structure, since there
2018 should be no extant binaries with that structure. */
2019
2020 struct linux_stat {
2021 linux_dev_t st_dev;
2022 linux_ino_t st_ino;
2023 linux_mode_t st_mode;
2024 linux_nlink_t st_nlink;
2025 linux_uid_t st_uid;
2026 linux_gid_t st_gid;
2027 linux_dev_t st_rdev;
2028 linux_off_t st_size;
2029 uint32_t st_blksize;
2030 uint32_t st_blocks;
2031 uint32_t st_atimx; /* don't use st_{a,c,m}time, that might a macro */
2032 uint32_t __unused1; /* defined by the host's stat.h */
2033 uint32_t st_mtimx;
2034 uint32_t __unused2;
2035 uint32_t st_ctimx;
2036 uint32_t __unused3;
2037 uint32_t __unused4;
2038 uint32_t __unused5;
2039 };
2040
2041 /* Convert from host stat structure to solaris stat structure */
2042 STATIC_INLINE_EMUL_UNIX void
2043 convert_to_linux_stat(unsigned_word addr,
2044 struct stat *host,
2045 cpu *processor,
2046 unsigned_word cia)
2047 {
2048 struct linux_stat target;
2049
2050 target.st_dev = H2T_4(host->st_dev);
2051 target.st_ino = H2T_4(host->st_ino);
2052 target.st_mode = H2T_4(host->st_mode);
2053 target.st_nlink = H2T_2(host->st_nlink);
2054 target.st_uid = H2T_4(host->st_uid);
2055 target.st_gid = H2T_4(host->st_gid);
2056 target.st_size = H2T_4(host->st_size);
2057
2058 #ifdef HAVE_ST_RDEV
2059 target.st_rdev = H2T_4(host->st_rdev);
2060 #else
2061 target.st_rdev = 0;
2062 #endif
2063
2064 #ifdef HAVE_ST_BLKSIZE
2065 target.st_blksize = H2T_4(host->st_blksize);
2066 #else
2067 target.st_blksize = 0;
2068 #endif
2069
2070 #ifdef HAVE_ST_BLOCKS
2071 target.st_blocks = H2T_4(host->st_blocks);
2072 #else
2073 target.st_blocks = 0;
2074 #endif
2075
2076 target.st_atimx = H2T_4(host->st_atime);
2077 target.st_ctimx = H2T_4(host->st_ctime);
2078 target.st_mtimx = H2T_4(host->st_mtime);
2079 target.__unused1 = 0;
2080 target.__unused2 = 0;
2081 target.__unused3 = 0;
2082 target.__unused4 = 0;
2083 target.__unused5 = 0;
2084
2085 emul_write_buffer(&target, addr, sizeof(target), processor, cia);
2086 }
2087 #endif /* HAVE_SYS_STAT_H */
2088
2089 #ifndef HAVE_STAT
2090 #define do_linux_stat 0
2091 #else
2092 static void
2093 do_linux_stat(os_emul_data *emul,
2094 unsigned call,
2095 const int arg0,
2096 cpu *processor,
2097 unsigned_word cia)
2098 {
2099 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
2100 unsigned_word stat_pkt = cpu_registers(processor)->gpr[arg0+1];
2101 char path_buf[PATH_MAX];
2102 struct stat buf;
2103 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
2104 int status;
2105
2106 if (WITH_TRACE && ppc_trace[trace_os_emul])
2107 printf_filtered ("0x%lx [%s], 0x%lx", (long)path_addr, path, (long)stat_pkt);
2108
2109 status = stat (path, &buf);
2110 if (status == 0)
2111 convert_to_linux_stat (stat_pkt, &buf, processor, cia);
2112
2113 emul_write_status(processor, status, errno);
2114 }
2115 #endif
2116
2117 #ifndef HAVE_LSTAT
2118 #define do_linux_lstat 0
2119 #else
2120 static void
2121 do_linux_lstat(os_emul_data *emul,
2122 unsigned call,
2123 const int arg0,
2124 cpu *processor,
2125 unsigned_word cia)
2126 {
2127 unsigned_word path_addr = cpu_registers(processor)->gpr[arg0];
2128 unsigned_word stat_pkt = cpu_registers(processor)->gpr[arg0+1];
2129 char path_buf[PATH_MAX];
2130 struct stat buf;
2131 char *path = emul_read_string(path_buf, path_addr, PATH_MAX, processor, cia);
2132 int status;
2133
2134 if (WITH_TRACE && ppc_trace[trace_os_emul])
2135 printf_filtered ("0x%lx [%s], 0x%lx", (long)path_addr, path, (long)stat_pkt);
2136
2137 status = lstat (path, &buf);
2138 if (status == 0)
2139 convert_to_linux_stat (stat_pkt, &buf, processor, cia);
2140
2141 emul_write_status(processor, status, errno);
2142 }
2143 #endif
2144
2145 #ifndef HAVE_FSTAT
2146 #define do_linux_fstat 0
2147 #else
2148 static void
2149 do_linux_fstat(os_emul_data *emul,
2150 unsigned call,
2151 const int arg0,
2152 cpu *processor,
2153 unsigned_word cia)
2154 {
2155 int fildes = (int)cpu_registers(processor)->gpr[arg0];
2156 unsigned_word stat_pkt = cpu_registers(processor)->gpr[arg0+1];
2157 struct stat buf;
2158 int status;
2159
2160 if (WITH_TRACE && ppc_trace[trace_os_emul])
2161 printf_filtered ("%d, 0x%lx", fildes, (long)stat_pkt);
2162
2163 status = fdbad (fildes);
2164 if (status == 0)
2165 status = fstat (fildes, &buf);
2166 if (status == 0)
2167 convert_to_linux_stat (stat_pkt, &buf, processor, cia);
2168
2169 emul_write_status(processor, status, errno);
2170 }
2171 #endif
2172
2173 #if defined(HAVE_TERMIO_STRUCTURE) || defined(HAVE_TERMIOS_STRUCTURE)
2174 #define LINUX_NCC 10
2175 #define LINUX_NCCS 19
2176
2177 #define LINUX_VINTR 0
2178 #define LINUX_VQUIT 1
2179 #define LINUX_VERASE 2
2180 #define LINUX_VKILL 3
2181 #define LINUX_VEOF 4
2182 #define LINUX_VMIN 5
2183 #define LINUX_VEOL 6
2184 #define LINUX_VTIME 7
2185 #define LINUX_VEOL2 8
2186 #define LINUX_VSWTC 9
2187 #define LINUX_VWERASE 10
2188 #define LINUX_VREPRINT 11
2189 #define LINUX_VSUSP 12
2190 #define LINUX_VSTART 13
2191 #define LINUX_VSTOP 14
2192 #define LINUX_VLNEXT 15
2193 #define LINUX_VDISCARD 16
2194
2195 #define LINUX_IOC_NRBITS 8
2196 #define LINUX_IOC_TYPEBITS 8
2197 #define LINUX_IOC_SIZEBITS 13
2198 #define LINUX_IOC_DIRBITS 3
2199
2200 #define LINUX_IOC_NRMASK ((1 << LINUX_IOC_NRBITS)-1)
2201 #define LINUX_IOC_TYPEMASK ((1 << LINUX_IOC_TYPEBITS)-1)
2202 #define LINUX_IOC_SIZEMASK ((1 << LINUX_IOC_SIZEBITS)-1)
2203 #define LINUX_IOC_DIRMASK ((1 << LINUX_IOC_DIRBITS)-1)
2204
2205 #define LINUX_IOC_NRSHIFT 0
2206 #define LINUX_IOC_TYPESHIFT (LINUX_IOC_NRSHIFT+LINUX_IOC_NRBITS)
2207 #define LINUX_IOC_SIZESHIFT (LINUX_IOC_TYPESHIFT+LINUX_IOC_TYPEBITS)
2208 #define LINUX_IOC_DIRSHIFT (LINUX_IOC_SIZESHIFT+LINUX_IOC_SIZEBITS)
2209
2210 /*
2211 * Direction bits _IOC_NONE could be 0, but OSF/1 gives it a bit.
2212 * And this turns out useful to catch old ioctl numbers in header
2213 * files for us.
2214 */
2215 #define LINUX_IOC_NONE 1U
2216 #define LINUX_IOC_READ 2U
2217 #define LINUX_IOC_WRITE 4U
2218
2219 #define LINUX_IOC(dir,type,nr,size) \
2220 (((dir) << LINUX_IOC_DIRSHIFT) | \
2221 ((type) << LINUX_IOC_TYPESHIFT) | \
2222 ((nr) << LINUX_IOC_NRSHIFT) | \
2223 ((size) << LINUX_IOC_SIZESHIFT))
2224
2225 /* used to create numbers */
2226 #define LINUX_IO(type,nr) LINUX_IOC(LINUX_IOC_NONE,(type),(nr),0)
2227 #define LINUX_IOR(type,nr,size) LINUX_IOC(LINUX_IOC_READ,(type),(nr),sizeof(size))
2228 #define LINUX_IOW(type,nr,size) LINUX_IOC(LINUX_IOC_WRITE,(type),(nr),sizeof(size))
2229 #define LINUX_IOWR(type,nr,size) LINUX_IOC(LINUX_IOC_READ|LINUX_IOC_WRITE,(type),(nr),sizeof(size))
2230 #endif
2231
2232 #if defined(HAVE_TERMIO_STRUCTURE) || defined(HAVE_TERMIOS_STRUCTURE)
2233 /* Convert to/from host termio structure */
2234
2235 struct linux_termio {
2236 uint16_t c_iflag; /* input modes */
2237 uint16_t c_oflag; /* output modes */
2238 uint16_t c_cflag; /* control modes */
2239 uint16_t c_lflag; /* line discipline modes */
2240 uint8_t c_line; /* line discipline */
2241 uint8_t c_cc[LINUX_NCC]; /* control chars */
2242 };
2243
2244 STATIC_INLINE_EMUL_UNIX void
2245 convert_to_linux_termio(unsigned_word addr,
2246 struct termio *host,
2247 cpu *processor,
2248 unsigned_word cia)
2249 {
2250 struct linux_termio target;
2251 int i;
2252
2253 target.c_iflag = H2T_2 (host->c_iflag);
2254 target.c_oflag = H2T_2 (host->c_oflag);
2255 target.c_cflag = H2T_2 (host->c_cflag);
2256 target.c_lflag = H2T_2 (host->c_lflag);
2257
2258 #if defined(HAVE_TERMIO_CLINE) || defined(HAVE_TERMIOS_CLINE)
2259 target.c_line = host->c_line;
2260 #else
2261 target.c_line = 0;
2262 #endif
2263
2264 for (i = 0; i < LINUX_NCC; i++)
2265 target.c_cc[i] = 0;
2266
2267 #ifdef VINTR
2268 target.c_cc[LINUX_VINTR] = host->c_cc[VINTR];
2269 #endif
2270
2271 #ifdef VQUIT
2272 target.c_cc[LINUX_VQUIT] = host->c_cc[VQUIT];
2273 #endif
2274
2275 #ifdef VERASE
2276 target.c_cc[LINUX_VERASE] = host->c_cc[VERASE];
2277 #endif
2278
2279 #ifdef VKILL
2280 target.c_cc[LINUX_VKILL] = host->c_cc[VKILL];
2281 #endif
2282
2283 #ifdef VEOF
2284 target.c_cc[LINUX_VEOF] = host->c_cc[VEOF];
2285 #endif
2286
2287 #ifdef VMIN
2288 target.c_cc[LINUX_VMIN] = host->c_cc[VMIN];
2289 #endif
2290
2291 #ifdef VEOL
2292 target.c_cc[LINUX_VEOL] = host->c_cc[VEOL];
2293 #endif
2294
2295 #ifdef VTIME
2296 target.c_cc[LINUX_VTIME] = host->c_cc[VTIME];
2297 #endif
2298
2299 #ifdef VEOL2
2300 target.c_cc[LINUX_VEOL2] = host->c_cc[VEOL2];
2301 #endif
2302
2303 #ifdef VSWTC
2304 target.c_cc[LINUX_VSWTC] = host->c_cc[VSWTC];
2305 #endif
2306
2307 #ifdef VSWTCH
2308 target.c_cc[LINUX_VSWTC] = host->c_cc[VSWTCH];
2309 #endif
2310
2311 emul_write_buffer(&target, addr, sizeof(target), processor, cia);
2312 }
2313 #endif /* HAVE_TERMIO_STRUCTURE */
2314
2315 #ifdef HAVE_TERMIOS_STRUCTURE
2316 /* Convert to/from host termios structure */
2317
2318 typedef uint32_t linux_tcflag_t;
2319 typedef uint8_t linux_cc_t;
2320 typedef uint32_t linux_speed_t;
2321
2322 struct linux_termios {
2323 linux_tcflag_t c_iflag;
2324 linux_tcflag_t c_oflag;
2325 linux_tcflag_t c_cflag;
2326 linux_tcflag_t c_lflag;
2327 linux_cc_t c_cc[LINUX_NCCS];
2328 linux_cc_t c_line;
2329 int32_t c_ispeed;
2330 int32_t c_ospeed;
2331 };
2332
2333 STATIC_INLINE_EMUL_UNIX void
2334 convert_to_linux_termios(unsigned_word addr,
2335 struct termios *host,
2336 cpu *processor,
2337 unsigned_word cia)
2338 {
2339 struct linux_termios target;
2340 int i;
2341
2342 target.c_iflag = H2T_4 (host->c_iflag);
2343 target.c_oflag = H2T_4 (host->c_oflag);
2344 target.c_cflag = H2T_4 (host->c_cflag);
2345 target.c_lflag = H2T_4 (host->c_lflag);
2346
2347 for (i = 0; i < LINUX_NCCS; i++)
2348 target.c_cc[i] = 0;
2349
2350 #ifdef VINTR
2351 target.c_cc[LINUX_VINTR] = host->c_cc[VINTR];
2352 #endif
2353
2354 #ifdef VQUIT
2355 target.c_cc[LINUX_VQUIT] = host->c_cc[VQUIT];
2356 #endif
2357
2358 #ifdef VERASE
2359 target.c_cc[LINUX_VERASE] = host->c_cc[VERASE];
2360 #endif
2361
2362 #ifdef VKILL
2363 target.c_cc[LINUX_VKILL] = host->c_cc[VKILL];
2364 #endif
2365
2366 #ifdef VEOF
2367 target.c_cc[LINUX_VEOF] = host->c_cc[VEOF];
2368 #endif
2369
2370 #ifdef VEOL
2371 target.c_cc[LINUX_VEOL] = host->c_cc[VEOL];
2372 #endif
2373
2374 #ifdef VEOL2
2375 target.c_cc[LINUX_VEOL2] = host->c_cc[VEOL2];
2376 #endif
2377
2378 #ifdef VSWTCH
2379 target.c_cc[LINUX_VSWTC] = host->c_cc[VSWTCH];
2380 #endif
2381
2382 #ifdef HAVE_TERMIOS_CLINE
2383 target.c_line = host->c_line;
2384 #else
2385 target.c_line = 0;
2386 #endif
2387
2388 #ifdef HAVE_CFGETISPEED
2389 target.c_ispeed = cfgetispeed (host);
2390 #else
2391 target.c_ispeed = 0;
2392 #endif
2393
2394 #ifdef HAVE_CFGETOSPEED
2395 target.c_ospeed = cfgetospeed (host);
2396 #else
2397 target.c_ospeed = 0;
2398 #endif
2399
2400 emul_write_buffer(&target, addr, sizeof(target), processor, cia);
2401 }
2402 #endif /* HAVE_TERMIOS_STRUCTURE */
2403
2404 #ifndef HAVE_IOCTL
2405 #define do_linux_ioctl 0
2406 #else
2407 static void
2408 do_linux_ioctl(os_emul_data *emul,
2409 unsigned call,
2410 const int arg0,
2411 cpu *processor,
2412 unsigned_word cia)
2413 {
2414 int fildes = cpu_registers(processor)->gpr[arg0];
2415 unsigned request = cpu_registers(processor)->gpr[arg0+1];
2416 unsigned_word argp_addr = cpu_registers(processor)->gpr[arg0+2];
2417 int status = 0;
2418 const char *name = "<unknown>";
2419
2420 #ifdef HAVE_TERMIOS_STRUCTURE
2421 struct termios host_termio;
2422
2423 #else
2424 #ifdef HAVE_TERMIO_STRUCTURE
2425 struct termio host_termio;
2426 #endif
2427 #endif
2428
2429 status = fdbad (fildes);
2430 if (status != 0)
2431 goto done;
2432
2433 switch (request)
2434 {
2435 case 0: /* make sure we have at least one case */
2436 default:
2437 status = -1;
2438 errno = EINVAL;
2439 break;
2440
2441 #if defined(HAVE_TERMIO_STRUCTURE) || defined(HAVE_TERMIOS_STRUCTURE)
2442 #if defined(TCGETA) || defined(TCGETS) || defined(HAVE_TCGETATTR)
2443 case LINUX_IOR('t', 23, struct linux_termio): /* TCGETA */
2444 name = "TCGETA";
2445 #ifdef HAVE_TCGETATTR
2446 status = tcgetattr(fildes, &host_termio);
2447 #elif defined(TCGETS)
2448 status = ioctl (fildes, TCGETS, &host_termio);
2449 #else
2450 status = ioctl (fildes, TCGETA, &host_termio);
2451 #endif
2452 if (status == 0)
2453 convert_to_linux_termio (argp_addr, &host_termio, processor, cia);
2454 break;
2455 #endif /* TCGETA */
2456 #endif /* HAVE_TERMIO_STRUCTURE */
2457
2458 #ifdef HAVE_TERMIOS_STRUCTURE
2459 #if defined(TCGETS) || defined(HAVE_TCGETATTR)
2460 case LINUX_IOR('t', 19, struct linux_termios): /* TCGETS */
2461 name = "TCGETS";
2462 #ifdef HAVE_TCGETATTR
2463 status = tcgetattr(fildes, &host_termio);
2464 #else
2465 status = ioctl (fildes, TCGETS, &host_termio);
2466 #endif
2467 if (status == 0)
2468 convert_to_linux_termios (argp_addr, &host_termio, processor, cia);
2469 break;
2470 #endif /* TCGETS */
2471 #endif /* HAVE_TERMIOS_STRUCTURE */
2472 }
2473
2474 done:
2475 emul_write_status(processor, status, errno);
2476
2477 if (WITH_TRACE && ppc_trace[trace_os_emul])
2478 printf_filtered ("%d, 0x%x [%s], 0x%lx", fildes, request, name, (long)argp_addr);
2479 }
2480 #endif /* HAVE_IOCTL */
2481
2482 static emul_syscall_descriptor linux_descriptors[] = {
2483 /* 0 */ { 0, "setup" },
2484 /* 1 */ { do_unix_exit, "exit" },
2485 /* 2 */ { 0, "fork" },
2486 /* 3 */ { do_unix_read, "read" },
2487 /* 4 */ { do_unix_write, "write" },
2488 /* 5 */ { do_unix_open, "open" },
2489 /* 6 */ { do_unix_close, "close" },
2490 /* 7 */ { 0, "waitpid" },
2491 /* 8 */ { 0, "creat" },
2492 /* 9 */ { do_unix_link, "link" },
2493 /* 10 */ { do_unix_unlink, "unlink" },
2494 /* 11 */ { 0, "execve" },
2495 /* 12 */ { do_unix_chdir, "chdir" },
2496 /* 13 */ { do_unix_time, "time" },
2497 /* 14 */ { 0, "mknod" },
2498 /* 15 */ { 0, "chmod" },
2499 /* 16 */ { 0, "chown" },
2500 /* 17 */ { 0, "break" },
2501 /* 18 */ { 0, "stat" },
2502 /* 19 */ { do_unix_lseek, "lseek" },
2503 /* 20 */ { do_unix_getpid, "getpid" },
2504 /* 21 */ { 0, "mount" },
2505 /* 22 */ { 0, "umount" },
2506 /* 23 */ { 0, "setuid" },
2507 /* 24 */ { do_unix_getuid, "getuid" },
2508 /* 25 */ { 0, "stime" },
2509 /* 26 */ { 0, "ptrace" },
2510 /* 27 */ { 0, "alarm" },
2511 /* 28 */ { 0, "fstat" },
2512 /* 29 */ { 0, "pause" },
2513 /* 30 */ { 0, "utime" },
2514 /* 31 */ { 0, "stty" },
2515 /* 32 */ { 0, "gtty" },
2516 /* 33 */ { do_unix_access, "access" },
2517 /* 34 */ { 0, "nice" },
2518 /* 35 */ { 0, "ftime" },
2519 /* 36 */ { 0, "sync" },
2520 /* 37 */ { 0, "kill" },
2521 /* 38 */ { 0, "rename" },
2522 /* 39 */ { do_unix_mkdir, "mkdir" },
2523 /* 40 */ { do_unix_rmdir, "rmdir" },
2524 /* 41 */ { do_unix_dup, "dup" },
2525 /* 42 */ { 0, "pipe" },
2526 /* 43 */ { 0, "times" },
2527 /* 44 */ { 0, "prof" },
2528 /* 45 */ { do_unix_break, "brk" },
2529 /* 46 */ { 0, "setgid" },
2530 /* 47 */ { do_unix_getgid, "getgid" },
2531 /* 48 */ { 0, "signal" },
2532 /* 49 */ { do_unix_geteuid, "geteuid" },
2533 /* 50 */ { do_unix_getegid, "getegid" },
2534 /* 51 */ { 0, "acct" },
2535 /* 52 */ { 0, "phys" },
2536 /* 53 */ { 0, "lock" },
2537 /* 54 */ { do_linux_ioctl, "ioctl" },
2538 /* 55 */ { 0, "fcntl" },
2539 /* 56 */ { 0, "mpx" },
2540 /* 57 */ { 0, "setpgid" },
2541 /* 58 */ { 0, "ulimit" },
2542 /* 59 */ { 0, "olduname" },
2543 /* 60 */ { do_unix_umask, "umask" },
2544 /* 61 */ { 0, "chroot" },
2545 /* 62 */ { 0, "ustat" },
2546 /* 63 */ { do_unix_dup2, "dup2" },
2547 /* 64 */ { do_unix_getppid, "getppid" },
2548 /* 65 */ { 0, "getpgrp" },
2549 /* 66 */ { 0, "setsid" },
2550 /* 67 */ { 0, "sigaction" },
2551 /* 68 */ { 0, "sgetmask" },
2552 /* 69 */ { 0, "ssetmask" },
2553 /* 70 */ { 0, "setreuid" },
2554 /* 71 */ { 0, "setregid" },
2555 /* 72 */ { 0, "sigsuspend" },
2556 /* 73 */ { 0, "sigpending" },
2557 /* 74 */ { 0, "sethostname" },
2558 /* 75 */ { 0, "setrlimit" },
2559 /* 76 */ { 0, "getrlimit" },
2560 /* 77 */ { do_unix_getrusage, "getrusage" },
2561 /* 78 */ { do_unix_gettimeofday, "gettimeofday" },
2562 /* 79 */ { 0, "settimeofday" },
2563 /* 80 */ { 0, "getgroups" },
2564 /* 81 */ { 0, "setgroups" },
2565 /* 82 */ { 0, "select" },
2566 /* 83 */ { do_unix_symlink, "symlink" },
2567 /* 84 */ { 0, "lstat" },
2568 /* 85 */ { 0, "readlink" },
2569 /* 86 */ { 0, "uselib" },
2570 /* 87 */ { 0, "swapon" },
2571 /* 88 */ { 0, "reboot" },
2572 /* 89 */ { 0, "readdir" },
2573 /* 90 */ { 0, "mmap" },
2574 /* 91 */ { 0, "munmap" },
2575 /* 92 */ { 0, "truncate" },
2576 /* 93 */ { 0, "ftruncate" },
2577 /* 94 */ { 0, "fchmod" },
2578 /* 95 */ { 0, "fchown" },
2579 /* 96 */ { 0, "getpriority" },
2580 /* 97 */ { 0, "setpriority" },
2581 /* 98 */ { 0, "profil" },
2582 /* 99 */ { 0, "statfs" },
2583 /* 100 */ { 0, "fstatfs" },
2584 /* 101 */ { 0, "ioperm" },
2585 /* 102 */ { 0, "socketcall" },
2586 /* 103 */ { 0, "syslog" },
2587 /* 104 */ { 0, "setitimer" },
2588 /* 105 */ { 0, "getitimer" },
2589 /* 106 */ { do_linux_stat, "newstat" },
2590 /* 107 */ { do_linux_lstat, "newlstat" },
2591 /* 108 */ { do_linux_fstat, "newfstat" },
2592 /* 109 */ { 0, "uname" },
2593 /* 110 */ { 0, "iopl" },
2594 /* 111 */ { 0, "vhangup" },
2595 /* 112 */ { 0, "idle" },
2596 /* 113 */ { 0, "vm86" },
2597 /* 114 */ { 0, "wait4" },
2598 /* 115 */ { 0, "swapoff" },
2599 /* 116 */ { 0, "sysinfo" },
2600 /* 117 */ { 0, "ipc" },
2601 /* 118 */ { 0, "fsync" },
2602 /* 119 */ { 0, "sigreturn" },
2603 /* 120 */ { 0, "clone" },
2604 /* 121 */ { 0, "setdomainname" },
2605 /* 122 */ { 0, "newuname" },
2606 /* 123 */ { 0, "modify_ldt" },
2607 /* 124 */ { 0, "adjtimex" },
2608 /* 125 */ { 0, "mprotect" },
2609 /* 126 */ { 0, "sigprocmask" },
2610 /* 127 */ { 0, "create_module" },
2611 /* 128 */ { 0, "init_module" },
2612 /* 129 */ { 0, "delete_module" },
2613 /* 130 */ { 0, "get_kernel_syms" },
2614 /* 131 */ { 0, "quotactl" },
2615 /* 132 */ { 0, "getpgid" },
2616 /* 133 */ { 0, "fchdir" },
2617 /* 134 */ { 0, "bdflush" },
2618 /* 135 */ { 0, "sysfs" },
2619 /* 136 */ { 0, "personality" },
2620 /* 137 */ { 0, "afs_syscall" },
2621 /* 138 */ { 0, "setfsuid" },
2622 /* 139 */ { 0, "setfsgid" },
2623 /* 140 */ { 0, "llseek" },
2624 /* 141 */ { 0, "getdents" },
2625 /* 142 */ { 0, "newselect" },
2626 /* 143 */ { 0, "flock" },
2627 /* 144 */ { 0, "msync" },
2628 /* 145 */ { 0, "readv" },
2629 /* 146 */ { 0, "writev" },
2630 /* 147 */ { 0, "getsid" },
2631 /* 148 */ { 0, "fdatasync" },
2632 /* 149 */ { 0, "sysctl" },
2633 /* 150 */ { 0, "mlock" },
2634 /* 151 */ { 0, "munlock" },
2635 /* 152 */ { 0, "mlockall" },
2636 /* 153 */ { 0, "munlockall" },
2637 /* 154 */ { 0, "sched_setparam" },
2638 /* 155 */ { 0, "sched_getparam" },
2639 /* 156 */ { 0, "sched_setscheduler" },
2640 /* 157 */ { 0, "sched_getscheduler" },
2641 /* 158 */ { 0, "sched_yield" },
2642 /* 159 */ { 0, "sched_get_priority_max" },
2643 /* 160 */ { 0, "sched_get_priority_min" },
2644 /* 161 */ { 0, "sched_rr_get_interval" },
2645 };
2646
2647 static char *(linux_error_names[]) = {
2648 /* 0 */ "ESUCCESS",
2649 /* 1 */ "EPERM",
2650 /* 2 */ "ENOENT",
2651 /* 3 */ "ESRCH",
2652 /* 4 */ "EINTR",
2653 /* 5 */ "EIO",
2654 /* 6 */ "ENXIO",
2655 /* 7 */ "E2BIG",
2656 /* 8 */ "ENOEXEC",
2657 /* 9 */ "EBADF",
2658 /* 10 */ "ECHILD",
2659 /* 11 */ "EAGAIN",
2660 /* 12 */ "ENOMEM",
2661 /* 13 */ "EACCES",
2662 /* 14 */ "EFAULT",
2663 /* 15 */ "ENOTBLK",
2664 /* 16 */ "EBUSY",
2665 /* 17 */ "EEXIST",
2666 /* 18 */ "EXDEV",
2667 /* 19 */ "ENODEV",
2668 /* 20 */ "ENOTDIR",
2669 /* 21 */ "EISDIR",
2670 /* 22 */ "EINVAL",
2671 /* 23 */ "ENFILE",
2672 /* 24 */ "EMFILE",
2673 /* 25 */ "ENOTTY",
2674 /* 26 */ "ETXTBSY",
2675 /* 27 */ "EFBIG",
2676 /* 28 */ "ENOSPC",
2677 /* 29 */ "ESPIPE",
2678 /* 30 */ "EROFS",
2679 /* 31 */ "EMLINK",
2680 /* 32 */ "EPIPE",
2681 /* 33 */ "EDOM",
2682 /* 34 */ "ERANGE",
2683 /* 35 */ "EDEADLK",
2684 /* 36 */ "ENAMETOOLONG",
2685 /* 37 */ "ENOLCK",
2686 /* 38 */ "ENOSYS",
2687 /* 39 */ "ENOTEMPTY",
2688 /* 40 */ "ELOOP",
2689 /* 41 */ 0,
2690 /* 42 */ "ENOMSG",
2691 /* 43 */ "EIDRM",
2692 /* 44 */ "ECHRNG",
2693 /* 45 */ "EL2NSYNC",
2694 /* 46 */ "EL3HLT",
2695 /* 47 */ "EL3RST",
2696 /* 48 */ "ELNRNG",
2697 /* 49 */ "EUNATCH",
2698 /* 50 */ "ENOCSI",
2699 /* 51 */ "EL2HLT",
2700 /* 52 */ "EBADE",
2701 /* 53 */ "EBADR",
2702 /* 54 */ "EXFULL",
2703 /* 55 */ "ENOANO",
2704 /* 56 */ "EBADRQC",
2705 /* 57 */ "EBADSLT",
2706 /* 58 */ "EDEADLOCK",
2707 /* 59 */ "EBFONT",
2708 /* 60 */ "ENOSTR",
2709 /* 61 */ "ENODATA",
2710 /* 62 */ "ETIME",
2711 /* 63 */ "ENOSR",
2712 /* 64 */ "ENONET",
2713 /* 65 */ "ENOPKG",
2714 /* 66 */ "EREMOTE",
2715 /* 67 */ "ENOLINK",
2716 /* 68 */ "EADV",
2717 /* 69 */ "ESRMNT",
2718 /* 70 */ "ECOMM",
2719 /* 71 */ "EPROTO",
2720 /* 72 */ "EMULTIHOP",
2721 /* 73 */ "EDOTDOT",
2722 /* 74 */ "EBADMSG",
2723 /* 75 */ "EOVERFLOW",
2724 /* 76 */ "ENOTUNIQ",
2725 /* 77 */ "EBADFD",
2726 /* 78 */ "EREMCHG",
2727 /* 79 */ "ELIBACC",
2728 /* 80 */ "ELIBBAD",
2729 /* 81 */ "ELIBSCN",
2730 /* 82 */ "ELIBMAX",
2731 /* 83 */ "ELIBEXEC",
2732 /* 84 */ "EILSEQ",
2733 /* 85 */ "ERESTART",
2734 /* 86 */ "ESTRPIPE",
2735 /* 87 */ "EUSERS",
2736 /* 88 */ "ENOTSOCK",
2737 /* 89 */ "EDESTADDRREQ",
2738 /* 90 */ "EMSGSIZE",
2739 /* 91 */ "EPROTOTYPE",
2740 /* 92 */ "ENOPROTOOPT",
2741 /* 93 */ "EPROTONOSUPPORT",
2742 /* 94 */ "ESOCKTNOSUPPORT",
2743 /* 95 */ "EOPNOTSUPP",
2744 /* 96 */ "EPFNOSUPPORT",
2745 /* 97 */ "EAFNOSUPPORT",
2746 /* 98 */ "EADDRINUSE",
2747 /* 99 */ "EADDRNOTAVAIL",
2748 /* 100 */ "ENETDOWN",
2749 /* 101 */ "ENETUNREACH",
2750 /* 102 */ "ENETRESET",
2751 /* 103 */ "ECONNABORTED",
2752 /* 104 */ "ECONNRESET",
2753 /* 105 */ "ENOBUFS",
2754 /* 106 */ "EISCONN",
2755 /* 107 */ "ENOTCONN",
2756 /* 108 */ "ESHUTDOWN",
2757 /* 109 */ "ETOOMANYREFS",
2758 /* 110 */ "ETIMEDOUT",
2759 /* 111 */ "ECONNREFUSED",
2760 /* 112 */ "EHOSTDOWN",
2761 /* 113 */ "EHOSTUNREACH",
2762 /* 114 */ "EALREADY",
2763 /* 115 */ "EINPROGRESS",
2764 /* 116 */ "ESTALE",
2765 /* 117 */ "EUCLEAN",
2766 /* 118 */ "ENOTNAM",
2767 /* 119 */ "ENAVAIL",
2768 /* 120 */ "EISNAM",
2769 /* 121 */ "EREMOTEIO",
2770 /* 122 */ "EDQUOT",
2771 };
2772
2773 static char *(linux_signal_names[]) = {
2774 /* 0 */ 0,
2775 /* 1 */ "SIGHUP",
2776 /* 2 */ "SIGINT",
2777 /* 3 */ "SIGQUIT",
2778 /* 4 */ "SIGILL",
2779 /* 5 */ "SIGTRAP",
2780 /* 6 */ "SIGABRT",
2781 /* 6 */ "SIGIOT",
2782 /* 7 */ "SIGBUS",
2783 /* 8 */ "SIGFPE",
2784 /* 9 */ "SIGKILL",
2785 /* 10 */ "SIGUSR1",
2786 /* 11 */ "SIGSEGV",
2787 /* 12 */ "SIGUSR2",
2788 /* 13 */ "SIGPIPE",
2789 /* 14 */ "SIGALRM",
2790 /* 15 */ "SIGTERM",
2791 /* 16 */ "SIGSTKFLT",
2792 /* 17 */ "SIGCHLD",
2793 /* 18 */ "SIGCONT",
2794 /* 19 */ "SIGSTOP",
2795 /* 20 */ "SIGTSTP",
2796 /* 21 */ "SIGTTIN",
2797 /* 22 */ "SIGTTOU",
2798 /* 23 */ "SIGURG",
2799 /* 24 */ "SIGXCPU",
2800 /* 25 */ "SIGXFSZ",
2801 /* 26 */ "SIGVTALRM",
2802 /* 27 */ "SIGPROF",
2803 /* 28 */ "SIGWINCH",
2804 /* 29 */ "SIGIO",
2805 /* 30 */ "SIGPWR",
2806 /* 31 */ "SIGUNUSED",
2807 };
2808
2809 static emul_syscall emul_linux_syscalls = {
2810 linux_descriptors,
2811 ARRAY_SIZE (linux_descriptors),
2812 linux_error_names,
2813 ARRAY_SIZE (linux_error_names),
2814 linux_signal_names,
2815 ARRAY_SIZE (linux_signal_names),
2816 };
2817
2818
2819 /* Linux's os_emul interface, most are just passed on to the generic
2820 syscall stuff */
2821
2822 static os_emul_data *
2823 emul_linux_create(device *root,
2824 bfd *image,
2825 const char *name)
2826 {
2827 /* check that this emulation is really for us */
2828 if (name != NULL && strcmp(name, "linux") != 0)
2829 return NULL;
2830
2831 if (image == NULL)
2832 return NULL;
2833
2834 return emul_unix_create(root, image, "linux", &emul_linux_syscalls);
2835 }
2836
2837 static void
2838 emul_linux_init(os_emul_data *emul_data,
2839 int nr_cpus)
2840 {
2841 fd_closed[0] = 0;
2842 fd_closed[1] = 0;
2843 fd_closed[2] = 0;
2844 }
2845
2846 static void
2847 emul_linux_system_call(cpu *processor,
2848 unsigned_word cia,
2849 os_emul_data *emul_data)
2850 {
2851 emul_do_system_call(emul_data,
2852 emul_data->syscalls,
2853 cpu_registers(processor)->gpr[0],
2854 3, /*r3 contains arg0*/
2855 processor,
2856 cia);
2857 }
2858
2859 const os_emul emul_linux = {
2860 "linux",
2861 emul_linux_create,
2862 emul_linux_init,
2863 emul_linux_system_call,
2864 0, /*instruction_call*/
2865 0 /*data*/
2866 };
2867
2868 #endif /* _EMUL_UNIX_C_ */
The GNU Binutils are a collection of binary tools.