Assume GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
[emacs.git] / src / sysdep.c
blob836cc271b113071c70b7d56888c72d9a0a73520d
1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2015 Free Software
3 Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
22 /* If HYBRID_GET_CURRENT_DIR_NAME is defined in conf_post.h, then we
23 need the following before including unistd.h, in order to pick up
24 the right prototype for gget_current_dir_name. */
25 #ifdef HYBRID_GET_CURRENT_DIR_NAME
26 #undef get_current_dir_name
27 #define get_current_dir_name gget_current_dir_name
28 #endif
30 #include <execinfo.h>
31 #include "sysstdio.h"
32 #ifdef HAVE_PWD_H
33 #include <pwd.h>
34 #include <grp.h>
35 #endif /* HAVE_PWD_H */
36 #include <limits.h>
37 #include <unistd.h>
39 #include <c-ctype.h>
40 #include <utimens.h>
42 #include "lisp.h"
43 #include "sysselect.h"
44 #include "blockinput.h"
46 #if defined DARWIN_OS || defined __FreeBSD__
47 # include <sys/sysctl.h>
48 #endif
50 #ifdef __FreeBSD__
51 /* Sparc/ARM machine/frame.h has 'struct frame' which conflicts with Emacs's
52 'struct frame', so rename it. */
53 # define frame freebsd_frame
54 # include <sys/user.h>
55 # undef frame
57 # include <math.h>
58 #endif
60 #ifdef WINDOWSNT
61 #define read sys_read
62 #define write sys_write
63 #ifndef STDERR_FILENO
64 #define STDERR_FILENO fileno(GetStdHandle(STD_ERROR_HANDLE))
65 #endif
66 #include <windows.h>
67 #endif /* not WINDOWSNT */
69 #include <sys/types.h>
70 #include <sys/stat.h>
71 #include <errno.h>
73 /* Get SI_SRPC_DOMAIN, if it is available. */
74 #ifdef HAVE_SYS_SYSTEMINFO_H
75 #include <sys/systeminfo.h>
76 #endif
78 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
79 #include "msdos.h"
80 #endif
82 #include <sys/param.h>
83 #include <sys/file.h>
84 #include <fcntl.h>
86 #include "systty.h"
87 #include "syswait.h"
89 #ifdef HAVE_SYS_UTSNAME_H
90 #include <sys/utsname.h>
91 #include <memory.h>
92 #endif /* HAVE_SYS_UTSNAME_H */
94 #include "keyboard.h"
95 #include "frame.h"
96 #include "window.h"
97 #include "termhooks.h"
98 #include "termchar.h"
99 #include "termopts.h"
100 #include "dispextern.h"
101 #include "process.h"
102 #include "cm.h" /* for reset_sys_modes */
104 #ifdef WINDOWSNT
105 #include <direct.h>
106 /* In process.h which conflicts with the local copy. */
107 #define _P_WAIT 0
108 int _cdecl _spawnlp (int, const char *, const char *, ...);
109 int _cdecl _getpid (void);
110 /* The following is needed for O_CLOEXEC, F_SETFD, FD_CLOEXEC, and
111 several prototypes of functions called below. */
112 #include <sys/socket.h>
113 #endif
115 #include "syssignal.h"
116 #include "systime.h"
118 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
119 #ifndef ULLONG_MAX
120 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
121 #endif
123 /* Declare here, including term.h is problematic on some systems. */
124 extern void tputs (const char *, int, int (*)(int));
126 static const int baud_convert[] =
128 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
129 1800, 2400, 4800, 9600, 19200, 38400
132 #if !defined HAVE_GET_CURRENT_DIR_NAME || defined BROKEN_GET_CURRENT_DIR_NAME \
133 || (defined HYBRID_GET_CURRENT_DIR_NAME)
134 /* Return the current working directory. Returns NULL on errors.
135 Any other returned value must be freed with free. This is used
136 only when get_current_dir_name is not defined on the system. */
137 char *
138 get_current_dir_name (void)
140 char *buf;
141 char *pwd = getenv ("PWD");
142 struct stat dotstat, pwdstat;
143 /* If PWD is accurate, use it instead of calling getcwd. PWD is
144 sometimes a nicer name, and using it may avoid a fatal error if a
145 parent directory is searchable but not readable. */
146 if (pwd
147 && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
148 && stat (pwd, &pwdstat) == 0
149 && stat (".", &dotstat) == 0
150 && dotstat.st_ino == pwdstat.st_ino
151 && dotstat.st_dev == pwdstat.st_dev
152 #ifdef MAXPATHLEN
153 && strlen (pwd) < MAXPATHLEN
154 #endif
157 buf = malloc (strlen (pwd) + 1);
158 if (!buf)
159 return NULL;
160 strcpy (buf, pwd);
162 else
164 size_t buf_size = 1024;
165 buf = malloc (buf_size);
166 if (!buf)
167 return NULL;
168 for (;;)
170 if (getcwd (buf, buf_size) == buf)
171 break;
172 if (errno != ERANGE)
174 int tmp_errno = errno;
175 free (buf);
176 errno = tmp_errno;
177 return NULL;
179 buf_size *= 2;
180 buf = realloc (buf, buf_size);
181 if (!buf)
182 return NULL;
185 return buf;
187 #endif
190 /* Discard pending input on all input descriptors. */
192 void
193 discard_tty_input (void)
195 #ifndef WINDOWSNT
196 struct emacs_tty buf;
198 if (noninteractive)
199 return;
201 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
202 while (dos_keyread () != -1)
204 #else /* not MSDOS */
206 struct tty_display_info *tty;
207 for (tty = tty_list; tty; tty = tty->next)
209 if (tty->input) /* Is the device suspended? */
211 emacs_get_tty (fileno (tty->input), &buf);
212 emacs_set_tty (fileno (tty->input), &buf, 0);
216 #endif /* not MSDOS */
217 #endif /* not WINDOWSNT */
221 #ifdef SIGTSTP
223 /* Arrange for character C to be read as the next input from
224 the terminal.
225 XXX What if we have multiple ttys?
228 void
229 stuff_char (char c)
231 if (! (FRAMEP (selected_frame)
232 && FRAME_LIVE_P (XFRAME (selected_frame))
233 && FRAME_TERMCAP_P (XFRAME (selected_frame))))
234 return;
236 /* Should perhaps error if in batch mode */
237 #ifdef TIOCSTI
238 ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
239 #else /* no TIOCSTI */
240 error ("Cannot stuff terminal input characters in this version of Unix");
241 #endif /* no TIOCSTI */
244 #endif /* SIGTSTP */
246 void
247 init_baud_rate (int fd)
249 int emacs_ospeed;
251 if (noninteractive)
252 emacs_ospeed = 0;
253 else
255 #ifdef DOS_NT
256 emacs_ospeed = 15;
257 #else /* not DOS_NT */
258 struct termios sg;
260 sg.c_cflag = B9600;
261 tcgetattr (fd, &sg);
262 emacs_ospeed = cfgetospeed (&sg);
263 #endif /* not DOS_NT */
266 baud_rate = (emacs_ospeed < ARRAYELTS (baud_convert)
267 ? baud_convert[emacs_ospeed] : 9600);
268 if (baud_rate == 0)
269 baud_rate = 1200;
274 #ifndef MSDOS
276 /* Wait for the subprocess with process id CHILD to terminate or change status.
277 CHILD must be a child process that has not been reaped.
278 If STATUS is non-null, store the waitpid-style exit status into *STATUS
279 and tell wait_reading_process_output that it needs to look around.
280 Use waitpid-style OPTIONS when waiting.
281 If INTERRUPTIBLE, this function is interruptible by a signal.
283 Return CHILD if successful, 0 if no status is available;
284 the latter is possible only when options & NOHANG. */
285 static pid_t
286 get_child_status (pid_t child, int *status, int options, bool interruptible)
288 pid_t pid;
290 /* Invoke waitpid only with a known process ID; do not invoke
291 waitpid with a nonpositive argument. Otherwise, Emacs might
292 reap an unwanted process by mistake. For example, invoking
293 waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
294 so that another thread running glib won't find them. */
295 eassert (child > 0);
297 while ((pid = waitpid (child, status, options)) < 0)
299 /* Check that CHILD is a child process that has not been reaped,
300 and that STATUS and OPTIONS are valid. Otherwise abort,
301 as continuing after this internal error could cause Emacs to
302 become confused and kill innocent-victim processes. */
303 if (errno != EINTR)
304 emacs_abort ();
306 /* Note: the MS-Windows emulation of waitpid calls QUIT
307 internally. */
308 if (interruptible)
309 QUIT;
312 /* If successful and status is requested, tell wait_reading_process_output
313 that it needs to wake up and look around. */
314 if (pid && status && input_available_clear_time)
315 *input_available_clear_time = make_timespec (0, 0);
317 return pid;
320 /* Wait for the subprocess with process id CHILD to terminate.
321 CHILD must be a child process that has not been reaped.
322 If STATUS is non-null, store the waitpid-style exit status into *STATUS
323 and tell wait_reading_process_output that it needs to look around.
324 If INTERRUPTIBLE, this function is interruptible by a signal. */
325 void
326 wait_for_termination (pid_t child, int *status, bool interruptible)
328 get_child_status (child, status, 0, interruptible);
331 /* Report whether the subprocess with process id CHILD has changed status.
332 Termination counts as a change of status.
333 CHILD must be a child process that has not been reaped.
334 If STATUS is non-null, store the waitpid-style exit status into *STATUS
335 and tell wait_reading_process_output that it needs to look around.
336 Use waitpid-style OPTIONS to check status, but do not wait.
338 Return CHILD if successful, 0 if no status is available because
339 the process's state has not changed. */
340 pid_t
341 child_status_changed (pid_t child, int *status, int options)
343 return get_child_status (child, status, WNOHANG | options, 0);
347 /* Set up the terminal at the other end of a pseudo-terminal that
348 we will be controlling an inferior through.
349 It should not echo or do line-editing, since that is done
350 in Emacs. No padding needed for insertion into an Emacs buffer. */
352 void
353 child_setup_tty (int out)
355 #ifndef WINDOWSNT
356 struct emacs_tty s;
358 emacs_get_tty (out, &s);
359 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
360 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
361 #ifdef NLDLY
362 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
363 Some versions of GNU Hurd do not have FFDLY? */
364 #ifdef FFDLY
365 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
366 /* No output delays */
367 #else
368 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY);
369 /* No output delays */
370 #endif
371 #endif
372 s.main.c_lflag &= ~ECHO; /* Disable echo */
373 s.main.c_lflag |= ISIG; /* Enable signals */
374 #ifdef IUCLC
375 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
376 #endif
377 #ifdef ISTRIP
378 s.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
379 #endif
380 #ifdef OLCUC
381 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
382 #endif
383 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
384 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
385 s.main.c_cc[VERASE] = CDISABLE; /* disable erase processing */
386 s.main.c_cc[VKILL] = CDISABLE; /* disable kill processing */
388 #ifdef HPUX
389 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
390 #endif /* HPUX */
392 #ifdef SIGNALS_VIA_CHARACTERS
393 /* the QUIT and INTR character are used in process_send_signal
394 so set them here to something useful. */
395 if (s.main.c_cc[VQUIT] == CDISABLE)
396 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
397 if (s.main.c_cc[VINTR] == CDISABLE)
398 s.main.c_cc[VINTR] = 'C'&037; /* Control-C */
399 #endif /* not SIGNALS_VIA_CHARACTERS */
401 #ifdef AIX
402 /* Also, PTY overloads NUL and BREAK.
403 don't ignore break, but don't signal either, so it looks like NUL. */
404 s.main.c_iflag &= ~IGNBRK;
405 s.main.c_iflag &= ~BRKINT;
406 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
407 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
408 would force it to 0377. That looks like duplicated code. */
409 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
410 #endif /* AIX */
412 /* We originally enabled ICANON (and set VEOF to 04), and then had
413 process.c send additional EOF chars to flush the output when faced
414 with long lines, but this leads to weird effects when the
415 subprocess has disabled ICANON and ends up seeing those spurious
416 extra EOFs. So we don't send EOFs any more in
417 process.c:send_process. First we tried to disable ICANON by
418 default, so if a subsprocess sets up ICANON, it's his problem (or
419 the Elisp package that talks to it) to deal with lines that are
420 too long. But this disables some features, such as the ability
421 to send EOF signals. So we re-enabled ICANON but there is no
422 more "send eof to flush" going on (which is wrong and unportable
423 in itself). The correct way to handle too much output is to
424 buffer what could not be written and then write it again when
425 select returns ok for writing. This has it own set of
426 problems. Write is now asynchronous, is that a problem? How much
427 do we buffer, and what do we do when that limit is reached? */
429 s.main.c_lflag |= ICANON; /* Enable line editing and eof processing */
430 s.main.c_cc[VEOF] = 'D'&037; /* Control-D */
431 #if 0 /* These settings only apply to non-ICANON mode. */
432 s.main.c_cc[VMIN] = 1;
433 s.main.c_cc[VTIME] = 0;
434 #endif
436 emacs_set_tty (out, &s, 0);
437 #endif /* not WINDOWSNT */
439 #endif /* not MSDOS */
442 /* Record a signal code and the action for it. */
443 struct save_signal
445 int code;
446 struct sigaction action;
449 static void save_signal_handlers (struct save_signal *);
450 static void restore_signal_handlers (struct save_signal *);
452 /* Suspend the Emacs process; give terminal to its superior. */
454 void
455 sys_suspend (void)
457 #ifndef DOS_NT
458 kill (0, SIGTSTP);
459 #else
460 /* On a system where suspending is not implemented,
461 instead fork a subshell and let it talk directly to the terminal
462 while we wait. */
463 sys_subshell ();
465 #endif
468 /* Fork a subshell. */
470 void
471 sys_subshell (void)
473 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
474 int st;
475 #ifdef MSDOS
476 char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS. */
477 #else
478 char oldwd[MAX_UTF8_PATH];
479 #endif
480 #endif
481 pid_t pid;
482 int status;
483 struct save_signal saved_handlers[5];
484 char *str = SSDATA (encode_current_directory ());
486 #ifdef DOS_NT
487 pid = 0;
488 #else
490 char *volatile str_volatile = str;
491 pid = vfork ();
492 str = str_volatile;
494 #endif
496 if (pid < 0)
497 error ("Can't spawn subshell");
499 saved_handlers[0].code = SIGINT;
500 saved_handlers[1].code = SIGQUIT;
501 saved_handlers[2].code = SIGTERM;
502 #ifdef USABLE_SIGIO
503 saved_handlers[3].code = SIGIO;
504 saved_handlers[4].code = 0;
505 #else
506 saved_handlers[3].code = 0;
507 #endif
509 #ifdef DOS_NT
510 save_signal_handlers (saved_handlers);
511 #endif
513 if (pid == 0)
515 const char *sh = 0;
517 #ifdef DOS_NT /* MW, Aug 1993 */
518 getcwd (oldwd, sizeof oldwd);
519 if (sh == 0)
520 sh = egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
521 #endif
522 if (sh == 0)
523 sh = egetenv ("SHELL");
524 if (sh == 0)
525 sh = "sh";
527 /* Use our buffer's default directory for the subshell. */
528 if (chdir (str) != 0)
530 #ifndef DOS_NT
531 emacs_perror (str);
532 _exit (EXIT_CANCELED);
533 #endif
536 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
538 char *epwd = getenv ("PWD");
539 char old_pwd[MAXPATHLEN+1+4];
541 /* If PWD is set, pass it with corrected value. */
542 if (epwd)
544 strcpy (old_pwd, epwd);
545 setenv ("PWD", str, 1);
547 st = system (sh);
548 chdir (oldwd); /* FIXME: Do the right thing on chdir failure. */
549 if (epwd)
550 putenv (old_pwd); /* restore previous value */
552 #else /* not MSDOS */
553 #ifdef WINDOWSNT
554 /* Waits for process completion */
555 pid = _spawnlp (_P_WAIT, sh, sh, NULL);
556 chdir (oldwd); /* FIXME: Do the right thing on chdir failure. */
557 if (pid == -1)
558 write (1, "Can't execute subshell", 22);
559 #else /* not WINDOWSNT */
560 execlp (sh, sh, (char *) 0);
561 emacs_perror (sh);
562 _exit (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
563 #endif /* not WINDOWSNT */
564 #endif /* not MSDOS */
567 /* Do this now if we did not do it before. */
568 #ifndef MSDOS
569 save_signal_handlers (saved_handlers);
570 #endif
572 #ifndef DOS_NT
573 wait_for_termination (pid, &status, 0);
574 #endif
575 restore_signal_handlers (saved_handlers);
578 static void
579 save_signal_handlers (struct save_signal *saved_handlers)
581 while (saved_handlers->code)
583 struct sigaction action;
584 emacs_sigaction_init (&action, SIG_IGN);
585 sigaction (saved_handlers->code, &action, &saved_handlers->action);
586 saved_handlers++;
590 static void
591 restore_signal_handlers (struct save_signal *saved_handlers)
593 while (saved_handlers->code)
595 sigaction (saved_handlers->code, &saved_handlers->action, 0);
596 saved_handlers++;
600 #ifdef USABLE_SIGIO
601 static int old_fcntl_flags[FD_SETSIZE];
602 #endif
604 void
605 init_sigio (int fd)
607 #ifdef USABLE_SIGIO
608 old_fcntl_flags[fd] = fcntl (fd, F_GETFL, 0) & ~FASYNC;
609 fcntl (fd, F_SETFL, old_fcntl_flags[fd] | FASYNC);
610 interrupts_deferred = 0;
611 #endif
614 #ifndef DOS_NT
615 static void
616 reset_sigio (int fd)
618 #ifdef USABLE_SIGIO
619 fcntl (fd, F_SETFL, old_fcntl_flags[fd]);
620 #endif
622 #endif
624 void
625 request_sigio (void)
627 #ifdef USABLE_SIGIO
628 sigset_t unblocked;
630 if (noninteractive)
631 return;
633 sigemptyset (&unblocked);
634 # ifdef SIGWINCH
635 sigaddset (&unblocked, SIGWINCH);
636 # endif
637 sigaddset (&unblocked, SIGIO);
638 pthread_sigmask (SIG_UNBLOCK, &unblocked, 0);
640 interrupts_deferred = 0;
641 #endif
644 void
645 unrequest_sigio (void)
647 #ifdef USABLE_SIGIO
648 sigset_t blocked;
650 if (noninteractive)
651 return;
653 sigemptyset (&blocked);
654 # ifdef SIGWINCH
655 sigaddset (&blocked, SIGWINCH);
656 # endif
657 sigaddset (&blocked, SIGIO);
658 pthread_sigmask (SIG_BLOCK, &blocked, 0);
659 interrupts_deferred = 1;
660 #endif
663 #ifndef MSDOS
664 /* Block SIGCHLD. */
666 void
667 block_child_signal (sigset_t *oldset)
669 sigset_t blocked;
670 sigemptyset (&blocked);
671 sigaddset (&blocked, SIGCHLD);
672 sigaddset (&blocked, SIGINT);
673 pthread_sigmask (SIG_BLOCK, &blocked, oldset);
676 /* Unblock SIGCHLD. */
678 void
679 unblock_child_signal (sigset_t const *oldset)
681 pthread_sigmask (SIG_SETMASK, oldset, 0);
684 #endif /* !MSDOS */
686 /* Saving and restoring the process group of Emacs's terminal. */
688 /* The process group of which Emacs was a member when it initially
689 started.
691 If Emacs was in its own process group (i.e. inherited_pgroup ==
692 getpid ()), then we know we're running under a shell with job
693 control (Emacs would never be run as part of a pipeline).
694 Everything is fine.
696 If Emacs was not in its own process group, then we know we're
697 running under a shell (or a caller) that doesn't know how to
698 separate itself from Emacs (like sh). Emacs must be in its own
699 process group in order to receive SIGIO correctly. In this
700 situation, we put ourselves in our own pgroup, forcibly set the
701 tty's pgroup to our pgroup, and make sure to restore and reinstate
702 the tty's pgroup just like any other terminal setting. If
703 inherited_group was not the tty's pgroup, then we'll get a
704 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
705 it goes foreground in the future, which is what should happen. */
707 static pid_t inherited_pgroup;
709 void
710 init_foreground_group (void)
712 pid_t pgrp = getpgrp ();
713 inherited_pgroup = getpid () == pgrp ? 0 : pgrp;
716 /* Block and unblock SIGTTOU. */
718 void
719 block_tty_out_signal (sigset_t *oldset)
721 #ifdef SIGTTOU
722 sigset_t blocked;
723 sigemptyset (&blocked);
724 sigaddset (&blocked, SIGTTOU);
725 pthread_sigmask (SIG_BLOCK, &blocked, oldset);
726 #endif
729 void
730 unblock_tty_out_signal (sigset_t const *oldset)
732 #ifdef SIGTTOU
733 pthread_sigmask (SIG_SETMASK, oldset, 0);
734 #endif
737 /* Safely set a controlling terminal FD's process group to PGID.
738 If we are not in the foreground already, POSIX requires tcsetpgrp
739 to deliver a SIGTTOU signal, which would stop us. This is an
740 annoyance, so temporarily ignore the signal.
742 In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
743 skip all this unless SIGTTOU is defined. */
744 static void
745 tcsetpgrp_without_stopping (int fd, pid_t pgid)
747 #ifdef SIGTTOU
748 sigset_t oldset;
749 block_input ();
750 block_tty_out_signal (&oldset);
751 tcsetpgrp (fd, pgid);
752 unblock_tty_out_signal (&oldset);
753 unblock_input ();
754 #endif
757 /* Split off the foreground process group to Emacs alone. When we are
758 in the foreground, but not started in our own process group,
759 redirect the tty device handle FD to point to our own process
760 group. FD must be the file descriptor of the controlling tty. */
761 static void
762 narrow_foreground_group (int fd)
764 if (inherited_pgroup && setpgid (0, 0) == 0)
765 tcsetpgrp_without_stopping (fd, getpid ());
768 /* Set the tty to our original foreground group. */
769 static void
770 widen_foreground_group (int fd)
772 if (inherited_pgroup && setpgid (0, inherited_pgroup) == 0)
773 tcsetpgrp_without_stopping (fd, inherited_pgroup);
776 /* Getting and setting emacs_tty structures. */
778 /* Set *TC to the parameters associated with the terminal FD,
779 or clear it if the parameters are not available.
780 Return 0 on success, -1 on failure. */
782 emacs_get_tty (int fd, struct emacs_tty *settings)
784 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
785 memset (&settings->main, 0, sizeof (settings->main));
786 #ifdef DOS_NT
787 #ifdef WINDOWSNT
788 HANDLE h = (HANDLE)_get_osfhandle (fd);
789 DWORD console_mode;
791 if (h && h != INVALID_HANDLE_VALUE && GetConsoleMode (h, &console_mode))
793 settings->main = console_mode;
794 return 0;
796 #endif /* WINDOWSNT */
797 return -1;
798 #else /* !DOS_NT */
799 /* We have those nifty POSIX tcmumbleattr functions. */
800 return tcgetattr (fd, &settings->main);
801 #endif
805 /* Set the parameters of the tty on FD according to the contents of
806 *SETTINGS. If FLUSHP, discard input.
807 Return 0 if all went well, and -1 (setting errno) if anything failed. */
810 emacs_set_tty (int fd, struct emacs_tty *settings, bool flushp)
812 /* Set the primary parameters - baud rate, character size, etcetera. */
813 #ifdef DOS_NT
814 #ifdef WINDOWSNT
815 HANDLE h = (HANDLE)_get_osfhandle (fd);
817 if (h && h != INVALID_HANDLE_VALUE)
819 DWORD new_mode;
821 /* Assume the handle is open for input. */
822 if (flushp)
823 FlushConsoleInputBuffer (h);
824 new_mode = settings->main;
825 SetConsoleMode (h, new_mode);
827 #endif /* WINDOWSNT */
828 #else /* !DOS_NT */
829 int i;
830 /* We have those nifty POSIX tcmumbleattr functions.
831 William J. Smith <wjs@wiis.wang.com> writes:
832 "POSIX 1003.1 defines tcsetattr to return success if it was
833 able to perform any of the requested actions, even if some
834 of the requested actions could not be performed.
835 We must read settings back to ensure tty setup properly.
836 AIX requires this to keep tty from hanging occasionally." */
837 /* This make sure that we don't loop indefinitely in here. */
838 for (i = 0 ; i < 10 ; i++)
839 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
841 if (errno == EINTR)
842 continue;
843 else
844 return -1;
846 else
848 struct termios new;
850 memset (&new, 0, sizeof (new));
851 /* Get the current settings, and see if they're what we asked for. */
852 tcgetattr (fd, &new);
853 /* We cannot use memcmp on the whole structure here because under
854 * aix386 the termios structure has some reserved field that may
855 * not be filled in.
857 if ( new.c_iflag == settings->main.c_iflag
858 && new.c_oflag == settings->main.c_oflag
859 && new.c_cflag == settings->main.c_cflag
860 && new.c_lflag == settings->main.c_lflag
861 && memcmp (new.c_cc, settings->main.c_cc, NCCS) == 0)
862 break;
863 else
864 continue;
866 #endif
868 /* We have survived the tempest. */
869 return 0;
874 #ifdef F_SETOWN
875 static int old_fcntl_owner[FD_SETSIZE];
876 #endif /* F_SETOWN */
878 /* This may also be defined in stdio,
879 but if so, this does no harm,
880 and using the same name avoids wasting the other one's space. */
882 #if defined (USG)
883 unsigned char _sobuf[BUFSIZ+8];
884 #else
885 char _sobuf[BUFSIZ];
886 #endif
888 /* Initialize the terminal mode on all tty devices that are currently
889 open. */
891 void
892 init_all_sys_modes (void)
894 struct tty_display_info *tty;
895 for (tty = tty_list; tty; tty = tty->next)
896 init_sys_modes (tty);
899 /* Initialize the terminal mode on the given tty device. */
901 void
902 init_sys_modes (struct tty_display_info *tty_out)
904 struct emacs_tty tty;
905 Lisp_Object terminal;
907 Vtty_erase_char = Qnil;
909 if (noninteractive)
910 return;
912 if (!tty_out->output)
913 return; /* The tty is suspended. */
915 narrow_foreground_group (fileno (tty_out->input));
917 if (! tty_out->old_tty)
918 tty_out->old_tty = xmalloc (sizeof *tty_out->old_tty);
920 emacs_get_tty (fileno (tty_out->input), tty_out->old_tty);
922 tty = *tty_out->old_tty;
924 #if !defined (DOS_NT)
925 XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);
927 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
928 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
929 #ifdef INLCR /* I'm just being cautious,
930 since I can't check how widespread INLCR is--rms. */
931 tty.main.c_iflag &= ~INLCR; /* Disable map of NL to CR on input */
932 #endif
933 #ifdef ISTRIP
934 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
935 #endif
936 tty.main.c_lflag &= ~ECHO; /* Disable echo */
937 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
938 #ifdef IEXTEN
939 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
940 #endif
941 tty.main.c_lflag |= ISIG; /* Enable signals */
942 if (tty_out->flow_control)
944 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
945 #ifdef IXANY
946 tty.main.c_iflag &= ~IXANY;
947 #endif /* IXANY */
949 else
950 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
951 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
952 on output */
953 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
954 #ifdef CS8
955 if (tty_out->meta_key)
957 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
958 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
960 #endif
962 XSETTERMINAL(terminal, tty_out->terminal);
963 if (!NILP (Fcontrolling_tty_p (terminal)))
965 tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
966 /* Set up C-g for both SIGQUIT and SIGINT.
967 We don't know which we will get, but we handle both alike
968 so which one it really gives us does not matter. */
969 tty.main.c_cc[VQUIT] = quit_char;
971 else
973 /* We normally don't get interrupt or quit signals from tty
974 devices other than our controlling terminal; therefore,
975 we must handle C-g as normal input. Unfortunately, this
976 means that the interrupt and quit feature must be
977 disabled on secondary ttys, or we would not even see the
978 keypress.
980 Note that even though emacsclient could have special code
981 to pass SIGINT to Emacs, we should _not_ enable
982 interrupt/quit keys for emacsclient frames. This means
983 that we can't break out of loops in C code from a
984 secondary tty frame, but we can always decide what
985 display the C-g came from, which is more important from a
986 usability point of view. (Consider the case when two
987 people work together using the same Emacs instance.) */
988 tty.main.c_cc[VINTR] = CDISABLE;
989 tty.main.c_cc[VQUIT] = CDISABLE;
991 tty.main.c_cc[VMIN] = 1; /* Input should wait for at least 1 char */
992 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
993 #ifdef VSWTCH
994 tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
995 of C-z */
996 #endif /* VSWTCH */
998 #ifdef VSUSP
999 tty.main.c_cc[VSUSP] = CDISABLE; /* Turn off handling of C-z. */
1000 #endif /* VSUSP */
1001 #ifdef V_DSUSP
1002 tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off handling of C-y. */
1003 #endif /* V_DSUSP */
1004 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1005 tty.main.c_cc[VDSUSP] = CDISABLE;
1006 #endif /* VDSUSP */
1007 #ifdef VLNEXT
1008 tty.main.c_cc[VLNEXT] = CDISABLE;
1009 #endif /* VLNEXT */
1010 #ifdef VREPRINT
1011 tty.main.c_cc[VREPRINT] = CDISABLE;
1012 #endif /* VREPRINT */
1013 #ifdef VWERASE
1014 tty.main.c_cc[VWERASE] = CDISABLE;
1015 #endif /* VWERASE */
1016 #ifdef VDISCARD
1017 tty.main.c_cc[VDISCARD] = CDISABLE;
1018 #endif /* VDISCARD */
1020 if (tty_out->flow_control)
1022 #ifdef VSTART
1023 tty.main.c_cc[VSTART] = '\021';
1024 #endif /* VSTART */
1025 #ifdef VSTOP
1026 tty.main.c_cc[VSTOP] = '\023';
1027 #endif /* VSTOP */
1029 else
1031 #ifdef VSTART
1032 tty.main.c_cc[VSTART] = CDISABLE;
1033 #endif /* VSTART */
1034 #ifdef VSTOP
1035 tty.main.c_cc[VSTOP] = CDISABLE;
1036 #endif /* VSTOP */
1039 #ifdef AIX
1040 tty.main.c_cc[VSTRT] = CDISABLE;
1041 tty.main.c_cc[VSTOP] = CDISABLE;
1042 tty.main.c_cc[VSUSP] = CDISABLE;
1043 tty.main.c_cc[VDSUSP] = CDISABLE;
1044 if (tty_out->flow_control)
1046 #ifdef VSTART
1047 tty.main.c_cc[VSTART] = '\021';
1048 #endif /* VSTART */
1049 #ifdef VSTOP
1050 tty.main.c_cc[VSTOP] = '\023';
1051 #endif /* VSTOP */
1053 /* Also, PTY overloads NUL and BREAK.
1054 don't ignore break, but don't signal either, so it looks like NUL.
1055 This really serves a purpose only if running in an XTERM window
1056 or via TELNET or the like, but does no harm elsewhere. */
1057 tty.main.c_iflag &= ~IGNBRK;
1058 tty.main.c_iflag &= ~BRKINT;
1059 #endif
1060 #endif /* not DOS_NT */
1062 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1063 if (!tty_out->term_initted)
1064 internal_terminal_init ();
1065 dos_ttraw (tty_out);
1066 #endif
1068 emacs_set_tty (fileno (tty_out->input), &tty, 0);
1070 /* This code added to insure that, if flow-control is not to be used,
1071 we have an unlocked terminal at the start. */
1073 #ifdef TCXONC
1074 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TCXONC, 1);
1075 #endif
1076 #ifdef TIOCSTART
1077 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
1078 #endif
1080 #if !defined (DOS_NT)
1081 #ifdef TCOON
1082 if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
1083 #endif
1084 #endif
1086 #ifdef F_GETOWN
1087 if (interrupt_input)
1089 old_fcntl_owner[fileno (tty_out->input)] =
1090 fcntl (fileno (tty_out->input), F_GETOWN, 0);
1091 fcntl (fileno (tty_out->input), F_SETOWN, getpid ());
1092 init_sigio (fileno (tty_out->input));
1093 #ifdef HAVE_GPM
1094 if (gpm_tty == tty_out)
1096 /* Arrange for mouse events to give us SIGIO signals. */
1097 fcntl (gpm_fd, F_SETOWN, getpid ());
1098 fcntl (gpm_fd, F_SETFL, fcntl (gpm_fd, F_GETFL, 0) | O_NONBLOCK);
1099 init_sigio (gpm_fd);
1101 #endif /* HAVE_GPM */
1103 #endif /* F_GETOWN */
1105 #ifdef _IOFBF
1106 /* This symbol is defined on recent USG systems.
1107 Someone says without this call USG won't really buffer the file
1108 even with a call to setbuf. */
1109 setvbuf (tty_out->output, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1110 #else
1111 setbuf (tty_out->output, (char *) _sobuf);
1112 #endif
1114 if (tty_out->terminal->set_terminal_modes_hook)
1115 tty_out->terminal->set_terminal_modes_hook (tty_out->terminal);
1117 if (!tty_out->term_initted)
1119 Lisp_Object tail, frame;
1120 FOR_EACH_FRAME (tail, frame)
1122 /* XXX This needs to be revised. */
1123 if (FRAME_TERMCAP_P (XFRAME (frame))
1124 && FRAME_TTY (XFRAME (frame)) == tty_out)
1125 init_frame_faces (XFRAME (frame));
1129 if (tty_out->term_initted && no_redraw_on_reenter)
1131 /* We used to call "direct_output_forward_char(0)" here,
1132 but it's not clear why, since it may not do anything anyway. */
1134 else
1136 Lisp_Object tail, frame;
1137 frame_garbaged = 1;
1138 FOR_EACH_FRAME (tail, frame)
1140 if ((FRAME_TERMCAP_P (XFRAME (frame))
1141 || FRAME_MSDOS_P (XFRAME (frame)))
1142 && FRAME_TTY (XFRAME (frame)) == tty_out)
1143 FRAME_GARBAGED_P (XFRAME (frame)) = 1;
1147 tty_out->term_initted = 1;
1150 /* Return true if safe to use tabs in output.
1151 At the time this is called, init_sys_modes has not been done yet. */
1153 bool
1154 tabs_safe_p (int fd)
1156 struct emacs_tty etty;
1158 emacs_get_tty (fd, &etty);
1159 #ifndef DOS_NT
1160 #ifdef TABDLY
1161 return ((etty.main.c_oflag & TABDLY) != TAB3);
1162 #else /* not TABDLY */
1163 return 1;
1164 #endif /* not TABDLY */
1165 #else /* DOS_NT */
1166 return 0;
1167 #endif /* DOS_NT */
1170 /* Discard echoing. */
1172 void
1173 suppress_echo_on_tty (int fd)
1175 struct emacs_tty etty;
1177 emacs_get_tty (fd, &etty);
1178 #ifdef DOS_NT
1179 /* Set raw input mode. */
1180 etty.main = 0;
1181 #else
1182 etty.main.c_lflag &= ~ICANON; /* Disable buffering */
1183 etty.main.c_lflag &= ~ECHO; /* Disable echoing */
1184 #endif /* ! WINDOWSNT */
1185 emacs_set_tty (fd, &etty, 0);
1188 /* Get terminal size from system.
1189 Store number of lines into *HEIGHTP and width into *WIDTHP.
1190 We store 0 if there's no valid information. */
1192 void
1193 get_tty_size (int fd, int *widthp, int *heightp)
1195 #if defined TIOCGWINSZ
1197 /* BSD-style. */
1198 struct winsize size;
1200 if (ioctl (fd, TIOCGWINSZ, &size) == -1)
1201 *widthp = *heightp = 0;
1202 else
1204 *widthp = size.ws_col;
1205 *heightp = size.ws_row;
1208 #elif defined TIOCGSIZE
1210 /* SunOS - style. */
1211 struct ttysize size;
1213 if (ioctl (fd, TIOCGSIZE, &size) == -1)
1214 *widthp = *heightp = 0;
1215 else
1217 *widthp = size.ts_cols;
1218 *heightp = size.ts_lines;
1221 #elif defined WINDOWSNT
1223 CONSOLE_SCREEN_BUFFER_INFO info;
1224 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info))
1226 *widthp = info.srWindow.Right - info.srWindow.Left + 1;
1227 *heightp = info.srWindow.Bottom - info.srWindow.Top + 1;
1229 else
1230 *widthp = *heightp = 0;
1232 #elif defined MSDOS
1234 *widthp = ScreenCols ();
1235 *heightp = ScreenRows ();
1237 #else /* system doesn't know size */
1239 *widthp = 0;
1240 *heightp = 0;
1242 #endif
1245 /* Set the logical window size associated with descriptor FD
1246 to HEIGHT and WIDTH. This is used mainly with ptys.
1247 Return a negative value on failure. */
1250 set_window_size (int fd, int height, int width)
1252 #ifdef TIOCSWINSZ
1254 /* BSD-style. */
1255 struct winsize size;
1256 size.ws_row = height;
1257 size.ws_col = width;
1259 return ioctl (fd, TIOCSWINSZ, &size);
1261 #else
1262 #ifdef TIOCSSIZE
1264 /* SunOS - style. */
1265 struct ttysize size;
1266 size.ts_lines = height;
1267 size.ts_cols = width;
1269 return ioctl (fd, TIOCGSIZE, &size);
1270 #else
1271 return -1;
1272 #endif /* not SunOS-style */
1273 #endif /* not BSD-style */
1278 /* Prepare all terminal devices for exiting Emacs. */
1280 void
1281 reset_all_sys_modes (void)
1283 struct tty_display_info *tty;
1284 for (tty = tty_list; tty; tty = tty->next)
1285 reset_sys_modes (tty);
1288 /* Prepare the terminal for closing it; move the cursor to the
1289 bottom of the frame, turn off interrupt-driven I/O, etc. */
1291 void
1292 reset_sys_modes (struct tty_display_info *tty_out)
1294 if (noninteractive)
1296 fflush (stdout);
1297 return;
1299 if (!tty_out->term_initted)
1300 return;
1302 if (!tty_out->output)
1303 return; /* The tty is suspended. */
1305 /* Go to and clear the last line of the terminal. */
1307 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
1309 /* Code adapted from tty_clear_end_of_line. */
1310 if (tty_out->TS_clr_line)
1312 emacs_tputs (tty_out, tty_out->TS_clr_line, 1, cmputc);
1314 else
1315 { /* have to do it the hard way */
1316 int i;
1317 tty_turn_off_insert (tty_out);
1319 for (i = cursorX (tty_out); i < FrameCols (tty_out) - 1; i++)
1321 fputc (' ', tty_out->output);
1325 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
1326 fflush (tty_out->output);
1328 if (tty_out->terminal->reset_terminal_modes_hook)
1329 tty_out->terminal->reset_terminal_modes_hook (tty_out->terminal);
1331 /* Avoid possible loss of output when changing terminal modes. */
1332 while (fdatasync (fileno (tty_out->output)) != 0 && errno == EINTR)
1333 continue;
1335 #ifndef DOS_NT
1336 #ifdef F_SETOWN
1337 if (interrupt_input)
1339 reset_sigio (fileno (tty_out->input));
1340 fcntl (fileno (tty_out->input), F_SETOWN,
1341 old_fcntl_owner[fileno (tty_out->input)]);
1343 #endif /* F_SETOWN */
1344 fcntl (fileno (tty_out->input), F_SETFL,
1345 fcntl (fileno (tty_out->input), F_GETFL, 0) & ~O_NONBLOCK);
1346 #endif
1348 if (tty_out->old_tty)
1349 while (emacs_set_tty (fileno (tty_out->input),
1350 tty_out->old_tty, 0) < 0 && errno == EINTR)
1353 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1354 dos_ttcooked ();
1355 #endif
1357 widen_foreground_group (fileno (tty_out->input));
1360 #ifdef HAVE_PTYS
1362 /* Set up the proper status flags for use of a pty. */
1364 void
1365 setup_pty (int fd)
1367 /* I'm told that TOICREMOTE does not mean control chars
1368 "can't be sent" but rather that they don't have
1369 input-editing or signaling effects.
1370 That should be good, because we have other ways
1371 to do those things in Emacs.
1372 However, telnet mode seems not to work on 4.2.
1373 So TIOCREMOTE is turned off now. */
1375 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1376 will hang. In particular, the "timeout" feature (which
1377 causes a read to return if there is no data available)
1378 does this. Also it is known that telnet mode will hang
1379 in such a way that Emacs must be stopped (perhaps this
1380 is the same problem).
1382 If TIOCREMOTE is turned off, then there is a bug in
1383 hp-ux which sometimes loses data. Apparently the
1384 code which blocks the master process when the internal
1385 buffer fills up does not work. Other than this,
1386 though, everything else seems to work fine.
1388 Since the latter lossage is more benign, we may as well
1389 lose that way. -- cph */
1390 #ifdef FIONBIO
1391 #if defined (UNIX98_PTYS)
1393 int on = 1;
1394 ioctl (fd, FIONBIO, &on);
1396 #endif
1397 #endif
1399 #endif /* HAVE_PTYS */
1401 void
1402 init_system_name (void)
1404 char *hostname_alloc = NULL;
1405 char *hostname;
1406 #ifndef HAVE_GETHOSTNAME
1407 struct utsname uts;
1408 uname (&uts);
1409 hostname = uts.nodename;
1410 #else /* HAVE_GETHOSTNAME */
1411 char hostname_buf[256];
1412 ptrdiff_t hostname_size = sizeof hostname_buf;
1413 hostname = hostname_buf;
1415 /* Try to get the host name; if the buffer is too short, try
1416 again. Apparently, the only indication gethostname gives of
1417 whether the buffer was large enough is the presence or absence
1418 of a '\0' in the string. Eech. */
1419 for (;;)
1421 gethostname (hostname, hostname_size - 1);
1422 hostname[hostname_size - 1] = '\0';
1424 /* Was the buffer large enough for the '\0'? */
1425 if (strlen (hostname) < hostname_size - 1)
1426 break;
1428 hostname = hostname_alloc = xpalloc (hostname_alloc, &hostname_size, 1,
1429 min (PTRDIFF_MAX, SIZE_MAX), 1);
1431 #endif /* HAVE_GETHOSTNAME */
1432 char *p;
1433 for (p = hostname; *p; p++)
1434 if (*p == ' ' || *p == '\t')
1435 *p = '-';
1436 if (! (STRINGP (Vsystem_name) && SBYTES (Vsystem_name) == p - hostname
1437 && strcmp (SSDATA (Vsystem_name), hostname) == 0))
1438 Vsystem_name = build_string (hostname);
1439 xfree (hostname_alloc);
1442 sigset_t empty_mask;
1444 static struct sigaction process_fatal_action;
1446 static int
1447 emacs_sigaction_flags (void)
1449 #ifdef SA_RESTART
1450 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1451 'select') to reset their timeout on some platforms (e.g.,
1452 HP-UX 11), which is not what we want. Also, when Emacs is
1453 interactive, we don't want SA_RESTART because we need to poll
1454 for pending input so we need long-running syscalls to be interrupted
1455 after a signal that sets pending_signals.
1457 Non-interactive keyboard input goes through stdio, where we
1458 always want restartable system calls. */
1459 if (noninteractive)
1460 return SA_RESTART;
1461 #endif
1462 return 0;
1465 /* Store into *ACTION a signal action suitable for Emacs, with handler
1466 HANDLER. */
1467 void
1468 emacs_sigaction_init (struct sigaction *action, signal_handler_t handler)
1470 sigemptyset (&action->sa_mask);
1472 /* When handling a signal, block nonfatal system signals that are caught
1473 by Emacs. This makes race conditions less likely. */
1474 sigaddset (&action->sa_mask, SIGALRM);
1475 #ifdef SIGCHLD
1476 sigaddset (&action->sa_mask, SIGCHLD);
1477 #endif
1478 #ifdef SIGDANGER
1479 sigaddset (&action->sa_mask, SIGDANGER);
1480 #endif
1481 #ifdef PROFILER_CPU_SUPPORT
1482 sigaddset (&action->sa_mask, SIGPROF);
1483 #endif
1484 #ifdef SIGWINCH
1485 sigaddset (&action->sa_mask, SIGWINCH);
1486 #endif
1487 if (! noninteractive)
1489 sigaddset (&action->sa_mask, SIGINT);
1490 sigaddset (&action->sa_mask, SIGQUIT);
1491 #ifdef USABLE_SIGIO
1492 sigaddset (&action->sa_mask, SIGIO);
1493 #endif
1496 action->sa_handler = handler;
1497 action->sa_flags = emacs_sigaction_flags ();
1500 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1501 static pthread_t main_thread;
1502 #endif
1504 /* SIG has arrived at the current process. Deliver it to the main
1505 thread, which should handle it with HANDLER.
1507 If we are on the main thread, handle the signal SIG with HANDLER.
1508 Otherwise, redirect the signal to the main thread, blocking it from
1509 this thread. POSIX says any thread can receive a signal that is
1510 associated with a process, process group, or asynchronous event.
1511 On GNU/Linux that is not true, but for other systems (FreeBSD at
1512 least) it is. */
1513 void
1514 deliver_process_signal (int sig, signal_handler_t handler)
1516 /* Preserve errno, to avoid race conditions with signal handlers that
1517 might change errno. Races can occur even in single-threaded hosts. */
1518 int old_errno = errno;
1520 bool on_main_thread = true;
1521 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1522 if (! pthread_equal (pthread_self (), main_thread))
1524 sigset_t blocked;
1525 sigemptyset (&blocked);
1526 sigaddset (&blocked, sig);
1527 pthread_sigmask (SIG_BLOCK, &blocked, 0);
1528 pthread_kill (main_thread, sig);
1529 on_main_thread = false;
1531 #endif
1532 if (on_main_thread)
1533 handler (sig);
1535 errno = old_errno;
1538 /* Static location to save a fatal backtrace in a thread.
1539 FIXME: If two subsidiary threads fail simultaneously, the resulting
1540 backtrace may be garbage. */
1541 enum { BACKTRACE_LIMIT_MAX = 500 };
1542 static void *thread_backtrace_buffer[BACKTRACE_LIMIT_MAX + 1];
1543 static int thread_backtrace_npointers;
1545 /* SIG has arrived at the current thread.
1546 If we are on the main thread, handle the signal SIG with HANDLER.
1547 Otherwise, this is a fatal error in the handling thread. */
1548 static void
1549 deliver_thread_signal (int sig, signal_handler_t handler)
1551 int old_errno = errno;
1553 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1554 if (! pthread_equal (pthread_self (), main_thread))
1556 thread_backtrace_npointers
1557 = backtrace (thread_backtrace_buffer, BACKTRACE_LIMIT_MAX);
1558 sigaction (sig, &process_fatal_action, 0);
1559 pthread_kill (main_thread, sig);
1561 /* Avoid further damage while the main thread is exiting. */
1562 while (1)
1563 sigsuspend (&empty_mask);
1565 #endif
1567 handler (sig);
1568 errno = old_errno;
1571 #if !HAVE_DECL_SYS_SIGLIST
1572 # undef sys_siglist
1573 # ifdef _sys_siglist
1574 # define sys_siglist _sys_siglist
1575 # elif HAVE_DECL___SYS_SIGLIST
1576 # define sys_siglist __sys_siglist
1577 # else
1578 # define sys_siglist my_sys_siglist
1579 static char const *sys_siglist[NSIG];
1580 # endif
1581 #endif
1583 #ifdef _sys_nsig
1584 # define sys_siglist_entries _sys_nsig
1585 #else
1586 # define sys_siglist_entries NSIG
1587 #endif
1589 /* Handle bus errors, invalid instruction, etc. */
1590 static void
1591 handle_fatal_signal (int sig)
1593 terminate_due_to_signal (sig, 40);
1596 static void
1597 deliver_fatal_signal (int sig)
1599 deliver_process_signal (sig, handle_fatal_signal);
1602 static void
1603 deliver_fatal_thread_signal (int sig)
1605 deliver_thread_signal (sig, handle_fatal_signal);
1608 static _Noreturn void
1609 handle_arith_signal (int sig)
1611 pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
1612 xsignal0 (Qarith_error);
1615 #if defined HAVE_STACK_OVERFLOW_HANDLING && !defined WINDOWSNT
1617 /* Alternate stack used by SIGSEGV handler below. */
1619 static unsigned char sigsegv_stack[SIGSTKSZ];
1622 /* Return true if SIGINFO indicates a stack overflow. */
1624 static bool
1625 stack_overflow (siginfo_t *siginfo)
1627 /* In theory, a more-accurate heuristic can be obtained by using
1628 GNU/Linux pthread_getattr_np along with POSIX pthread_attr_getstack
1629 and pthread_attr_getguardsize to find the location and size of the
1630 guard area. In practice, though, these functions are so hard to
1631 use reliably that they're not worth bothering with. E.g., see:
1632 https://sourceware.org/bugzilla/show_bug.cgi?id=16291
1633 Other operating systems also have problems, e.g., Solaris's
1634 stack_violation function is tailor-made for this problem, but it
1635 doesn't work on Solaris 11.2 x86-64 with a 32-bit executable.
1637 GNU libsigsegv is overkill for Emacs; otherwise it might be a
1638 candidate here. */
1640 if (!siginfo)
1641 return false;
1643 /* The faulting address. */
1644 char *addr = siginfo->si_addr;
1645 if (!addr)
1646 return false;
1648 /* The known top and bottom of the stack. The actual stack may
1649 extend a bit beyond these boundaries. */
1650 char *bot = stack_bottom;
1651 char *top = near_C_stack_top ();
1653 /* Log base 2 of the stack heuristic ratio. This ratio is the size
1654 of the known stack divided by the size of the guard area past the
1655 end of the stack top. The heuristic is that a bad address is
1656 considered to be a stack overflow if it occurs within
1657 stacksize>>LG_STACK_HEURISTIC bytes above the top of the known
1658 stack. This heuristic is not exactly correct but it's good
1659 enough in practice. */
1660 enum { LG_STACK_HEURISTIC = 8 };
1662 if (bot < top)
1663 return 0 <= addr - top && addr - top < (top - bot) >> LG_STACK_HEURISTIC;
1664 else
1665 return 0 <= top - addr && top - addr < (bot - top) >> LG_STACK_HEURISTIC;
1669 /* Attempt to recover from SIGSEGV caused by C stack overflow. */
1671 static void
1672 handle_sigsegv (int sig, siginfo_t *siginfo, void *arg)
1674 /* Hard GC error may lead to stack overflow caused by
1675 too nested calls to mark_object. No way to survive. */
1676 bool fatal = gc_in_progress;
1678 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1679 if (!fatal && !pthread_equal (pthread_self (), main_thread))
1680 fatal = true;
1681 #endif
1683 if (!fatal && stack_overflow (siginfo))
1684 siglongjmp (return_to_command_loop, 1);
1686 /* Otherwise we can't do anything with this. */
1687 deliver_fatal_thread_signal (sig);
1690 /* Return true if we have successfully set up SIGSEGV handler on alternate
1691 stack. Otherwise we just treat SIGSEGV among the rest of fatal signals. */
1693 static bool
1694 init_sigsegv (void)
1696 struct sigaction sa;
1697 stack_t ss;
1699 ss.ss_sp = sigsegv_stack;
1700 ss.ss_size = sizeof (sigsegv_stack);
1701 ss.ss_flags = 0;
1702 if (sigaltstack (&ss, NULL) < 0)
1703 return 0;
1705 sigfillset (&sa.sa_mask);
1706 sa.sa_sigaction = handle_sigsegv;
1707 sa.sa_flags = SA_SIGINFO | SA_ONSTACK | emacs_sigaction_flags ();
1708 return sigaction (SIGSEGV, &sa, NULL) < 0 ? 0 : 1;
1711 #else /* not HAVE_STACK_OVERFLOW_HANDLING or WINDOWSNT */
1713 static bool
1714 init_sigsegv (void)
1716 return 0;
1719 #endif /* HAVE_STACK_OVERFLOW_HANDLING && !WINDOWSNT */
1721 static void
1722 deliver_arith_signal (int sig)
1724 deliver_thread_signal (sig, handle_arith_signal);
1727 #ifdef SIGDANGER
1729 /* Handler for SIGDANGER. */
1730 static void
1731 handle_danger_signal (int sig)
1733 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1735 /* It might be unsafe to call do_auto_save now. */
1736 force_auto_save_soon ();
1739 static void
1740 deliver_danger_signal (int sig)
1742 deliver_process_signal (sig, handle_danger_signal);
1744 #endif
1746 /* Treat SIG as a terminating signal, unless it is already ignored and
1747 we are in --batch mode. Among other things, this makes nohup work. */
1748 static void
1749 maybe_fatal_sig (int sig)
1751 bool catch_sig = !noninteractive;
1752 if (!catch_sig)
1754 struct sigaction old_action;
1755 sigaction (sig, 0, &old_action);
1756 catch_sig = old_action.sa_handler != SIG_IGN;
1758 if (catch_sig)
1759 sigaction (sig, &process_fatal_action, 0);
1762 void
1763 init_signals (bool dumping)
1765 struct sigaction thread_fatal_action;
1766 struct sigaction action;
1768 sigemptyset (&empty_mask);
1770 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1771 main_thread = pthread_self ();
1772 #endif
1774 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1775 if (! initialized)
1777 sys_siglist[SIGABRT] = "Aborted";
1778 # ifdef SIGAIO
1779 sys_siglist[SIGAIO] = "LAN I/O interrupt";
1780 # endif
1781 sys_siglist[SIGALRM] = "Alarm clock";
1782 # ifdef SIGBUS
1783 sys_siglist[SIGBUS] = "Bus error";
1784 # endif
1785 # ifdef SIGCHLD
1786 sys_siglist[SIGCHLD] = "Child status changed";
1787 # endif
1788 # ifdef SIGCONT
1789 sys_siglist[SIGCONT] = "Continued";
1790 # endif
1791 # ifdef SIGDANGER
1792 sys_siglist[SIGDANGER] = "Swap space dangerously low";
1793 # endif
1794 # ifdef SIGDGNOTIFY
1795 sys_siglist[SIGDGNOTIFY] = "Notification message in queue";
1796 # endif
1797 # ifdef SIGEMT
1798 sys_siglist[SIGEMT] = "Emulation trap";
1799 # endif
1800 sys_siglist[SIGFPE] = "Arithmetic exception";
1801 # ifdef SIGFREEZE
1802 sys_siglist[SIGFREEZE] = "SIGFREEZE";
1803 # endif
1804 # ifdef SIGGRANT
1805 sys_siglist[SIGGRANT] = "Monitor mode granted";
1806 # endif
1807 sys_siglist[SIGHUP] = "Hangup";
1808 sys_siglist[SIGILL] = "Illegal instruction";
1809 sys_siglist[SIGINT] = "Interrupt";
1810 # ifdef SIGIO
1811 sys_siglist[SIGIO] = "I/O possible";
1812 # endif
1813 # ifdef SIGIOINT
1814 sys_siglist[SIGIOINT] = "I/O intervention required";
1815 # endif
1816 # ifdef SIGIOT
1817 sys_siglist[SIGIOT] = "IOT trap";
1818 # endif
1819 sys_siglist[SIGKILL] = "Killed";
1820 # ifdef SIGLOST
1821 sys_siglist[SIGLOST] = "Resource lost";
1822 # endif
1823 # ifdef SIGLWP
1824 sys_siglist[SIGLWP] = "SIGLWP";
1825 # endif
1826 # ifdef SIGMSG
1827 sys_siglist[SIGMSG] = "Monitor mode data available";
1828 # endif
1829 # ifdef SIGPHONE
1830 sys_siglist[SIGWIND] = "SIGPHONE";
1831 # endif
1832 sys_siglist[SIGPIPE] = "Broken pipe";
1833 # ifdef SIGPOLL
1834 sys_siglist[SIGPOLL] = "Pollable event occurred";
1835 # endif
1836 # ifdef SIGPROF
1837 sys_siglist[SIGPROF] = "Profiling timer expired";
1838 # endif
1839 # ifdef SIGPTY
1840 sys_siglist[SIGPTY] = "PTY I/O interrupt";
1841 # endif
1842 # ifdef SIGPWR
1843 sys_siglist[SIGPWR] = "Power-fail restart";
1844 # endif
1845 sys_siglist[SIGQUIT] = "Quit";
1846 # ifdef SIGRETRACT
1847 sys_siglist[SIGRETRACT] = "Need to relinquish monitor mode";
1848 # endif
1849 # ifdef SIGSAK
1850 sys_siglist[SIGSAK] = "Secure attention";
1851 # endif
1852 sys_siglist[SIGSEGV] = "Segmentation violation";
1853 # ifdef SIGSOUND
1854 sys_siglist[SIGSOUND] = "Sound completed";
1855 # endif
1856 # ifdef SIGSTOP
1857 sys_siglist[SIGSTOP] = "Stopped (signal)";
1858 # endif
1859 # ifdef SIGSTP
1860 sys_siglist[SIGSTP] = "Stopped (user)";
1861 # endif
1862 # ifdef SIGSYS
1863 sys_siglist[SIGSYS] = "Bad argument to system call";
1864 # endif
1865 sys_siglist[SIGTERM] = "Terminated";
1866 # ifdef SIGTHAW
1867 sys_siglist[SIGTHAW] = "SIGTHAW";
1868 # endif
1869 # ifdef SIGTRAP
1870 sys_siglist[SIGTRAP] = "Trace/breakpoint trap";
1871 # endif
1872 # ifdef SIGTSTP
1873 sys_siglist[SIGTSTP] = "Stopped (user)";
1874 # endif
1875 # ifdef SIGTTIN
1876 sys_siglist[SIGTTIN] = "Stopped (tty input)";
1877 # endif
1878 # ifdef SIGTTOU
1879 sys_siglist[SIGTTOU] = "Stopped (tty output)";
1880 # endif
1881 # ifdef SIGURG
1882 sys_siglist[SIGURG] = "Urgent I/O condition";
1883 # endif
1884 # ifdef SIGUSR1
1885 sys_siglist[SIGUSR1] = "User defined signal 1";
1886 # endif
1887 # ifdef SIGUSR2
1888 sys_siglist[SIGUSR2] = "User defined signal 2";
1889 # endif
1890 # ifdef SIGVTALRM
1891 sys_siglist[SIGVTALRM] = "Virtual timer expired";
1892 # endif
1893 # ifdef SIGWAITING
1894 sys_siglist[SIGWAITING] = "Process's LWPs are blocked";
1895 # endif
1896 # ifdef SIGWINCH
1897 sys_siglist[SIGWINCH] = "Window size changed";
1898 # endif
1899 # ifdef SIGWIND
1900 sys_siglist[SIGWIND] = "SIGWIND";
1901 # endif
1902 # ifdef SIGXCPU
1903 sys_siglist[SIGXCPU] = "CPU time limit exceeded";
1904 # endif
1905 # ifdef SIGXFSZ
1906 sys_siglist[SIGXFSZ] = "File size limit exceeded";
1907 # endif
1909 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1911 /* Don't alter signal handlers if dumping. On some machines,
1912 changing signal handlers sets static data that would make signals
1913 fail to work right when the dumped Emacs is run. */
1914 if (dumping)
1915 return;
1917 sigfillset (&process_fatal_action.sa_mask);
1918 process_fatal_action.sa_handler = deliver_fatal_signal;
1919 process_fatal_action.sa_flags = emacs_sigaction_flags ();
1921 sigfillset (&thread_fatal_action.sa_mask);
1922 thread_fatal_action.sa_handler = deliver_fatal_thread_signal;
1923 thread_fatal_action.sa_flags = process_fatal_action.sa_flags;
1925 /* SIGINT may need special treatment on MS-Windows. See
1926 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1927 Please update the doc of kill-emacs, kill-emacs-hook, and
1928 NEWS if you change this. */
1930 maybe_fatal_sig (SIGHUP);
1931 maybe_fatal_sig (SIGINT);
1932 maybe_fatal_sig (SIGTERM);
1934 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1935 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1936 to behave more like typical batch applications do. */
1937 if (! noninteractive)
1938 signal (SIGPIPE, SIG_IGN);
1940 sigaction (SIGQUIT, &process_fatal_action, 0);
1941 sigaction (SIGILL, &thread_fatal_action, 0);
1942 sigaction (SIGTRAP, &thread_fatal_action, 0);
1944 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1945 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1946 interpreter's floating point operations, so treat SIGFPE as an
1947 arith-error if it arises in the main thread. */
1948 if (IEEE_FLOATING_POINT)
1949 sigaction (SIGFPE, &thread_fatal_action, 0);
1950 else
1952 emacs_sigaction_init (&action, deliver_arith_signal);
1953 sigaction (SIGFPE, &action, 0);
1956 #ifdef SIGUSR1
1957 add_user_signal (SIGUSR1, "sigusr1");
1958 #endif
1959 #ifdef SIGUSR2
1960 add_user_signal (SIGUSR2, "sigusr2");
1961 #endif
1962 sigaction (SIGABRT, &thread_fatal_action, 0);
1963 #ifdef SIGPRE
1964 sigaction (SIGPRE, &thread_fatal_action, 0);
1965 #endif
1966 #ifdef SIGORE
1967 sigaction (SIGORE, &thread_fatal_action, 0);
1968 #endif
1969 #ifdef SIGUME
1970 sigaction (SIGUME, &thread_fatal_action, 0);
1971 #endif
1972 #ifdef SIGDLK
1973 sigaction (SIGDLK, &process_fatal_action, 0);
1974 #endif
1975 #ifdef SIGCPULIM
1976 sigaction (SIGCPULIM, &process_fatal_action, 0);
1977 #endif
1978 #ifdef SIGIOT
1979 sigaction (SIGIOT, &thread_fatal_action, 0);
1980 #endif
1981 #ifdef SIGEMT
1982 sigaction (SIGEMT, &thread_fatal_action, 0);
1983 #endif
1984 #ifdef SIGBUS
1985 sigaction (SIGBUS, &thread_fatal_action, 0);
1986 #endif
1987 if (!init_sigsegv ())
1988 sigaction (SIGSEGV, &thread_fatal_action, 0);
1989 #ifdef SIGSYS
1990 sigaction (SIGSYS, &thread_fatal_action, 0);
1991 #endif
1992 sigaction (SIGTERM, &process_fatal_action, 0);
1993 #ifdef SIGPROF
1994 signal (SIGPROF, SIG_IGN);
1995 #endif
1996 #ifdef SIGVTALRM
1997 sigaction (SIGVTALRM, &process_fatal_action, 0);
1998 #endif
1999 #ifdef SIGXCPU
2000 sigaction (SIGXCPU, &process_fatal_action, 0);
2001 #endif
2002 #ifdef SIGXFSZ
2003 sigaction (SIGXFSZ, &process_fatal_action, 0);
2004 #endif
2006 #ifdef SIGDANGER
2007 /* This just means available memory is getting low. */
2008 emacs_sigaction_init (&action, deliver_danger_signal);
2009 sigaction (SIGDANGER, &action, 0);
2010 #endif
2012 /* AIX-specific signals. */
2013 #ifdef SIGGRANT
2014 sigaction (SIGGRANT, &process_fatal_action, 0);
2015 #endif
2016 #ifdef SIGMIGRATE
2017 sigaction (SIGMIGRATE, &process_fatal_action, 0);
2018 #endif
2019 #ifdef SIGMSG
2020 sigaction (SIGMSG, &process_fatal_action, 0);
2021 #endif
2022 #ifdef SIGRETRACT
2023 sigaction (SIGRETRACT, &process_fatal_action, 0);
2024 #endif
2025 #ifdef SIGSAK
2026 sigaction (SIGSAK, &process_fatal_action, 0);
2027 #endif
2028 #ifdef SIGSOUND
2029 sigaction (SIGSOUND, &process_fatal_action, 0);
2030 #endif
2031 #ifdef SIGTALRM
2032 sigaction (SIGTALRM, &thread_fatal_action, 0);
2033 #endif
2036 #ifndef HAVE_RANDOM
2037 #ifdef random
2038 #define HAVE_RANDOM
2039 #endif
2040 #endif
2042 /* Figure out how many bits the system's random number generator uses.
2043 `random' and `lrand48' are assumed to return 31 usable bits.
2044 BSD `rand' returns a 31 bit value but the low order bits are unusable;
2045 so we'll shift it and treat it like the 15-bit USG `rand'. */
2047 #ifndef RAND_BITS
2048 # ifdef HAVE_RANDOM
2049 # define RAND_BITS 31
2050 # else /* !HAVE_RANDOM */
2051 # ifdef HAVE_LRAND48
2052 # define RAND_BITS 31
2053 # define random lrand48
2054 # else /* !HAVE_LRAND48 */
2055 # define RAND_BITS 15
2056 # if RAND_MAX == 32767
2057 # define random rand
2058 # else /* RAND_MAX != 32767 */
2059 # if RAND_MAX == 2147483647
2060 # define random() (rand () >> 16)
2061 # else /* RAND_MAX != 2147483647 */
2062 # ifdef USG
2063 # define random rand
2064 # else
2065 # define random() (rand () >> 16)
2066 # endif /* !USG */
2067 # endif /* RAND_MAX != 2147483647 */
2068 # endif /* RAND_MAX != 32767 */
2069 # endif /* !HAVE_LRAND48 */
2070 # endif /* !HAVE_RANDOM */
2071 #endif /* !RAND_BITS */
2073 void
2074 seed_random (void *seed, ptrdiff_t seed_size)
2076 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
2077 unsigned int arg = 0;
2078 #else
2079 long int arg = 0;
2080 #endif
2081 unsigned char *argp = (unsigned char *) &arg;
2082 unsigned char *seedp = seed;
2083 ptrdiff_t i;
2084 for (i = 0; i < seed_size; i++)
2085 argp[i % sizeof arg] ^= seedp[i];
2086 #ifdef HAVE_RANDOM
2087 srandom (arg);
2088 #else
2089 # ifdef HAVE_LRAND48
2090 srand48 (arg);
2091 # else
2092 srand (arg);
2093 # endif
2094 #endif
2097 void
2098 init_random (void)
2100 struct timespec t = current_timespec ();
2101 uintmax_t v = getpid () ^ t.tv_sec ^ t.tv_nsec;
2102 seed_random (&v, sizeof v);
2106 * Return a nonnegative random integer out of whatever we've got.
2107 * It contains enough bits to make a random (signed) Emacs fixnum.
2108 * This suffices even for a 64-bit architecture with a 15-bit rand.
2110 EMACS_INT
2111 get_random (void)
2113 EMACS_UINT val = 0;
2114 int i;
2115 for (i = 0; i < (FIXNUM_BITS + RAND_BITS - 1) / RAND_BITS; i++)
2116 val = (random () ^ (val << RAND_BITS)
2117 ^ (val >> (BITS_PER_EMACS_INT - RAND_BITS)));
2118 val ^= val >> (BITS_PER_EMACS_INT - FIXNUM_BITS);
2119 return val & INTMASK;
2122 #ifndef HAVE_SNPRINTF
2123 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2125 snprintf (char *buf, size_t bufsize, char const *format, ...)
2127 ptrdiff_t size = min (bufsize, PTRDIFF_MAX);
2128 ptrdiff_t nbytes = size - 1;
2129 va_list ap;
2131 if (size)
2133 va_start (ap, format);
2134 nbytes = doprnt (buf, size, format, 0, ap);
2135 va_end (ap);
2138 if (nbytes == size - 1)
2140 /* Calculate the length of the string that would have been created
2141 had the buffer been large enough. */
2142 char stackbuf[4000];
2143 char *b = stackbuf;
2144 ptrdiff_t bsize = sizeof stackbuf;
2145 va_start (ap, format);
2146 nbytes = evxprintf (&b, &bsize, stackbuf, -1, format, ap);
2147 va_end (ap);
2148 if (b != stackbuf)
2149 xfree (b);
2152 if (INT_MAX < nbytes)
2154 #ifdef EOVERFLOW
2155 errno = EOVERFLOW;
2156 #else
2157 errno = EDOM;
2158 #endif
2159 return -1;
2161 return nbytes;
2163 #endif
2165 /* If a backtrace is available, output the top lines of it to stderr.
2166 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2167 This function may be called from a signal handler, so it should
2168 not invoke async-unsafe functions like malloc.
2170 If BACKTRACE_LIMIT is -1, initialize tables that 'backtrace' uses
2171 but do not output anything. This avoids some problems that can
2172 otherwise occur if the malloc arena is corrupted before 'backtrace'
2173 is called, since 'backtrace' may call malloc if the tables are not
2174 initialized.
2176 If the static variable THREAD_BACKTRACE_NPOINTERS is nonzero, a
2177 fatal error has occurred in some other thread; generate a thread
2178 backtrace instead, ignoring BACKTRACE_LIMIT. */
2179 void
2180 emacs_backtrace (int backtrace_limit)
2182 void *main_backtrace_buffer[BACKTRACE_LIMIT_MAX + 1];
2183 int bounded_limit = min (backtrace_limit, BACKTRACE_LIMIT_MAX);
2184 void *buffer;
2185 int npointers;
2187 if (thread_backtrace_npointers)
2189 buffer = thread_backtrace_buffer;
2190 npointers = thread_backtrace_npointers;
2192 else
2194 buffer = main_backtrace_buffer;
2196 /* Work around 'backtrace' bug; see Bug#19959 and glibc bug#18084. */
2197 if (bounded_limit < 0)
2199 backtrace (buffer, 1);
2200 return;
2203 npointers = backtrace (buffer, bounded_limit + 1);
2206 if (npointers)
2208 emacs_write (STDERR_FILENO, "\nBacktrace:\n", 12);
2209 backtrace_symbols_fd (buffer, npointers, STDERR_FILENO);
2210 if (bounded_limit < npointers)
2211 emacs_write (STDERR_FILENO, "...\n", 4);
2215 #ifndef HAVE_NTGUI
2216 void
2217 emacs_abort (void)
2219 terminate_due_to_signal (SIGABRT, 40);
2221 #endif
2223 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2224 Use binary I/O on systems that care about text vs binary I/O.
2225 Arrange for subprograms to not inherit the file descriptor.
2226 Prefer a method that is multithread-safe, if available.
2227 Do not fail merely because the open was interrupted by a signal.
2228 Allow the user to quit. */
2231 emacs_open (const char *file, int oflags, int mode)
2233 int fd;
2234 if (! (oflags & O_TEXT))
2235 oflags |= O_BINARY;
2236 oflags |= O_CLOEXEC;
2237 while ((fd = open (file, oflags, mode)) < 0 && errno == EINTR)
2238 QUIT;
2239 if (! O_CLOEXEC && 0 <= fd)
2240 fcntl (fd, F_SETFD, FD_CLOEXEC);
2241 return fd;
2244 /* Open FILE as a stream for Emacs use, with mode MODE.
2245 Act like emacs_open with respect to threads, signals, and quits. */
2247 FILE *
2248 emacs_fopen (char const *file, char const *mode)
2250 int fd, omode, oflags;
2251 int bflag = 0;
2252 char const *m = mode;
2254 switch (*m++)
2256 case 'r': omode = O_RDONLY; oflags = 0; break;
2257 case 'w': omode = O_WRONLY; oflags = O_CREAT | O_TRUNC; break;
2258 case 'a': omode = O_WRONLY; oflags = O_CREAT | O_APPEND; break;
2259 default: emacs_abort ();
2262 while (*m)
2263 switch (*m++)
2265 case '+': omode = O_RDWR; break;
2266 case 'b': bflag = O_BINARY; break;
2267 case 't': bflag = O_TEXT; break;
2268 default: /* Ignore. */ break;
2271 fd = emacs_open (file, omode | oflags | bflag, 0666);
2272 return fd < 0 ? 0 : fdopen (fd, mode);
2275 /* Create a pipe for Emacs use. */
2278 emacs_pipe (int fd[2])
2280 #ifdef MSDOS
2281 return pipe (fd);
2282 #else /* !MSDOS */
2283 int result = pipe2 (fd, O_BINARY | O_CLOEXEC);
2284 if (! O_CLOEXEC && result == 0)
2286 fcntl (fd[0], F_SETFD, FD_CLOEXEC);
2287 fcntl (fd[1], F_SETFD, FD_CLOEXEC);
2289 return result;
2290 #endif /* !MSDOS */
2293 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2294 For the background behind this mess, please see Austin Group defect 529
2295 <http://austingroupbugs.net/view.php?id=529>. */
2297 #ifndef POSIX_CLOSE_RESTART
2298 # define POSIX_CLOSE_RESTART 1
2299 static int
2300 posix_close (int fd, int flag)
2302 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2303 eassert (flag == POSIX_CLOSE_RESTART);
2305 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2306 on a system that does not define POSIX_CLOSE_RESTART.
2308 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2309 closed, and retrying the close could inadvertently close a file
2310 descriptor allocated by some other thread. In other systems
2311 (e.g., HP/UX) FD is not closed. And in still other systems
2312 (e.g., OS X, Solaris), maybe FD is closed, maybe not, and in a
2313 multithreaded program there can be no way to tell.
2315 So, in this case, pretend that the close succeeded. This works
2316 well on systems like GNU/Linux that close FD. Although it may
2317 leak a file descriptor on other systems, the leak is unlikely and
2318 it's better to leak than to close a random victim. */
2319 return close (fd) == 0 || errno == EINTR ? 0 : -1;
2321 #endif
2323 /* Close FD, retrying if interrupted. If successful, return 0;
2324 otherwise, return -1 and set errno to a non-EINTR value. Consider
2325 an EINPROGRESS error to be successful, as that's merely a signal
2326 arriving. FD is always closed when this function returns, even
2327 when it returns -1.
2329 Do not call this function if FD is nonnegative and might already be closed,
2330 as that might close an innocent victim opened by some other thread. */
2333 emacs_close (int fd)
2335 while (1)
2337 int r = posix_close (fd, POSIX_CLOSE_RESTART);
2338 if (r == 0)
2339 return r;
2340 if (!POSIX_CLOSE_RESTART || errno != EINTR)
2342 eassert (errno != EBADF || fd < 0);
2343 return errno == EINPROGRESS ? 0 : r;
2348 /* Maximum number of bytes to read or write in a single system call.
2349 This works around a serious bug in Linux kernels before 2.6.16; see
2350 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2351 It's likely to work around similar bugs in other operating systems, so do it
2352 on all platforms. Round INT_MAX down to a page size, with the conservative
2353 assumption that page sizes are at most 2**18 bytes (any kernel with a
2354 page size larger than that shouldn't have the bug). */
2355 #ifndef MAX_RW_COUNT
2356 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2357 #endif
2359 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2360 Return the number of bytes read, which might be less than NBYTE.
2361 On error, set errno and return -1. */
2362 ptrdiff_t
2363 emacs_read (int fildes, void *buf, ptrdiff_t nbyte)
2365 ssize_t rtnval;
2367 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2368 passes a size that large to emacs_read. */
2370 while ((rtnval = read (fildes, buf, nbyte)) == -1
2371 && (errno == EINTR))
2372 QUIT;
2373 return (rtnval);
2376 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2377 or if a partial write occurs. If interrupted, process pending
2378 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2379 errno if this is less than NBYTE. */
2380 static ptrdiff_t
2381 emacs_full_write (int fildes, char const *buf, ptrdiff_t nbyte,
2382 bool process_signals)
2384 ptrdiff_t bytes_written = 0;
2386 while (nbyte > 0)
2388 ssize_t n = write (fildes, buf, min (nbyte, MAX_RW_COUNT));
2390 if (n < 0)
2392 if (errno == EINTR)
2394 /* I originally used `QUIT' but that might cause files to
2395 be truncated if you hit C-g in the middle of it. --Stef */
2396 if (process_signals && pending_signals)
2397 process_pending_signals ();
2398 continue;
2400 else
2401 break;
2404 buf += n;
2405 nbyte -= n;
2406 bytes_written += n;
2409 return bytes_written;
2412 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2413 interrupted or if a partial write occurs. Return the number of
2414 bytes written, setting errno if this is less than NBYTE. */
2415 ptrdiff_t
2416 emacs_write (int fildes, void const *buf, ptrdiff_t nbyte)
2418 return emacs_full_write (fildes, buf, nbyte, 0);
2421 /* Like emacs_write, but also process pending signals if interrupted. */
2422 ptrdiff_t
2423 emacs_write_sig (int fildes, void const *buf, ptrdiff_t nbyte)
2425 return emacs_full_write (fildes, buf, nbyte, 1);
2428 /* Write a diagnostic to standard error that contains MESSAGE and a
2429 string derived from errno. Preserve errno. Do not buffer stderr.
2430 Do not process pending signals if interrupted. */
2431 void
2432 emacs_perror (char const *message)
2434 int err = errno;
2435 char const *error_string = strerror (err);
2436 char const *command = (initial_argv && initial_argv[0]
2437 ? initial_argv[0] : "emacs");
2438 /* Write it out all at once, if it's short; this is less likely to
2439 be interleaved with other output. */
2440 char buf[BUFSIZ];
2441 int nbytes = snprintf (buf, sizeof buf, "%s: %s: %s\n",
2442 command, message, error_string);
2443 if (0 <= nbytes && nbytes < BUFSIZ)
2444 emacs_write (STDERR_FILENO, buf, nbytes);
2445 else
2447 emacs_write (STDERR_FILENO, command, strlen (command));
2448 emacs_write (STDERR_FILENO, ": ", 2);
2449 emacs_write (STDERR_FILENO, message, strlen (message));
2450 emacs_write (STDERR_FILENO, ": ", 2);
2451 emacs_write (STDERR_FILENO, error_string, strlen (error_string));
2452 emacs_write (STDERR_FILENO, "\n", 1);
2454 errno = err;
2457 /* Return a struct timeval that is roughly equivalent to T.
2458 Use the least timeval not less than T.
2459 Return an extremal value if the result would overflow. */
2460 struct timeval
2461 make_timeval (struct timespec t)
2463 struct timeval tv;
2464 tv.tv_sec = t.tv_sec;
2465 tv.tv_usec = t.tv_nsec / 1000;
2467 if (t.tv_nsec % 1000 != 0)
2469 if (tv.tv_usec < 999999)
2470 tv.tv_usec++;
2471 else if (tv.tv_sec < TYPE_MAXIMUM (time_t))
2473 tv.tv_sec++;
2474 tv.tv_usec = 0;
2478 return tv;
2481 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2482 ATIME and MTIME, respectively.
2483 FD must be either negative -- in which case it is ignored --
2484 or a file descriptor that is open on FILE.
2485 If FD is nonnegative, then FILE can be NULL. */
2487 set_file_times (int fd, const char *filename,
2488 struct timespec atime, struct timespec mtime)
2490 struct timespec timespec[2];
2491 timespec[0] = atime;
2492 timespec[1] = mtime;
2493 return fdutimens (fd, filename, timespec);
2496 /* Like strsignal, except async-signal-safe, and this function typically
2497 returns a string in the C locale rather than the current locale. */
2498 char const *
2499 safe_strsignal (int code)
2501 char const *signame = 0;
2503 if (0 <= code && code < sys_siglist_entries)
2504 signame = sys_siglist[code];
2505 if (! signame)
2506 signame = "Unknown signal";
2508 return signame;
2511 #ifndef DOS_NT
2512 /* For make-serial-process */
2514 serial_open (Lisp_Object port)
2516 int fd = emacs_open (SSDATA (port), O_RDWR | O_NOCTTY | O_NONBLOCK, 0);
2517 if (fd < 0)
2518 report_file_error ("Opening serial port", port);
2519 #ifdef TIOCEXCL
2520 ioctl (fd, TIOCEXCL, (char *) 0);
2521 #endif
2523 return fd;
2526 #if !defined (HAVE_CFMAKERAW)
2527 /* Workaround for targets which are missing cfmakeraw. */
2528 /* Pasted from man page. */
2529 static void
2530 cfmakeraw (struct termios *termios_p)
2532 termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2533 termios_p->c_oflag &= ~OPOST;
2534 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2535 termios_p->c_cflag &= ~(CSIZE|PARENB);
2536 termios_p->c_cflag |= CS8;
2538 #endif /* !defined (HAVE_CFMAKERAW */
2540 #if !defined (HAVE_CFSETSPEED)
2541 /* Workaround for targets which are missing cfsetspeed. */
2542 static int
2543 cfsetspeed (struct termios *termios_p, speed_t vitesse)
2545 return (cfsetispeed (termios_p, vitesse)
2546 + cfsetospeed (termios_p, vitesse));
2548 #endif
2550 /* For serial-process-configure */
2551 void
2552 serial_configure (struct Lisp_Process *p,
2553 Lisp_Object contact)
2555 Lisp_Object childp2 = Qnil;
2556 Lisp_Object tem = Qnil;
2557 struct termios attr;
2558 int err;
2559 char summary[4] = "???"; /* This usually becomes "8N1". */
2561 childp2 = Fcopy_sequence (p->childp);
2563 /* Read port attributes and prepare default configuration. */
2564 err = tcgetattr (p->outfd, &attr);
2565 if (err != 0)
2566 report_file_error ("Failed tcgetattr", Qnil);
2567 cfmakeraw (&attr);
2568 #if defined (CLOCAL)
2569 attr.c_cflag |= CLOCAL;
2570 #endif
2571 #if defined (CREAD)
2572 attr.c_cflag |= CREAD;
2573 #endif
2575 /* Configure speed. */
2576 if (!NILP (Fplist_member (contact, QCspeed)))
2577 tem = Fplist_get (contact, QCspeed);
2578 else
2579 tem = Fplist_get (p->childp, QCspeed);
2580 CHECK_NUMBER (tem);
2581 err = cfsetspeed (&attr, XINT (tem));
2582 if (err != 0)
2583 report_file_error ("Failed cfsetspeed", tem);
2584 childp2 = Fplist_put (childp2, QCspeed, tem);
2586 /* Configure bytesize. */
2587 if (!NILP (Fplist_member (contact, QCbytesize)))
2588 tem = Fplist_get (contact, QCbytesize);
2589 else
2590 tem = Fplist_get (p->childp, QCbytesize);
2591 if (NILP (tem))
2592 tem = make_number (8);
2593 CHECK_NUMBER (tem);
2594 if (XINT (tem) != 7 && XINT (tem) != 8)
2595 error (":bytesize must be nil (8), 7, or 8");
2596 summary[0] = XINT (tem) + '0';
2597 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2598 attr.c_cflag &= ~CSIZE;
2599 attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
2600 #else
2601 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2602 if (XINT (tem) != 8)
2603 error ("Bytesize cannot be changed");
2604 #endif
2605 childp2 = Fplist_put (childp2, QCbytesize, tem);
2607 /* Configure parity. */
2608 if (!NILP (Fplist_member (contact, QCparity)))
2609 tem = Fplist_get (contact, QCparity);
2610 else
2611 tem = Fplist_get (p->childp, QCparity);
2612 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
2613 error (":parity must be nil (no parity), `even', or `odd'");
2614 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2615 attr.c_cflag &= ~(PARENB | PARODD);
2616 attr.c_iflag &= ~(IGNPAR | INPCK);
2617 if (NILP (tem))
2619 summary[1] = 'N';
2621 else if (EQ (tem, Qeven))
2623 summary[1] = 'E';
2624 attr.c_cflag |= PARENB;
2625 attr.c_iflag |= (IGNPAR | INPCK);
2627 else if (EQ (tem, Qodd))
2629 summary[1] = 'O';
2630 attr.c_cflag |= (PARENB | PARODD);
2631 attr.c_iflag |= (IGNPAR | INPCK);
2633 #else
2634 /* Don't error on no parity, which should be set by cfmakeraw. */
2635 if (!NILP (tem))
2636 error ("Parity cannot be configured");
2637 #endif
2638 childp2 = Fplist_put (childp2, QCparity, tem);
2640 /* Configure stopbits. */
2641 if (!NILP (Fplist_member (contact, QCstopbits)))
2642 tem = Fplist_get (contact, QCstopbits);
2643 else
2644 tem = Fplist_get (p->childp, QCstopbits);
2645 if (NILP (tem))
2646 tem = make_number (1);
2647 CHECK_NUMBER (tem);
2648 if (XINT (tem) != 1 && XINT (tem) != 2)
2649 error (":stopbits must be nil (1 stopbit), 1, or 2");
2650 summary[2] = XINT (tem) + '0';
2651 #if defined (CSTOPB)
2652 attr.c_cflag &= ~CSTOPB;
2653 if (XINT (tem) == 2)
2654 attr.c_cflag |= CSTOPB;
2655 #else
2656 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2657 if (XINT (tem) != 1)
2658 error ("Stopbits cannot be configured");
2659 #endif
2660 childp2 = Fplist_put (childp2, QCstopbits, tem);
2662 /* Configure flowcontrol. */
2663 if (!NILP (Fplist_member (contact, QCflowcontrol)))
2664 tem = Fplist_get (contact, QCflowcontrol);
2665 else
2666 tem = Fplist_get (p->childp, QCflowcontrol);
2667 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
2668 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2669 #if defined (CRTSCTS)
2670 attr.c_cflag &= ~CRTSCTS;
2671 #endif
2672 #if defined (CNEW_RTSCTS)
2673 attr.c_cflag &= ~CNEW_RTSCTS;
2674 #endif
2675 #if defined (IXON) && defined (IXOFF)
2676 attr.c_iflag &= ~(IXON | IXOFF);
2677 #endif
2678 if (NILP (tem))
2680 /* Already configured. */
2682 else if (EQ (tem, Qhw))
2684 #if defined (CRTSCTS)
2685 attr.c_cflag |= CRTSCTS;
2686 #elif defined (CNEW_RTSCTS)
2687 attr.c_cflag |= CNEW_RTSCTS;
2688 #else
2689 error ("Hardware flowcontrol (RTS/CTS) not supported");
2690 #endif
2692 else if (EQ (tem, Qsw))
2694 #if defined (IXON) && defined (IXOFF)
2695 attr.c_iflag |= (IXON | IXOFF);
2696 #else
2697 error ("Software flowcontrol (XON/XOFF) not supported");
2698 #endif
2700 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
2702 /* Activate configuration. */
2703 err = tcsetattr (p->outfd, TCSANOW, &attr);
2704 if (err != 0)
2705 report_file_error ("Failed tcsetattr", Qnil);
2707 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
2708 pset_childp (p, childp2);
2710 #endif /* not DOS_NT */
2712 /* System depended enumeration of and access to system processes a-la ps(1). */
2714 #ifdef HAVE_PROCFS
2716 /* Process enumeration and access via /proc. */
2718 Lisp_Object
2719 list_system_processes (void)
2721 Lisp_Object procdir, match, proclist, next;
2722 Lisp_Object tail;
2724 /* For every process on the system, there's a directory in the
2725 "/proc" pseudo-directory whose name is the numeric ID of that
2726 process. */
2727 procdir = build_string ("/proc");
2728 match = build_string ("[0-9]+");
2729 proclist = directory_files_internal (procdir, Qnil, match, Qt, 0, Qnil);
2731 /* `proclist' gives process IDs as strings. Destructively convert
2732 each string into a number. */
2733 for (tail = proclist; CONSP (tail); tail = next)
2735 next = XCDR (tail);
2736 XSETCAR (tail, Fstring_to_number (XCAR (tail), Qnil));
2739 /* directory_files_internal returns the files in reverse order; undo
2740 that. */
2741 proclist = Fnreverse (proclist);
2742 return proclist;
2745 #elif defined DARWIN_OS || defined __FreeBSD__
2747 Lisp_Object
2748 list_system_processes (void)
2750 #ifdef DARWIN_OS
2751 int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
2752 #else
2753 int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PROC};
2754 #endif
2755 size_t len;
2756 struct kinfo_proc *procs;
2757 size_t i;
2759 Lisp_Object proclist = Qnil;
2761 if (sysctl (mib, 3, NULL, &len, NULL, 0) != 0)
2762 return proclist;
2764 procs = xmalloc (len);
2765 if (sysctl (mib, 3, procs, &len, NULL, 0) != 0)
2767 xfree (procs);
2768 return proclist;
2771 len /= sizeof (struct kinfo_proc);
2772 for (i = 0; i < len; i++)
2774 #ifdef DARWIN_OS
2775 proclist = Fcons (make_fixnum_or_float (procs[i].kp_proc.p_pid), proclist);
2776 #else
2777 proclist = Fcons (make_fixnum_or_float (procs[i].ki_pid), proclist);
2778 #endif
2781 xfree (procs);
2783 return proclist;
2786 /* The WINDOWSNT implementation is in w32.c.
2787 The MSDOS implementation is in dosfns.c. */
2788 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2790 Lisp_Object
2791 list_system_processes (void)
2793 return Qnil;
2796 #endif /* !defined (WINDOWSNT) */
2798 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2799 static struct timespec
2800 time_from_jiffies (unsigned long long tval, long hz)
2802 unsigned long long s = tval / hz;
2803 unsigned long long frac = tval % hz;
2804 int ns;
2806 if (TYPE_MAXIMUM (time_t) < s)
2807 time_overflow ();
2808 if (LONG_MAX - 1 <= ULLONG_MAX / TIMESPEC_RESOLUTION
2809 || frac <= ULLONG_MAX / TIMESPEC_RESOLUTION)
2810 ns = frac * TIMESPEC_RESOLUTION / hz;
2811 else
2813 /* This is reachable only in the unlikely case that HZ * HZ
2814 exceeds ULLONG_MAX. It calculates an approximation that is
2815 guaranteed to be in range. */
2816 long hz_per_ns = (hz / TIMESPEC_RESOLUTION
2817 + (hz % TIMESPEC_RESOLUTION != 0));
2818 ns = frac / hz_per_ns;
2821 return make_timespec (s, ns);
2824 static Lisp_Object
2825 ltime_from_jiffies (unsigned long long tval, long hz)
2827 struct timespec t = time_from_jiffies (tval, hz);
2828 return make_lisp_time (t);
2831 static struct timespec
2832 get_up_time (void)
2834 FILE *fup;
2835 struct timespec up = make_timespec (0, 0);
2837 block_input ();
2838 fup = emacs_fopen ("/proc/uptime", "r");
2840 if (fup)
2842 unsigned long long upsec, upfrac, idlesec, idlefrac;
2843 int upfrac_start, upfrac_end, idlefrac_start, idlefrac_end;
2845 if (fscanf (fup, "%llu.%n%llu%n %llu.%n%llu%n",
2846 &upsec, &upfrac_start, &upfrac, &upfrac_end,
2847 &idlesec, &idlefrac_start, &idlefrac, &idlefrac_end)
2848 == 4)
2850 if (TYPE_MAXIMUM (time_t) < upsec)
2852 upsec = TYPE_MAXIMUM (time_t);
2853 upfrac = TIMESPEC_RESOLUTION - 1;
2855 else
2857 int upfraclen = upfrac_end - upfrac_start;
2858 for (; upfraclen < LOG10_TIMESPEC_RESOLUTION; upfraclen++)
2859 upfrac *= 10;
2860 for (; LOG10_TIMESPEC_RESOLUTION < upfraclen; upfraclen--)
2861 upfrac /= 10;
2862 upfrac = min (upfrac, TIMESPEC_RESOLUTION - 1);
2864 up = make_timespec (upsec, upfrac);
2866 fclose (fup);
2868 unblock_input ();
2870 return up;
2873 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2874 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2876 static Lisp_Object
2877 procfs_ttyname (int rdev)
2879 FILE *fdev;
2880 char name[PATH_MAX];
2882 block_input ();
2883 fdev = emacs_fopen ("/proc/tty/drivers", "r");
2884 name[0] = 0;
2886 if (fdev)
2888 unsigned major;
2889 unsigned long minor_beg, minor_end;
2890 char minor[25]; /* 2 32-bit numbers + dash */
2891 char *endp;
2893 for (; !feof (fdev) && !ferror (fdev); name[0] = 0)
2895 if (fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor) >= 3
2896 && major == MAJOR (rdev))
2898 minor_beg = strtoul (minor, &endp, 0);
2899 if (*endp == '\0')
2900 minor_end = minor_beg;
2901 else if (*endp == '-')
2902 minor_end = strtoul (endp + 1, &endp, 0);
2903 else
2904 continue;
2906 if (MINOR (rdev) >= minor_beg && MINOR (rdev) <= minor_end)
2908 sprintf (name + strlen (name), "%u", MINOR (rdev));
2909 break;
2913 fclose (fdev);
2915 unblock_input ();
2916 return build_string (name);
2919 static uintmax_t
2920 procfs_get_total_memory (void)
2922 FILE *fmem;
2923 uintmax_t retval = 2 * 1024 * 1024; /* default: 2 GiB */
2924 int c;
2926 block_input ();
2927 fmem = emacs_fopen ("/proc/meminfo", "r");
2929 if (fmem)
2931 uintmax_t entry_value;
2932 bool done;
2935 switch (fscanf (fmem, "MemTotal: %"SCNuMAX, &entry_value))
2937 case 1:
2938 retval = entry_value;
2939 done = 1;
2940 break;
2942 case 0:
2943 while ((c = getc (fmem)) != EOF && c != '\n')
2944 continue;
2945 done = c == EOF;
2946 break;
2948 default:
2949 done = 1;
2950 break;
2952 while (!done);
2954 fclose (fmem);
2956 unblock_input ();
2957 return retval;
2960 Lisp_Object
2961 system_process_attributes (Lisp_Object pid)
2963 char procfn[PATH_MAX], fn[PATH_MAX];
2964 struct stat st;
2965 struct passwd *pw;
2966 struct group *gr;
2967 long clocks_per_sec;
2968 char *procfn_end;
2969 char procbuf[1025], *p, *q;
2970 int fd;
2971 ssize_t nread;
2972 static char const default_cmd[] = "???";
2973 const char *cmd = default_cmd;
2974 int cmdsize = sizeof default_cmd - 1;
2975 char *cmdline = NULL;
2976 ptrdiff_t cmdline_size;
2977 char c;
2978 printmax_t proc_id;
2979 int ppid, pgrp, sess, tty, tpgid, thcount;
2980 uid_t uid;
2981 gid_t gid;
2982 unsigned long long u_time, s_time, cutime, cstime, start;
2983 long priority, niceness, rss;
2984 unsigned long minflt, majflt, cminflt, cmajflt, vsize;
2985 struct timespec tnow, tstart, tboot, telapsed, us_time;
2986 double pcpu, pmem;
2987 Lisp_Object attrs = Qnil;
2988 Lisp_Object cmd_str, decoded_cmd;
2989 ptrdiff_t count;
2991 CHECK_NUMBER_OR_FLOAT (pid);
2992 CONS_TO_INTEGER (pid, pid_t, proc_id);
2993 sprintf (procfn, "/proc/%"pMd, proc_id);
2994 if (stat (procfn, &st) < 0)
2995 return attrs;
2997 /* euid egid */
2998 uid = st.st_uid;
2999 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid)), attrs);
3000 block_input ();
3001 pw = getpwuid (uid);
3002 unblock_input ();
3003 if (pw)
3004 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
3006 gid = st.st_gid;
3007 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid)), attrs);
3008 block_input ();
3009 gr = getgrgid (gid);
3010 unblock_input ();
3011 if (gr)
3012 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
3014 count = SPECPDL_INDEX ();
3015 strcpy (fn, procfn);
3016 procfn_end = fn + strlen (fn);
3017 strcpy (procfn_end, "/stat");
3018 fd = emacs_open (fn, O_RDONLY, 0);
3019 if (fd < 0)
3020 nread = 0;
3021 else
3023 record_unwind_protect_int (close_file_unwind, fd);
3024 nread = emacs_read (fd, procbuf, sizeof procbuf - 1);
3026 if (0 < nread)
3028 procbuf[nread] = '\0';
3029 p = procbuf;
3031 p = strchr (p, '(');
3032 if (p != NULL)
3034 q = strrchr (p + 1, ')');
3035 /* comm */
3036 if (q != NULL)
3038 cmd = p + 1;
3039 cmdsize = q - cmd;
3042 else
3043 q = NULL;
3044 /* Command name is encoded in locale-coding-system; decode it. */
3045 cmd_str = make_unibyte_string (cmd, cmdsize);
3046 decoded_cmd = code_convert_string_norecord (cmd_str,
3047 Vlocale_coding_system, 0);
3048 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
3050 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
3051 utime stime cutime cstime priority nice thcount . start vsize rss */
3052 if (q
3053 && (sscanf (q + 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
3054 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
3055 &c, &ppid, &pgrp, &sess, &tty, &tpgid,
3056 &minflt, &cminflt, &majflt, &cmajflt,
3057 &u_time, &s_time, &cutime, &cstime,
3058 &priority, &niceness, &thcount, &start, &vsize, &rss)
3059 == 20))
3061 char state_str[2];
3062 state_str[0] = c;
3063 state_str[1] = '\0';
3064 attrs = Fcons (Fcons (Qstate, build_string (state_str)), attrs);
3065 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (ppid)), attrs);
3066 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pgrp)), attrs);
3067 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (sess)), attrs);
3068 attrs = Fcons (Fcons (Qttname, procfs_ttyname (tty)), attrs);
3069 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (tpgid)), attrs);
3070 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (minflt)), attrs);
3071 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (majflt)), attrs);
3072 attrs = Fcons (Fcons (Qcminflt, make_fixnum_or_float (cminflt)),
3073 attrs);
3074 attrs = Fcons (Fcons (Qcmajflt, make_fixnum_or_float (cmajflt)),
3075 attrs);
3076 clocks_per_sec = sysconf (_SC_CLK_TCK);
3077 if (clocks_per_sec < 0)
3078 clocks_per_sec = 100;
3079 attrs = Fcons (Fcons (Qutime,
3080 ltime_from_jiffies (u_time, clocks_per_sec)),
3081 attrs);
3082 attrs = Fcons (Fcons (Qstime,
3083 ltime_from_jiffies (s_time, clocks_per_sec)),
3084 attrs);
3085 attrs = Fcons (Fcons (Qtime,
3086 ltime_from_jiffies (s_time + u_time,
3087 clocks_per_sec)),
3088 attrs);
3089 attrs = Fcons (Fcons (Qcutime,
3090 ltime_from_jiffies (cutime, clocks_per_sec)),
3091 attrs);
3092 attrs = Fcons (Fcons (Qcstime,
3093 ltime_from_jiffies (cstime, clocks_per_sec)),
3094 attrs);
3095 attrs = Fcons (Fcons (Qctime,
3096 ltime_from_jiffies (cstime + cutime,
3097 clocks_per_sec)),
3098 attrs);
3099 attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs);
3100 attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
3101 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount)),
3102 attrs);
3103 tnow = current_timespec ();
3104 telapsed = get_up_time ();
3105 tboot = timespec_sub (tnow, telapsed);
3106 tstart = time_from_jiffies (start, clocks_per_sec);
3107 tstart = timespec_add (tboot, tstart);
3108 attrs = Fcons (Fcons (Qstart, make_lisp_time (tstart)), attrs);
3109 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize / 1024)),
3110 attrs);
3111 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4 * rss)), attrs);
3112 telapsed = timespec_sub (tnow, tstart);
3113 attrs = Fcons (Fcons (Qetime, make_lisp_time (telapsed)), attrs);
3114 us_time = time_from_jiffies (u_time + s_time, clocks_per_sec);
3115 pcpu = timespectod (us_time) / timespectod (telapsed);
3116 if (pcpu > 1.0)
3117 pcpu = 1.0;
3118 attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
3119 pmem = 4.0 * 100 * rss / procfs_get_total_memory ();
3120 if (pmem > 100)
3121 pmem = 100;
3122 attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs);
3125 unbind_to (count, Qnil);
3127 /* args */
3128 strcpy (procfn_end, "/cmdline");
3129 fd = emacs_open (fn, O_RDONLY, 0);
3130 if (fd >= 0)
3132 ptrdiff_t readsize, nread_incr;
3133 record_unwind_protect_int (close_file_unwind, fd);
3134 record_unwind_protect_nothing ();
3135 nread = cmdline_size = 0;
3139 cmdline = xpalloc (cmdline, &cmdline_size, 2, STRING_BYTES_BOUND, 1);
3140 set_unwind_protect_ptr (count + 1, xfree, cmdline);
3142 /* Leave room even if every byte needs escaping below. */
3143 readsize = (cmdline_size >> 1) - nread;
3145 nread_incr = emacs_read (fd, cmdline + nread, readsize);
3146 nread += max (0, nread_incr);
3148 while (nread_incr == readsize);
3150 if (nread)
3152 /* We don't want trailing null characters. */
3153 for (p = cmdline + nread; cmdline < p && !p[-1]; p--)
3154 continue;
3156 /* Escape-quote whitespace and backslashes. */
3157 q = cmdline + cmdline_size;
3158 while (cmdline < p)
3160 char c = *--p;
3161 *--q = c ? c : ' ';
3162 if (c_isspace (c) || c == '\\')
3163 *--q = '\\';
3166 nread = cmdline + cmdline_size - q;
3169 if (!nread)
3171 nread = cmdsize + 2;
3172 cmdline_size = nread + 1;
3173 q = cmdline = xrealloc (cmdline, cmdline_size);
3174 set_unwind_protect_ptr (count + 1, xfree, cmdline);
3175 sprintf (cmdline, "[%.*s]", cmdsize, cmd);
3177 /* Command line is encoded in locale-coding-system; decode it. */
3178 cmd_str = make_unibyte_string (q, nread);
3179 decoded_cmd = code_convert_string_norecord (cmd_str,
3180 Vlocale_coding_system, 0);
3181 unbind_to (count, Qnil);
3182 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
3185 return attrs;
3188 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3190 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3191 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3192 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3193 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3194 #undef _FILE_OFFSET_BITS
3195 #else
3196 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3197 #endif
3199 #include <procfs.h>
3201 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3202 #define _FILE_OFFSET_BITS 64
3203 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3204 #endif
3205 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3207 Lisp_Object
3208 system_process_attributes (Lisp_Object pid)
3210 char procfn[PATH_MAX], fn[PATH_MAX];
3211 struct stat st;
3212 struct passwd *pw;
3213 struct group *gr;
3214 char *procfn_end;
3215 struct psinfo pinfo;
3216 int fd;
3217 ssize_t nread;
3218 printmax_t proc_id;
3219 uid_t uid;
3220 gid_t gid;
3221 Lisp_Object attrs = Qnil;
3222 Lisp_Object decoded_cmd;
3223 ptrdiff_t count;
3225 CHECK_NUMBER_OR_FLOAT (pid);
3226 CONS_TO_INTEGER (pid, pid_t, proc_id);
3227 sprintf (procfn, "/proc/%"pMd, proc_id);
3228 if (stat (procfn, &st) < 0)
3229 return attrs;
3231 /* euid egid */
3232 uid = st.st_uid;
3233 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid)), attrs);
3234 block_input ();
3235 pw = getpwuid (uid);
3236 unblock_input ();
3237 if (pw)
3238 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
3240 gid = st.st_gid;
3241 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid)), attrs);
3242 block_input ();
3243 gr = getgrgid (gid);
3244 unblock_input ();
3245 if (gr)
3246 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
3248 count = SPECPDL_INDEX ();
3249 strcpy (fn, procfn);
3250 procfn_end = fn + strlen (fn);
3251 strcpy (procfn_end, "/psinfo");
3252 fd = emacs_open (fn, O_RDONLY, 0);
3253 if (fd < 0)
3254 nread = 0;
3255 else
3257 record_unwind_protect (close_file_unwind, fd);
3258 nread = emacs_read (fd, &pinfo, sizeof pinfo);
3261 if (nread == sizeof pinfo)
3263 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (pinfo.pr_ppid)), attrs);
3264 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pinfo.pr_pgid)), attrs);
3265 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (pinfo.pr_sid)), attrs);
3268 char state_str[2];
3269 state_str[0] = pinfo.pr_lwp.pr_sname;
3270 state_str[1] = '\0';
3271 attrs = Fcons (Fcons (Qstate, build_string (state_str)), attrs);
3274 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3275 need to get a string from it. */
3277 /* FIXME: missing: Qtpgid */
3279 /* FIXME: missing:
3280 Qminflt
3281 Qmajflt
3282 Qcminflt
3283 Qcmajflt
3285 Qutime
3286 Qcutime
3287 Qstime
3288 Qcstime
3289 Are they available? */
3291 attrs = Fcons (Fcons (Qtime, make_lisp_time (pinfo.pr_time)), attrs);
3292 attrs = Fcons (Fcons (Qctime, make_lisp_time (pinfo.pr_ctime)), attrs);
3293 attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs);
3294 attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs);
3295 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)),
3296 attrs);
3298 attrs = Fcons (Fcons (Qstart, make_lisp_time (pinfo.pr_start)), attrs);
3299 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)),
3300 attrs);
3301 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)),
3302 attrs);
3304 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3305 range 0 .. 2**15, representing 0.0 .. 1.0. */
3306 attrs = Fcons (Fcons (Qpcpu,
3307 make_float (100.0 / 0x8000 * pinfo.pr_pctcpu)),
3308 attrs);
3309 attrs = Fcons (Fcons (Qpmem,
3310 make_float (100.0 / 0x8000 * pinfo.pr_pctmem)),
3311 attrs);
3313 decoded_cmd = (code_convert_string_norecord
3314 (build_unibyte_string (pinfo.pr_fname),
3315 Vlocale_coding_system, 0));
3316 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
3317 decoded_cmd = (code_convert_string_norecord
3318 (build_unibyte_string (pinfo.pr_psargs),
3319 Vlocale_coding_system, 0));
3320 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
3322 unbind_to (count, Qnil);
3323 return attrs;
3326 #elif defined __FreeBSD__
3328 static struct timespec
3329 timeval_to_timespec (struct timeval t)
3331 return make_timespec (t.tv_sec, t.tv_usec * 1000);
3334 static Lisp_Object
3335 make_lisp_timeval (struct timeval t)
3337 return make_lisp_time (timeval_to_timespec (t));
3340 Lisp_Object
3341 system_process_attributes (Lisp_Object pid)
3343 int proc_id;
3344 int pagesize = getpagesize ();
3345 unsigned long npages;
3346 int fscale;
3347 struct passwd *pw;
3348 struct group *gr;
3349 char *ttyname;
3350 size_t len;
3351 char args[MAXPATHLEN];
3352 struct timespec t, now;
3354 int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID};
3355 struct kinfo_proc proc;
3356 size_t proclen = sizeof proc;
3358 Lisp_Object attrs = Qnil;
3359 Lisp_Object decoded_comm;
3361 CHECK_NUMBER_OR_FLOAT (pid);
3362 CONS_TO_INTEGER (pid, int, proc_id);
3363 mib[3] = proc_id;
3365 if (sysctl (mib, 4, &proc, &proclen, NULL, 0) != 0)
3366 return attrs;
3368 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (proc.ki_uid)), attrs);
3370 block_input ();
3371 pw = getpwuid (proc.ki_uid);
3372 unblock_input ();
3373 if (pw)
3374 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
3376 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (proc.ki_svgid)), attrs);
3378 block_input ();
3379 gr = getgrgid (proc.ki_svgid);
3380 unblock_input ();
3381 if (gr)
3382 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
3384 decoded_comm = (code_convert_string_norecord
3385 (build_unibyte_string (proc.ki_comm),
3386 Vlocale_coding_system, 0));
3388 attrs = Fcons (Fcons (Qcomm, decoded_comm), attrs);
3390 char state[2] = {'\0', '\0'};
3391 switch (proc.ki_stat)
3393 case SRUN:
3394 state[0] = 'R';
3395 break;
3397 case SSLEEP:
3398 state[0] = 'S';
3399 break;
3401 case SLOCK:
3402 state[0] = 'D';
3403 break;
3405 case SZOMB:
3406 state[0] = 'Z';
3407 break;
3409 case SSTOP:
3410 state[0] = 'T';
3411 break;
3413 attrs = Fcons (Fcons (Qstate, build_string (state)), attrs);
3416 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (proc.ki_ppid)), attrs);
3417 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (proc.ki_pgid)), attrs);
3418 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (proc.ki_sid)), attrs);
3420 block_input ();
3421 ttyname = proc.ki_tdev == NODEV ? NULL : devname (proc.ki_tdev, S_IFCHR);
3422 unblock_input ();
3423 if (ttyname)
3424 attrs = Fcons (Fcons (Qtty, build_string (ttyname)), attrs);
3426 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (proc.ki_tpgid)), attrs);
3427 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (proc.ki_rusage.ru_minflt)), attrs);
3428 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (proc.ki_rusage.ru_majflt)), attrs);
3429 attrs = Fcons (Fcons (Qcminflt, make_number (proc.ki_rusage_ch.ru_minflt)), attrs);
3430 attrs = Fcons (Fcons (Qcmajflt, make_number (proc.ki_rusage_ch.ru_majflt)), attrs);
3432 attrs = Fcons (Fcons (Qutime, make_lisp_timeval (proc.ki_rusage.ru_utime)),
3433 attrs);
3434 attrs = Fcons (Fcons (Qstime, make_lisp_timeval (proc.ki_rusage.ru_stime)),
3435 attrs);
3436 t = timespec_add (timeval_to_timespec (proc.ki_rusage.ru_utime),
3437 timeval_to_timespec (proc.ki_rusage.ru_stime));
3438 attrs = Fcons (Fcons (Qtime, make_lisp_time (t)), attrs);
3440 attrs = Fcons (Fcons (Qcutime,
3441 make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
3442 attrs);
3443 attrs = Fcons (Fcons (Qcstime,
3444 make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
3445 attrs);
3446 t = timespec_add (timeval_to_timespec (proc.ki_rusage_ch.ru_utime),
3447 timeval_to_timespec (proc.ki_rusage_ch.ru_stime));
3448 attrs = Fcons (Fcons (Qctime, make_lisp_time (t)), attrs);
3450 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (proc.ki_numthreads)),
3451 attrs);
3452 attrs = Fcons (Fcons (Qpri, make_number (proc.ki_pri.pri_native)), attrs);
3453 attrs = Fcons (Fcons (Qnice, make_number (proc.ki_nice)), attrs);
3454 attrs = Fcons (Fcons (Qstart, make_lisp_timeval (proc.ki_start)), attrs);
3455 attrs = Fcons (Fcons (Qvsize, make_number (proc.ki_size >> 10)), attrs);
3456 attrs = Fcons (Fcons (Qrss, make_number (proc.ki_rssize * pagesize >> 10)),
3457 attrs);
3459 now = current_timespec ();
3460 t = timespec_sub (now, timeval_to_timespec (proc.ki_start));
3461 attrs = Fcons (Fcons (Qetime, make_lisp_time (t)), attrs);
3463 len = sizeof fscale;
3464 if (sysctlbyname ("kern.fscale", &fscale, &len, NULL, 0) == 0)
3466 double pcpu;
3467 fixpt_t ccpu;
3468 len = sizeof ccpu;
3469 if (sysctlbyname ("kern.ccpu", &ccpu, &len, NULL, 0) == 0)
3471 pcpu = (100.0 * proc.ki_pctcpu / fscale
3472 / (1 - exp (proc.ki_swtime * log ((double) ccpu / fscale))));
3473 attrs = Fcons (Fcons (Qpcpu, make_fixnum_or_float (pcpu)), attrs);
3477 len = sizeof npages;
3478 if (sysctlbyname ("hw.availpages", &npages, &len, NULL, 0) == 0)
3480 double pmem = (proc.ki_flag & P_INMEM
3481 ? 100.0 * proc.ki_rssize / npages
3482 : 0);
3483 attrs = Fcons (Fcons (Qpmem, make_fixnum_or_float (pmem)), attrs);
3486 mib[2] = KERN_PROC_ARGS;
3487 len = MAXPATHLEN;
3488 if (sysctl (mib, 4, args, &len, NULL, 0) == 0)
3490 int i;
3491 for (i = 0; i < len; i++)
3493 if (! args[i] && i < len - 1)
3494 args[i] = ' ';
3497 decoded_comm =
3498 (code_convert_string_norecord
3499 (build_unibyte_string (args),
3500 Vlocale_coding_system, 0));
3502 attrs = Fcons (Fcons (Qargs, decoded_comm), attrs);
3505 return attrs;
3508 /* The WINDOWSNT implementation is in w32.c.
3509 The MSDOS implementation is in dosfns.c. */
3510 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3512 Lisp_Object
3513 system_process_attributes (Lisp_Object pid)
3515 return Qnil;
3518 #endif /* !defined (WINDOWSNT) */
3520 /* Wide character string collation. */
3522 #ifdef __STDC_ISO_10646__
3523 # include <wchar.h>
3524 # include <wctype.h>
3526 # if defined HAVE_NEWLOCALE || defined HAVE_SETLOCALE
3527 # include <locale.h>
3528 # endif
3529 # ifndef LC_COLLATE
3530 # define LC_COLLATE 0
3531 # endif
3532 # ifndef LC_COLLATE_MASK
3533 # define LC_COLLATE_MASK 0
3534 # endif
3535 # ifndef LC_CTYPE
3536 # define LC_CTYPE 0
3537 # endif
3538 # ifndef LC_CTYPE_MASK
3539 # define LC_CTYPE_MASK 0
3540 # endif
3542 # ifndef HAVE_NEWLOCALE
3543 # undef freelocale
3544 # undef locale_t
3545 # undef newlocale
3546 # undef wcscoll_l
3547 # undef towlower_l
3548 # define freelocale emacs_freelocale
3549 # define locale_t emacs_locale_t
3550 # define newlocale emacs_newlocale
3551 # define wcscoll_l emacs_wcscoll_l
3552 # define towlower_l emacs_towlower_l
3554 typedef char const *locale_t;
3556 static locale_t
3557 newlocale (int category_mask, char const *locale, locale_t loc)
3559 return locale;
3562 static void
3563 freelocale (locale_t loc)
3567 static char *
3568 emacs_setlocale (int category, char const *locale)
3570 # ifdef HAVE_SETLOCALE
3571 errno = 0;
3572 char *loc = setlocale (category, locale);
3573 if (loc || errno)
3574 return loc;
3575 errno = EINVAL;
3576 # else
3577 errno = ENOTSUP;
3578 # endif
3579 return 0;
3582 static int
3583 wcscoll_l (wchar_t const *a, wchar_t const *b, locale_t loc)
3585 int result = 0;
3586 char *oldloc = emacs_setlocale (LC_COLLATE, NULL);
3587 int err;
3589 if (! oldloc)
3590 err = errno;
3591 else
3593 USE_SAFE_ALLOCA;
3594 char *oldcopy = SAFE_ALLOCA (strlen (oldloc) + 1);
3595 strcpy (oldcopy, oldloc);
3596 if (! emacs_setlocale (LC_COLLATE, loc))
3597 err = errno;
3598 else
3600 errno = 0;
3601 result = wcscoll (a, b);
3602 err = errno;
3603 if (! emacs_setlocale (LC_COLLATE, oldcopy))
3604 err = errno;
3606 SAFE_FREE ();
3609 errno = err;
3610 return result;
3613 static wint_t
3614 towlower_l (wint_t wc, locale_t loc)
3616 wint_t result = wc;
3617 char *oldloc = emacs_setlocale (LC_CTYPE, NULL);
3619 if (oldloc)
3621 USE_SAFE_ALLOCA;
3622 char *oldcopy = SAFE_ALLOCA (strlen (oldloc) + 1);
3623 strcpy (oldcopy, oldloc);
3624 if (emacs_setlocale (LC_CTYPE, loc))
3626 result = towlower (wc);
3627 emacs_setlocale (LC_COLLATE, oldcopy);
3629 SAFE_FREE ();
3632 return result;
3634 # endif
3637 str_collate (Lisp_Object s1, Lisp_Object s2,
3638 Lisp_Object locale, Lisp_Object ignore_case)
3640 int res, err;
3641 ptrdiff_t len, i, i_byte;
3642 wchar_t *p1, *p2;
3644 USE_SAFE_ALLOCA;
3646 /* Convert byte stream to code points. */
3647 len = SCHARS (s1); i = i_byte = 0;
3648 SAFE_NALLOCA (p1, 1, len + 1);
3649 while (i < len)
3650 FETCH_STRING_CHAR_ADVANCE (*(p1+i-1), s1, i, i_byte);
3651 *(p1+len) = 0;
3653 len = SCHARS (s2); i = i_byte = 0;
3654 SAFE_NALLOCA (p2, 1, len + 1);
3655 while (i < len)
3656 FETCH_STRING_CHAR_ADVANCE (*(p2+i-1), s2, i, i_byte);
3657 *(p2+len) = 0;
3659 if (STRINGP (locale))
3661 locale_t loc = newlocale (LC_COLLATE_MASK | LC_CTYPE_MASK,
3662 SSDATA (locale), 0);
3663 if (!loc)
3664 error ("Invalid locale %s: %s", SSDATA (locale), strerror (errno));
3666 if (! NILP (ignore_case))
3667 for (int i = 1; i < 3; i++)
3669 wchar_t *p = (i == 1) ? p1 : p2;
3670 for (; *p; p++)
3671 *p = towlower_l (*p, loc);
3674 errno = 0;
3675 res = wcscoll_l (p1, p2, loc);
3676 err = errno;
3677 freelocale (loc);
3679 else
3681 if (! NILP (ignore_case))
3682 for (int i = 1; i < 3; i++)
3684 wchar_t *p = (i == 1) ? p1 : p2;
3685 for (; *p; p++)
3686 *p = towlower (*p);
3689 errno = 0;
3690 res = wcscoll (p1, p2);
3691 err = errno;
3693 # ifndef HAVE_NEWLOCALE
3694 if (err)
3695 error ("Invalid locale or string for collation: %s", strerror (err));
3696 # else
3697 if (err)
3698 error ("Invalid string for collation: %s", strerror (err));
3699 # endif
3701 SAFE_FREE ();
3702 return res;
3704 #endif /* __STDC_ISO_10646__ */
3706 #ifdef WINDOWSNT
3708 str_collate (Lisp_Object s1, Lisp_Object s2,
3709 Lisp_Object locale, Lisp_Object ignore_case)
3712 char *loc = STRINGP (locale) ? SSDATA (locale) : NULL;
3713 int res, err = errno;
3715 errno = 0;
3716 res = w32_compare_strings (SDATA (s1), SDATA (s2), loc, !NILP (ignore_case));
3717 if (errno)
3718 error ("Invalid string for collation: %s", strerror (errno));
3720 errno = err;
3721 return res;
3723 #endif /* WINDOWSNT */