1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2016 Free Software
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 (at
10 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/>. */
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
35 #endif /* HAVE_PWD_H */
43 #include "sysselect.h"
44 #include "blockinput.h"
46 #if defined DARWIN_OS || defined __FreeBSD__
47 # include <sys/sysctl.h>
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>
62 #define write sys_write
64 #define STDERR_FILENO fileno(GetStdHandle(STD_ERROR_HANDLE))
67 #endif /* not WINDOWSNT */
69 #include <sys/types.h>
73 /* Get SI_SRPC_DOMAIN, if it is available. */
74 #ifdef HAVE_SYS_SYSTEMINFO_H
75 #include <sys/systeminfo.h>
78 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
82 #include <sys/param.h>
89 #ifdef HAVE_SYS_UTSNAME_H
90 #include <sys/utsname.h>
92 #endif /* HAVE_SYS_UTSNAME_H */
96 #include "termhooks.h"
103 /* MS-Windows loads GnuTLS at run time, if available; we don't want to
104 do that during startup just to call gnutls_rnd. */
105 #if 0x020c00 <= GNUTLS_VERSION_NUMBER && !defined WINDOWSNT
106 # include <gnutls/crypto.h>
108 # define emacs_gnutls_global_init() Qnil
109 # define gnutls_rnd(level, data, len) (-1)
114 /* In process.h which conflicts with the local copy. */
116 int _cdecl
_spawnlp (int, const char *, const char *, ...);
117 int _cdecl
_getpid (void);
118 /* The following is needed for O_CLOEXEC, F_SETFD, FD_CLOEXEC, and
119 several prototypes of functions called below. */
120 #include <sys/socket.h>
123 #include "syssignal.h"
126 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
128 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
131 /* Declare here, including term.h is problematic on some systems. */
132 extern void tputs (const char *, int, int (*)(int));
134 static const int baud_convert
[] =
136 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
137 1800, 2400, 4800, 9600, 19200, 38400
140 #if !defined HAVE_GET_CURRENT_DIR_NAME || defined BROKEN_GET_CURRENT_DIR_NAME \
141 || (defined HYBRID_GET_CURRENT_DIR_NAME)
142 /* Return the current working directory. Returns NULL on errors.
143 Any other returned value must be freed with free. This is used
144 only when get_current_dir_name is not defined on the system. */
146 get_current_dir_name (void)
149 char *pwd
= getenv ("PWD");
150 struct stat dotstat
, pwdstat
;
151 /* If PWD is accurate, use it instead of calling getcwd. PWD is
152 sometimes a nicer name, and using it may avoid a fatal error if a
153 parent directory is searchable but not readable. */
155 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
156 && stat (pwd
, &pwdstat
) == 0
157 && stat (".", &dotstat
) == 0
158 && dotstat
.st_ino
== pwdstat
.st_ino
159 && dotstat
.st_dev
== pwdstat
.st_dev
161 && strlen (pwd
) < MAXPATHLEN
165 buf
= malloc (strlen (pwd
) + 1);
172 size_t buf_size
= 1024;
173 buf
= malloc (buf_size
);
178 if (getcwd (buf
, buf_size
) == buf
)
182 int tmp_errno
= errno
;
188 buf
= realloc (buf
, buf_size
);
198 /* Discard pending input on all input descriptors. */
201 discard_tty_input (void)
204 struct emacs_tty buf
;
209 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
210 while (dos_keyread () != -1)
212 #else /* not MSDOS */
214 struct tty_display_info
*tty
;
215 for (tty
= tty_list
; tty
; tty
= tty
->next
)
217 if (tty
->input
) /* Is the device suspended? */
219 emacs_get_tty (fileno (tty
->input
), &buf
);
220 emacs_set_tty (fileno (tty
->input
), &buf
, 0);
224 #endif /* not MSDOS */
225 #endif /* not WINDOWSNT */
231 /* Arrange for character C to be read as the next input from
233 XXX What if we have multiple ttys?
239 if (! (FRAMEP (selected_frame
)
240 && FRAME_LIVE_P (XFRAME (selected_frame
))
241 && FRAME_TERMCAP_P (XFRAME (selected_frame
))))
244 /* Should perhaps error if in batch mode */
246 ioctl (fileno (CURTTY()->input
), TIOCSTI
, &c
);
247 #else /* no TIOCSTI */
248 error ("Cannot stuff terminal input characters in this version of Unix");
249 #endif /* no TIOCSTI */
255 init_baud_rate (int fd
)
265 #else /* not DOS_NT */
270 emacs_ospeed
= cfgetospeed (&sg
);
271 #endif /* not DOS_NT */
274 baud_rate
= (emacs_ospeed
< ARRAYELTS (baud_convert
)
275 ? baud_convert
[emacs_ospeed
] : 9600);
284 /* Wait for the subprocess with process id CHILD to terminate or change status.
285 CHILD must be a child process that has not been reaped.
286 If STATUS is non-null, store the waitpid-style exit status into *STATUS
287 and tell wait_reading_process_output that it needs to look around.
288 Use waitpid-style OPTIONS when waiting.
289 If INTERRUPTIBLE, this function is interruptible by a signal.
291 Return CHILD if successful, 0 if no status is available;
292 the latter is possible only when options & NOHANG. */
294 get_child_status (pid_t child
, int *status
, int options
, bool interruptible
)
298 /* Invoke waitpid only with a known process ID; do not invoke
299 waitpid with a nonpositive argument. Otherwise, Emacs might
300 reap an unwanted process by mistake. For example, invoking
301 waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
302 so that another thread running glib won't find them. */
305 while ((pid
= waitpid (child
, status
, options
)) < 0)
307 /* Check that CHILD is a child process that has not been reaped,
308 and that STATUS and OPTIONS are valid. Otherwise abort,
309 as continuing after this internal error could cause Emacs to
310 become confused and kill innocent-victim processes. */
314 /* Note: the MS-Windows emulation of waitpid calls QUIT
320 /* If successful and status is requested, tell wait_reading_process_output
321 that it needs to wake up and look around. */
322 if (pid
&& status
&& input_available_clear_time
)
323 *input_available_clear_time
= make_timespec (0, 0);
328 /* Wait for the subprocess with process id CHILD to terminate.
329 CHILD must be a child process that has not been reaped.
330 If STATUS is non-null, store the waitpid-style exit status into *STATUS
331 and tell wait_reading_process_output that it needs to look around.
332 If INTERRUPTIBLE, this function is interruptible by a signal. */
334 wait_for_termination (pid_t child
, int *status
, bool interruptible
)
336 get_child_status (child
, status
, 0, interruptible
);
339 /* Report whether the subprocess with process id CHILD has changed status.
340 Termination counts as a change of status.
341 CHILD must be a child process that has not been reaped.
342 If STATUS is non-null, store the waitpid-style exit status into *STATUS
343 and tell wait_reading_process_output that it needs to look around.
344 Use waitpid-style OPTIONS to check status, but do not wait.
346 Return CHILD if successful, 0 if no status is available because
347 the process's state has not changed. */
349 child_status_changed (pid_t child
, int *status
, int options
)
351 return get_child_status (child
, status
, WNOHANG
| options
, 0);
355 /* Set up the terminal at the other end of a pseudo-terminal that
356 we will be controlling an inferior through.
357 It should not echo or do line-editing, since that is done
358 in Emacs. No padding needed for insertion into an Emacs buffer. */
361 child_setup_tty (int out
)
366 emacs_get_tty (out
, &s
);
367 s
.main
.c_oflag
|= OPOST
; /* Enable output postprocessing */
368 s
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL on output */
370 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
371 Some versions of GNU Hurd do not have FFDLY? */
373 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
|FFDLY
);
374 /* No output delays */
376 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
);
377 /* No output delays */
380 s
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
381 s
.main
.c_lflag
|= ISIG
; /* Enable signals */
383 s
.main
.c_iflag
&= ~IUCLC
; /* Disable downcasing on input. */
386 s
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
389 s
.main
.c_oflag
&= ~OLCUC
; /* Disable upcasing on output. */
391 s
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
392 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CSIZE
) | CS8
; /* Don't strip 8th bit */
393 s
.main
.c_cc
[VERASE
] = CDISABLE
; /* disable erase processing */
394 s
.main
.c_cc
[VKILL
] = CDISABLE
; /* disable kill processing */
397 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
400 #ifdef SIGNALS_VIA_CHARACTERS
401 /* the QUIT and INTR character are used in process_send_signal
402 so set them here to something useful. */
403 if (s
.main
.c_cc
[VQUIT
] == CDISABLE
)
404 s
.main
.c_cc
[VQUIT
] = '\\'&037; /* Control-\ */
405 if (s
.main
.c_cc
[VINTR
] == CDISABLE
)
406 s
.main
.c_cc
[VINTR
] = 'C'&037; /* Control-C */
407 #endif /* not SIGNALS_VIA_CHARACTERS */
410 /* Also, PTY overloads NUL and BREAK.
411 don't ignore break, but don't signal either, so it looks like NUL. */
412 s
.main
.c_iflag
&= ~IGNBRK
;
413 s
.main
.c_iflag
&= ~BRKINT
;
414 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
415 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
416 would force it to 0377. That looks like duplicated code. */
417 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
420 /* We originally enabled ICANON (and set VEOF to 04), and then had
421 process.c send additional EOF chars to flush the output when faced
422 with long lines, but this leads to weird effects when the
423 subprocess has disabled ICANON and ends up seeing those spurious
424 extra EOFs. So we don't send EOFs any more in
425 process.c:send_process. First we tried to disable ICANON by
426 default, so if a subsprocess sets up ICANON, it's his problem (or
427 the Elisp package that talks to it) to deal with lines that are
428 too long. But this disables some features, such as the ability
429 to send EOF signals. So we re-enabled ICANON but there is no
430 more "send eof to flush" going on (which is wrong and unportable
431 in itself). The correct way to handle too much output is to
432 buffer what could not be written and then write it again when
433 select returns ok for writing. This has it own set of
434 problems. Write is now asynchronous, is that a problem? How much
435 do we buffer, and what do we do when that limit is reached? */
437 s
.main
.c_lflag
|= ICANON
; /* Enable line editing and eof processing */
438 s
.main
.c_cc
[VEOF
] = 'D'&037; /* Control-D */
439 #if 0 /* These settings only apply to non-ICANON mode. */
440 s
.main
.c_cc
[VMIN
] = 1;
441 s
.main
.c_cc
[VTIME
] = 0;
444 emacs_set_tty (out
, &s
, 0);
445 #endif /* not WINDOWSNT */
447 #endif /* not MSDOS */
450 /* Record a signal code and the action for it. */
454 struct sigaction action
;
457 static void save_signal_handlers (struct save_signal
*);
458 static void restore_signal_handlers (struct save_signal
*);
460 /* Suspend the Emacs process; give terminal to its superior. */
468 /* On a system where suspending is not implemented,
469 instead fork a subshell and let it talk directly to the terminal
476 /* Fork a subshell. */
481 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
484 char oldwd
[MAXPATHLEN
+1]; /* Fixed length is safe on MSDOS. */
486 char oldwd
[MAX_UTF8_PATH
];
491 struct save_signal saved_handlers
[5];
492 char *str
= SSDATA (encode_current_directory ());
498 char *volatile str_volatile
= str
;
505 error ("Can't spawn subshell");
507 saved_handlers
[0].code
= SIGINT
;
508 saved_handlers
[1].code
= SIGQUIT
;
509 saved_handlers
[2].code
= SIGTERM
;
511 saved_handlers
[3].code
= SIGIO
;
512 saved_handlers
[4].code
= 0;
514 saved_handlers
[3].code
= 0;
518 save_signal_handlers (saved_handlers
);
525 #ifdef DOS_NT /* MW, Aug 1993 */
526 getcwd (oldwd
, sizeof oldwd
);
528 sh
= egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
531 sh
= egetenv ("SHELL");
535 /* Use our buffer's default directory for the subshell. */
536 if (chdir (str
) != 0)
540 _exit (EXIT_CANCELED
);
544 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
546 char *epwd
= getenv ("PWD");
547 char old_pwd
[MAXPATHLEN
+1+4];
549 /* If PWD is set, pass it with corrected value. */
552 strcpy (old_pwd
, epwd
);
553 setenv ("PWD", str
, 1);
556 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
558 putenv (old_pwd
); /* restore previous value */
560 #else /* not MSDOS */
562 /* Waits for process completion */
563 pid
= _spawnlp (_P_WAIT
, sh
, sh
, NULL
);
564 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
566 write (1, "Can't execute subshell", 22);
567 #else /* not WINDOWSNT */
568 execlp (sh
, sh
, (char *) 0);
570 _exit (errno
== ENOENT
? EXIT_ENOENT
: EXIT_CANNOT_INVOKE
);
571 #endif /* not WINDOWSNT */
572 #endif /* not MSDOS */
575 /* Do this now if we did not do it before. */
577 save_signal_handlers (saved_handlers
);
581 wait_for_termination (pid
, &status
, 0);
583 restore_signal_handlers (saved_handlers
);
587 save_signal_handlers (struct save_signal
*saved_handlers
)
589 while (saved_handlers
->code
)
591 struct sigaction action
;
592 emacs_sigaction_init (&action
, SIG_IGN
);
593 sigaction (saved_handlers
->code
, &action
, &saved_handlers
->action
);
599 restore_signal_handlers (struct save_signal
*saved_handlers
)
601 while (saved_handlers
->code
)
603 sigaction (saved_handlers
->code
, &saved_handlers
->action
, 0);
609 static int old_fcntl_flags
[FD_SETSIZE
];
616 old_fcntl_flags
[fd
] = fcntl (fd
, F_GETFL
, 0) & ~FASYNC
;
617 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
] | FASYNC
);
618 interrupts_deferred
= 0;
627 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
]);
641 sigemptyset (&unblocked
);
643 sigaddset (&unblocked
, SIGWINCH
);
645 sigaddset (&unblocked
, SIGIO
);
646 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
648 interrupts_deferred
= 0;
653 unrequest_sigio (void)
661 sigemptyset (&blocked
);
663 sigaddset (&blocked
, SIGWINCH
);
665 sigaddset (&blocked
, SIGIO
);
666 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
667 interrupts_deferred
= 1;
675 block_child_signal (sigset_t
*oldset
)
678 sigemptyset (&blocked
);
679 sigaddset (&blocked
, SIGCHLD
);
680 sigaddset (&blocked
, SIGINT
);
681 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
684 /* Unblock SIGCHLD. */
687 unblock_child_signal (sigset_t
const *oldset
)
689 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
694 /* Saving and restoring the process group of Emacs's terminal. */
696 /* The process group of which Emacs was a member when it initially
699 If Emacs was in its own process group (i.e. inherited_pgroup ==
700 getpid ()), then we know we're running under a shell with job
701 control (Emacs would never be run as part of a pipeline).
704 If Emacs was not in its own process group, then we know we're
705 running under a shell (or a caller) that doesn't know how to
706 separate itself from Emacs (like sh). Emacs must be in its own
707 process group in order to receive SIGIO correctly. In this
708 situation, we put ourselves in our own pgroup, forcibly set the
709 tty's pgroup to our pgroup, and make sure to restore and reinstate
710 the tty's pgroup just like any other terminal setting. If
711 inherited_group was not the tty's pgroup, then we'll get a
712 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
713 it goes foreground in the future, which is what should happen. */
715 static pid_t inherited_pgroup
;
718 init_foreground_group (void)
720 pid_t pgrp
= getpgrp ();
721 inherited_pgroup
= getpid () == pgrp
? 0 : pgrp
;
724 /* Block and unblock SIGTTOU. */
727 block_tty_out_signal (sigset_t
*oldset
)
731 sigemptyset (&blocked
);
732 sigaddset (&blocked
, SIGTTOU
);
733 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
738 unblock_tty_out_signal (sigset_t
const *oldset
)
741 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
745 /* Safely set a controlling terminal FD's process group to PGID.
746 If we are not in the foreground already, POSIX requires tcsetpgrp
747 to deliver a SIGTTOU signal, which would stop us. This is an
748 annoyance, so temporarily ignore the signal.
750 In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
751 skip all this unless SIGTTOU is defined. */
753 tcsetpgrp_without_stopping (int fd
, pid_t pgid
)
758 block_tty_out_signal (&oldset
);
759 tcsetpgrp (fd
, pgid
);
760 unblock_tty_out_signal (&oldset
);
765 /* Split off the foreground process group to Emacs alone. When we are
766 in the foreground, but not started in our own process group,
767 redirect the tty device handle FD to point to our own process
768 group. FD must be the file descriptor of the controlling tty. */
770 narrow_foreground_group (int fd
)
772 if (inherited_pgroup
&& setpgid (0, 0) == 0)
773 tcsetpgrp_without_stopping (fd
, getpid ());
776 /* Set the tty to our original foreground group. */
778 widen_foreground_group (int fd
)
780 if (inherited_pgroup
&& setpgid (0, inherited_pgroup
) == 0)
781 tcsetpgrp_without_stopping (fd
, inherited_pgroup
);
784 /* Getting and setting emacs_tty structures. */
786 /* Set *TC to the parameters associated with the terminal FD,
787 or clear it if the parameters are not available.
788 Return 0 on success, -1 on failure. */
790 emacs_get_tty (int fd
, struct emacs_tty
*settings
)
792 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
793 memset (&settings
->main
, 0, sizeof (settings
->main
));
796 HANDLE h
= (HANDLE
)_get_osfhandle (fd
);
799 if (h
&& h
!= INVALID_HANDLE_VALUE
&& GetConsoleMode (h
, &console_mode
))
801 settings
->main
= console_mode
;
804 #endif /* WINDOWSNT */
807 /* We have those nifty POSIX tcmumbleattr functions. */
808 return tcgetattr (fd
, &settings
->main
);
813 /* Set the parameters of the tty on FD according to the contents of
814 *SETTINGS. If FLUSHP, discard input.
815 Return 0 if all went well, and -1 (setting errno) if anything failed. */
818 emacs_set_tty (int fd
, struct emacs_tty
*settings
, bool flushp
)
820 /* Set the primary parameters - baud rate, character size, etcetera. */
823 HANDLE h
= (HANDLE
)_get_osfhandle (fd
);
825 if (h
&& h
!= INVALID_HANDLE_VALUE
)
829 /* Assume the handle is open for input. */
831 FlushConsoleInputBuffer (h
);
832 new_mode
= settings
->main
;
833 SetConsoleMode (h
, new_mode
);
835 #endif /* WINDOWSNT */
838 /* We have those nifty POSIX tcmumbleattr functions.
839 William J. Smith <wjs@wiis.wang.com> writes:
840 "POSIX 1003.1 defines tcsetattr to return success if it was
841 able to perform any of the requested actions, even if some
842 of the requested actions could not be performed.
843 We must read settings back to ensure tty setup properly.
844 AIX requires this to keep tty from hanging occasionally." */
845 /* This make sure that we don't loop indefinitely in here. */
846 for (i
= 0 ; i
< 10 ; i
++)
847 if (tcsetattr (fd
, flushp
? TCSAFLUSH
: TCSADRAIN
, &settings
->main
) < 0)
858 memset (&new, 0, sizeof (new));
859 /* Get the current settings, and see if they're what we asked for. */
860 tcgetattr (fd
, &new);
861 /* We cannot use memcmp on the whole structure here because under
862 * aix386 the termios structure has some reserved field that may
865 if ( new.c_iflag
== settings
->main
.c_iflag
866 && new.c_oflag
== settings
->main
.c_oflag
867 && new.c_cflag
== settings
->main
.c_cflag
868 && new.c_lflag
== settings
->main
.c_lflag
869 && memcmp (new.c_cc
, settings
->main
.c_cc
, NCCS
) == 0)
876 /* We have survived the tempest. */
883 static int old_fcntl_owner
[FD_SETSIZE
];
884 #endif /* F_SETOWN */
886 /* This may also be defined in stdio,
887 but if so, this does no harm,
888 and using the same name avoids wasting the other one's space. */
891 unsigned char _sobuf
[BUFSIZ
+8];
896 /* Initialize the terminal mode on all tty devices that are currently
900 init_all_sys_modes (void)
902 struct tty_display_info
*tty
;
903 for (tty
= tty_list
; tty
; tty
= tty
->next
)
904 init_sys_modes (tty
);
907 /* Initialize the terminal mode on the given tty device. */
910 init_sys_modes (struct tty_display_info
*tty_out
)
912 struct emacs_tty tty
;
913 Lisp_Object terminal
;
915 Vtty_erase_char
= Qnil
;
920 if (!tty_out
->output
)
921 return; /* The tty is suspended. */
923 narrow_foreground_group (fileno (tty_out
->input
));
925 if (! tty_out
->old_tty
)
926 tty_out
->old_tty
= xmalloc (sizeof *tty_out
->old_tty
);
928 emacs_get_tty (fileno (tty_out
->input
), tty_out
->old_tty
);
930 tty
= *tty_out
->old_tty
;
932 #if !defined (DOS_NT)
933 XSETINT (Vtty_erase_char
, tty
.main
.c_cc
[VERASE
]);
935 tty
.main
.c_iflag
|= (IGNBRK
); /* Ignore break condition */
936 tty
.main
.c_iflag
&= ~ICRNL
; /* Disable map of CR to NL on input */
937 #ifdef INLCR /* I'm just being cautious,
938 since I can't check how widespread INLCR is--rms. */
939 tty
.main
.c_iflag
&= ~INLCR
; /* Disable map of NL to CR on input */
942 tty
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
944 tty
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
945 tty
.main
.c_lflag
&= ~ICANON
; /* Disable erase/kill processing */
947 tty
.main
.c_lflag
&= ~IEXTEN
; /* Disable other editing characters. */
949 tty
.main
.c_lflag
|= ISIG
; /* Enable signals */
950 if (tty_out
->flow_control
)
952 tty
.main
.c_iflag
|= IXON
; /* Enable start/stop output control */
954 tty
.main
.c_iflag
&= ~IXANY
;
958 tty
.main
.c_iflag
&= ~IXON
; /* Disable start/stop output control */
959 tty
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL
961 tty
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
963 if (tty_out
->meta_key
)
965 tty
.main
.c_cflag
|= CS8
; /* allow 8th bit on input */
966 tty
.main
.c_cflag
&= ~PARENB
;/* Don't check parity */
970 XSETTERMINAL(terminal
, tty_out
->terminal
);
971 if (!NILP (Fcontrolling_tty_p (terminal
)))
973 tty
.main
.c_cc
[VINTR
] = quit_char
; /* C-g (usually) gives SIGINT */
974 /* Set up C-g for both SIGQUIT and SIGINT.
975 We don't know which we will get, but we handle both alike
976 so which one it really gives us does not matter. */
977 tty
.main
.c_cc
[VQUIT
] = quit_char
;
981 /* We normally don't get interrupt or quit signals from tty
982 devices other than our controlling terminal; therefore,
983 we must handle C-g as normal input. Unfortunately, this
984 means that the interrupt and quit feature must be
985 disabled on secondary ttys, or we would not even see the
988 Note that even though emacsclient could have special code
989 to pass SIGINT to Emacs, we should _not_ enable
990 interrupt/quit keys for emacsclient frames. This means
991 that we can't break out of loops in C code from a
992 secondary tty frame, but we can always decide what
993 display the C-g came from, which is more important from a
994 usability point of view. (Consider the case when two
995 people work together using the same Emacs instance.) */
996 tty
.main
.c_cc
[VINTR
] = CDISABLE
;
997 tty
.main
.c_cc
[VQUIT
] = CDISABLE
;
999 tty
.main
.c_cc
[VMIN
] = 1; /* Input should wait for at least 1 char */
1000 tty
.main
.c_cc
[VTIME
] = 0; /* no matter how long that takes. */
1002 tty
.main
.c_cc
[VSWTCH
] = CDISABLE
; /* Turn off shell layering use
1007 tty
.main
.c_cc
[VSUSP
] = CDISABLE
; /* Turn off handling of C-z. */
1010 tty
.main
.c_cc
[V_DSUSP
] = CDISABLE
; /* Turn off handling of C-y. */
1011 #endif /* V_DSUSP */
1012 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1013 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1016 tty
.main
.c_cc
[VLNEXT
] = CDISABLE
;
1019 tty
.main
.c_cc
[VREPRINT
] = CDISABLE
;
1020 #endif /* VREPRINT */
1022 tty
.main
.c_cc
[VWERASE
] = CDISABLE
;
1023 #endif /* VWERASE */
1025 tty
.main
.c_cc
[VDISCARD
] = CDISABLE
;
1026 #endif /* VDISCARD */
1028 if (tty_out
->flow_control
)
1031 tty
.main
.c_cc
[VSTART
] = '\021';
1034 tty
.main
.c_cc
[VSTOP
] = '\023';
1040 tty
.main
.c_cc
[VSTART
] = CDISABLE
;
1043 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1048 tty
.main
.c_cc
[VSTRT
] = CDISABLE
;
1049 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1050 tty
.main
.c_cc
[VSUSP
] = CDISABLE
;
1051 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1052 if (tty_out
->flow_control
)
1055 tty
.main
.c_cc
[VSTART
] = '\021';
1058 tty
.main
.c_cc
[VSTOP
] = '\023';
1061 /* Also, PTY overloads NUL and BREAK.
1062 don't ignore break, but don't signal either, so it looks like NUL.
1063 This really serves a purpose only if running in an XTERM window
1064 or via TELNET or the like, but does no harm elsewhere. */
1065 tty
.main
.c_iflag
&= ~IGNBRK
;
1066 tty
.main
.c_iflag
&= ~BRKINT
;
1068 #endif /* not DOS_NT */
1070 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1071 if (!tty_out
->term_initted
)
1072 internal_terminal_init ();
1073 dos_ttraw (tty_out
);
1076 emacs_set_tty (fileno (tty_out
->input
), &tty
, 0);
1078 /* This code added to insure that, if flow-control is not to be used,
1079 we have an unlocked terminal at the start. */
1082 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TCXONC
, 1);
1085 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TIOCSTART
, 0);
1088 #if !defined (DOS_NT)
1090 if (!tty_out
->flow_control
) tcflow (fileno (tty_out
->input
), TCOON
);
1095 if (interrupt_input
)
1097 old_fcntl_owner
[fileno (tty_out
->input
)] =
1098 fcntl (fileno (tty_out
->input
), F_GETOWN
, 0);
1099 fcntl (fileno (tty_out
->input
), F_SETOWN
, getpid ());
1100 init_sigio (fileno (tty_out
->input
));
1102 if (gpm_tty
== tty_out
)
1104 /* Arrange for mouse events to give us SIGIO signals. */
1105 fcntl (gpm_fd
, F_SETOWN
, getpid ());
1106 fcntl (gpm_fd
, F_SETFL
, fcntl (gpm_fd
, F_GETFL
, 0) | O_NONBLOCK
);
1107 init_sigio (gpm_fd
);
1109 #endif /* HAVE_GPM */
1111 #endif /* F_GETOWN */
1114 /* This symbol is defined on recent USG systems.
1115 Someone says without this call USG won't really buffer the file
1116 even with a call to setbuf. */
1117 setvbuf (tty_out
->output
, (char *) _sobuf
, _IOFBF
, sizeof _sobuf
);
1119 setbuf (tty_out
->output
, (char *) _sobuf
);
1122 if (tty_out
->terminal
->set_terminal_modes_hook
)
1123 tty_out
->terminal
->set_terminal_modes_hook (tty_out
->terminal
);
1125 if (!tty_out
->term_initted
)
1127 Lisp_Object tail
, frame
;
1128 FOR_EACH_FRAME (tail
, frame
)
1130 /* XXX This needs to be revised. */
1131 if (FRAME_TERMCAP_P (XFRAME (frame
))
1132 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1133 init_frame_faces (XFRAME (frame
));
1137 if (tty_out
->term_initted
&& no_redraw_on_reenter
)
1139 /* We used to call "direct_output_forward_char(0)" here,
1140 but it's not clear why, since it may not do anything anyway. */
1144 Lisp_Object tail
, frame
;
1146 FOR_EACH_FRAME (tail
, frame
)
1148 if ((FRAME_TERMCAP_P (XFRAME (frame
))
1149 || FRAME_MSDOS_P (XFRAME (frame
)))
1150 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1151 FRAME_GARBAGED_P (XFRAME (frame
)) = 1;
1155 tty_out
->term_initted
= 1;
1158 /* Return true if safe to use tabs in output.
1159 At the time this is called, init_sys_modes has not been done yet. */
1162 tabs_safe_p (int fd
)
1164 struct emacs_tty etty
;
1166 emacs_get_tty (fd
, &etty
);
1169 return ((etty
.main
.c_oflag
& TABDLY
) != TAB3
);
1170 #else /* not TABDLY */
1172 #endif /* not TABDLY */
1178 /* Discard echoing. */
1181 suppress_echo_on_tty (int fd
)
1183 struct emacs_tty etty
;
1185 emacs_get_tty (fd
, &etty
);
1187 /* Set raw input mode. */
1190 etty
.main
.c_lflag
&= ~ICANON
; /* Disable buffering */
1191 etty
.main
.c_lflag
&= ~ECHO
; /* Disable echoing */
1192 #endif /* ! WINDOWSNT */
1193 emacs_set_tty (fd
, &etty
, 0);
1196 /* Get terminal size from system.
1197 Store number of lines into *HEIGHTP and width into *WIDTHP.
1198 We store 0 if there's no valid information. */
1201 get_tty_size (int fd
, int *widthp
, int *heightp
)
1203 #if defined TIOCGWINSZ
1206 struct winsize size
;
1208 if (ioctl (fd
, TIOCGWINSZ
, &size
) == -1)
1209 *widthp
= *heightp
= 0;
1212 *widthp
= size
.ws_col
;
1213 *heightp
= size
.ws_row
;
1216 #elif defined TIOCGSIZE
1218 /* SunOS - style. */
1219 struct ttysize size
;
1221 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1222 *widthp
= *heightp
= 0;
1225 *widthp
= size
.ts_cols
;
1226 *heightp
= size
.ts_lines
;
1229 #elif defined WINDOWSNT
1231 CONSOLE_SCREEN_BUFFER_INFO info
;
1232 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE
), &info
))
1234 *widthp
= info
.srWindow
.Right
- info
.srWindow
.Left
+ 1;
1235 *heightp
= info
.srWindow
.Bottom
- info
.srWindow
.Top
+ 1;
1238 *widthp
= *heightp
= 0;
1242 *widthp
= ScreenCols ();
1243 *heightp
= ScreenRows ();
1245 #else /* system doesn't know size */
1253 /* Set the logical window size associated with descriptor FD
1254 to HEIGHT and WIDTH. This is used mainly with ptys.
1255 Return a negative value on failure. */
1258 set_window_size (int fd
, int height
, int width
)
1263 struct winsize size
;
1264 size
.ws_row
= height
;
1265 size
.ws_col
= width
;
1267 return ioctl (fd
, TIOCSWINSZ
, &size
);
1272 /* SunOS - style. */
1273 struct ttysize size
;
1274 size
.ts_lines
= height
;
1275 size
.ts_cols
= width
;
1277 return ioctl (fd
, TIOCGSIZE
, &size
);
1280 #endif /* not SunOS-style */
1281 #endif /* not BSD-style */
1286 /* Prepare all terminal devices for exiting Emacs. */
1289 reset_all_sys_modes (void)
1291 struct tty_display_info
*tty
;
1292 for (tty
= tty_list
; tty
; tty
= tty
->next
)
1293 reset_sys_modes (tty
);
1296 /* Prepare the terminal for closing it; move the cursor to the
1297 bottom of the frame, turn off interrupt-driven I/O, etc. */
1300 reset_sys_modes (struct tty_display_info
*tty_out
)
1307 if (!tty_out
->term_initted
)
1310 if (!tty_out
->output
)
1311 return; /* The tty is suspended. */
1313 /* Go to and clear the last line of the terminal. */
1315 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1317 /* Code adapted from tty_clear_end_of_line. */
1318 if (tty_out
->TS_clr_line
)
1320 emacs_tputs (tty_out
, tty_out
->TS_clr_line
, 1, cmputc
);
1323 { /* have to do it the hard way */
1325 tty_turn_off_insert (tty_out
);
1327 for (i
= cursorX (tty_out
); i
< FrameCols (tty_out
) - 1; i
++)
1329 fputc (' ', tty_out
->output
);
1333 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1334 fflush (tty_out
->output
);
1336 if (tty_out
->terminal
->reset_terminal_modes_hook
)
1337 tty_out
->terminal
->reset_terminal_modes_hook (tty_out
->terminal
);
1339 /* Avoid possible loss of output when changing terminal modes. */
1340 while (fdatasync (fileno (tty_out
->output
)) != 0 && errno
== EINTR
)
1345 if (interrupt_input
)
1347 reset_sigio (fileno (tty_out
->input
));
1348 fcntl (fileno (tty_out
->input
), F_SETOWN
,
1349 old_fcntl_owner
[fileno (tty_out
->input
)]);
1351 #endif /* F_SETOWN */
1352 fcntl (fileno (tty_out
->input
), F_SETFL
,
1353 fcntl (fileno (tty_out
->input
), F_GETFL
, 0) & ~O_NONBLOCK
);
1356 if (tty_out
->old_tty
)
1357 while (emacs_set_tty (fileno (tty_out
->input
),
1358 tty_out
->old_tty
, 0) < 0 && errno
== EINTR
)
1361 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1365 widen_foreground_group (fileno (tty_out
->input
));
1370 /* Set up the proper status flags for use of a pty. */
1375 /* I'm told that TOICREMOTE does not mean control chars
1376 "can't be sent" but rather that they don't have
1377 input-editing or signaling effects.
1378 That should be good, because we have other ways
1379 to do those things in Emacs.
1380 However, telnet mode seems not to work on 4.2.
1381 So TIOCREMOTE is turned off now. */
1383 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1384 will hang. In particular, the "timeout" feature (which
1385 causes a read to return if there is no data available)
1386 does this. Also it is known that telnet mode will hang
1387 in such a way that Emacs must be stopped (perhaps this
1388 is the same problem).
1390 If TIOCREMOTE is turned off, then there is a bug in
1391 hp-ux which sometimes loses data. Apparently the
1392 code which blocks the master process when the internal
1393 buffer fills up does not work. Other than this,
1394 though, everything else seems to work fine.
1396 Since the latter lossage is more benign, we may as well
1397 lose that way. -- cph */
1399 #if defined (UNIX98_PTYS)
1402 ioctl (fd
, FIONBIO
, &on
);
1407 #endif /* HAVE_PTYS */
1410 init_system_name (void)
1412 char *hostname_alloc
= NULL
;
1414 #ifndef HAVE_GETHOSTNAME
1417 hostname
= uts
.nodename
;
1418 #else /* HAVE_GETHOSTNAME */
1419 char hostname_buf
[256];
1420 ptrdiff_t hostname_size
= sizeof hostname_buf
;
1421 hostname
= hostname_buf
;
1423 /* Try to get the host name; if the buffer is too short, try
1424 again. Apparently, the only indication gethostname gives of
1425 whether the buffer was large enough is the presence or absence
1426 of a '\0' in the string. Eech. */
1429 gethostname (hostname
, hostname_size
- 1);
1430 hostname
[hostname_size
- 1] = '\0';
1432 /* Was the buffer large enough for the '\0'? */
1433 if (strlen (hostname
) < hostname_size
- 1)
1436 hostname
= hostname_alloc
= xpalloc (hostname_alloc
, &hostname_size
, 1,
1437 min (PTRDIFF_MAX
, SIZE_MAX
), 1);
1439 #endif /* HAVE_GETHOSTNAME */
1441 for (p
= hostname
; *p
; p
++)
1442 if (*p
== ' ' || *p
== '\t')
1444 if (! (STRINGP (Vsystem_name
) && SBYTES (Vsystem_name
) == p
- hostname
1445 && strcmp (SSDATA (Vsystem_name
), hostname
) == 0))
1446 Vsystem_name
= build_string (hostname
);
1447 xfree (hostname_alloc
);
1450 sigset_t empty_mask
;
1452 static struct sigaction process_fatal_action
;
1455 emacs_sigaction_flags (void)
1458 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1459 'select') to reset their timeout on some platforms (e.g.,
1460 HP-UX 11), which is not what we want. Also, when Emacs is
1461 interactive, we don't want SA_RESTART because we need to poll
1462 for pending input so we need long-running syscalls to be interrupted
1463 after a signal that sets pending_signals.
1465 Non-interactive keyboard input goes through stdio, where we
1466 always want restartable system calls. */
1473 /* Store into *ACTION a signal action suitable for Emacs, with handler
1476 emacs_sigaction_init (struct sigaction
*action
, signal_handler_t handler
)
1478 sigemptyset (&action
->sa_mask
);
1480 /* When handling a signal, block nonfatal system signals that are caught
1481 by Emacs. This makes race conditions less likely. */
1482 sigaddset (&action
->sa_mask
, SIGALRM
);
1484 sigaddset (&action
->sa_mask
, SIGCHLD
);
1487 sigaddset (&action
->sa_mask
, SIGDANGER
);
1489 #ifdef PROFILER_CPU_SUPPORT
1490 sigaddset (&action
->sa_mask
, SIGPROF
);
1493 sigaddset (&action
->sa_mask
, SIGWINCH
);
1495 if (! noninteractive
)
1497 sigaddset (&action
->sa_mask
, SIGINT
);
1498 sigaddset (&action
->sa_mask
, SIGQUIT
);
1500 sigaddset (&action
->sa_mask
, SIGIO
);
1504 action
->sa_handler
= handler
;
1505 action
->sa_flags
= emacs_sigaction_flags ();
1508 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1509 static pthread_t main_thread
;
1512 /* SIG has arrived at the current process. Deliver it to the main
1513 thread, which should handle it with HANDLER.
1515 If we are on the main thread, handle the signal SIG with HANDLER.
1516 Otherwise, redirect the signal to the main thread, blocking it from
1517 this thread. POSIX says any thread can receive a signal that is
1518 associated with a process, process group, or asynchronous event.
1519 On GNU/Linux that is not true, but for other systems (FreeBSD at
1522 deliver_process_signal (int sig
, signal_handler_t handler
)
1524 /* Preserve errno, to avoid race conditions with signal handlers that
1525 might change errno. Races can occur even in single-threaded hosts. */
1526 int old_errno
= errno
;
1528 bool on_main_thread
= true;
1529 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1530 if (! pthread_equal (pthread_self (), main_thread
))
1533 sigemptyset (&blocked
);
1534 sigaddset (&blocked
, sig
);
1535 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1536 pthread_kill (main_thread
, sig
);
1537 on_main_thread
= false;
1546 /* Static location to save a fatal backtrace in a thread.
1547 FIXME: If two subsidiary threads fail simultaneously, the resulting
1548 backtrace may be garbage. */
1549 enum { BACKTRACE_LIMIT_MAX
= 500 };
1550 static void *thread_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
1551 static int thread_backtrace_npointers
;
1553 /* SIG has arrived at the current thread.
1554 If we are on the main thread, handle the signal SIG with HANDLER.
1555 Otherwise, this is a fatal error in the handling thread. */
1557 deliver_thread_signal (int sig
, signal_handler_t handler
)
1559 int old_errno
= errno
;
1561 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1562 if (! pthread_equal (pthread_self (), main_thread
))
1564 thread_backtrace_npointers
1565 = backtrace (thread_backtrace_buffer
, BACKTRACE_LIMIT_MAX
);
1566 sigaction (sig
, &process_fatal_action
, 0);
1567 pthread_kill (main_thread
, sig
);
1569 /* Avoid further damage while the main thread is exiting. */
1571 sigsuspend (&empty_mask
);
1579 #if !HAVE_DECL_SYS_SIGLIST
1581 # ifdef _sys_siglist
1582 # define sys_siglist _sys_siglist
1583 # elif HAVE_DECL___SYS_SIGLIST
1584 # define sys_siglist __sys_siglist
1586 # define sys_siglist my_sys_siglist
1587 static char const *sys_siglist
[NSIG
];
1592 # define sys_siglist_entries _sys_nsig
1594 # define sys_siglist_entries NSIG
1597 /* Handle bus errors, invalid instruction, etc. */
1599 handle_fatal_signal (int sig
)
1601 terminate_due_to_signal (sig
, 40);
1605 deliver_fatal_signal (int sig
)
1607 deliver_process_signal (sig
, handle_fatal_signal
);
1611 deliver_fatal_thread_signal (int sig
)
1613 deliver_thread_signal (sig
, handle_fatal_signal
);
1616 static _Noreturn
void
1617 handle_arith_signal (int sig
)
1619 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1620 xsignal0 (Qarith_error
);
1623 #if defined HAVE_STACK_OVERFLOW_HANDLING && !defined WINDOWSNT
1625 /* Alternate stack used by SIGSEGV handler below. */
1627 static unsigned char sigsegv_stack
[SIGSTKSZ
];
1630 /* Return true if SIGINFO indicates a stack overflow. */
1633 stack_overflow (siginfo_t
*siginfo
)
1635 /* In theory, a more-accurate heuristic can be obtained by using
1636 GNU/Linux pthread_getattr_np along with POSIX pthread_attr_getstack
1637 and pthread_attr_getguardsize to find the location and size of the
1638 guard area. In practice, though, these functions are so hard to
1639 use reliably that they're not worth bothering with. E.g., see:
1640 https://sourceware.org/bugzilla/show_bug.cgi?id=16291
1641 Other operating systems also have problems, e.g., Solaris's
1642 stack_violation function is tailor-made for this problem, but it
1643 doesn't work on Solaris 11.2 x86-64 with a 32-bit executable.
1645 GNU libsigsegv is overkill for Emacs; otherwise it might be a
1651 /* The faulting address. */
1652 char *addr
= siginfo
->si_addr
;
1656 /* The known top and bottom of the stack. The actual stack may
1657 extend a bit beyond these boundaries. */
1658 char *bot
= stack_bottom
;
1659 char *top
= near_C_stack_top ();
1661 /* Log base 2 of the stack heuristic ratio. This ratio is the size
1662 of the known stack divided by the size of the guard area past the
1663 end of the stack top. The heuristic is that a bad address is
1664 considered to be a stack overflow if it occurs within
1665 stacksize>>LG_STACK_HEURISTIC bytes above the top of the known
1666 stack. This heuristic is not exactly correct but it's good
1667 enough in practice. */
1668 enum { LG_STACK_HEURISTIC
= 8 };
1671 return 0 <= addr
- top
&& addr
- top
< (top
- bot
) >> LG_STACK_HEURISTIC
;
1673 return 0 <= top
- addr
&& top
- addr
< (bot
- top
) >> LG_STACK_HEURISTIC
;
1677 /* Attempt to recover from SIGSEGV caused by C stack overflow. */
1680 handle_sigsegv (int sig
, siginfo_t
*siginfo
, void *arg
)
1682 /* Hard GC error may lead to stack overflow caused by
1683 too nested calls to mark_object. No way to survive. */
1684 bool fatal
= gc_in_progress
;
1686 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1687 if (!fatal
&& !pthread_equal (pthread_self (), main_thread
))
1691 if (!fatal
&& stack_overflow (siginfo
))
1692 siglongjmp (return_to_command_loop
, 1);
1694 /* Otherwise we can't do anything with this. */
1695 deliver_fatal_thread_signal (sig
);
1698 /* Return true if we have successfully set up SIGSEGV handler on alternate
1699 stack. Otherwise we just treat SIGSEGV among the rest of fatal signals. */
1704 struct sigaction sa
;
1707 ss
.ss_sp
= sigsegv_stack
;
1708 ss
.ss_size
= sizeof (sigsegv_stack
);
1710 if (sigaltstack (&ss
, NULL
) < 0)
1713 sigfillset (&sa
.sa_mask
);
1714 sa
.sa_sigaction
= handle_sigsegv
;
1715 sa
.sa_flags
= SA_SIGINFO
| SA_ONSTACK
| emacs_sigaction_flags ();
1716 return sigaction (SIGSEGV
, &sa
, NULL
) < 0 ? 0 : 1;
1719 #else /* not HAVE_STACK_OVERFLOW_HANDLING or WINDOWSNT */
1727 #endif /* HAVE_STACK_OVERFLOW_HANDLING && !WINDOWSNT */
1730 deliver_arith_signal (int sig
)
1732 deliver_thread_signal (sig
, handle_arith_signal
);
1737 /* Handler for SIGDANGER. */
1739 handle_danger_signal (int sig
)
1741 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1743 /* It might be unsafe to call do_auto_save now. */
1744 force_auto_save_soon ();
1748 deliver_danger_signal (int sig
)
1750 deliver_process_signal (sig
, handle_danger_signal
);
1754 /* Treat SIG as a terminating signal, unless it is already ignored and
1755 we are in --batch mode. Among other things, this makes nohup work. */
1757 maybe_fatal_sig (int sig
)
1759 bool catch_sig
= !noninteractive
;
1762 struct sigaction old_action
;
1763 sigaction (sig
, 0, &old_action
);
1764 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1767 sigaction (sig
, &process_fatal_action
, 0);
1771 init_signals (bool dumping
)
1773 struct sigaction thread_fatal_action
;
1774 struct sigaction action
;
1776 sigemptyset (&empty_mask
);
1778 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1779 main_thread
= pthread_self ();
1782 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1785 sys_siglist
[SIGABRT
] = "Aborted";
1787 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1789 sys_siglist
[SIGALRM
] = "Alarm clock";
1791 sys_siglist
[SIGBUS
] = "Bus error";
1794 sys_siglist
[SIGCHLD
] = "Child status changed";
1797 sys_siglist
[SIGCONT
] = "Continued";
1800 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1803 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1806 sys_siglist
[SIGEMT
] = "Emulation trap";
1808 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1810 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1813 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1815 sys_siglist
[SIGHUP
] = "Hangup";
1816 sys_siglist
[SIGILL
] = "Illegal instruction";
1817 sys_siglist
[SIGINT
] = "Interrupt";
1819 sys_siglist
[SIGIO
] = "I/O possible";
1822 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1825 sys_siglist
[SIGIOT
] = "IOT trap";
1827 sys_siglist
[SIGKILL
] = "Killed";
1829 sys_siglist
[SIGLOST
] = "Resource lost";
1832 sys_siglist
[SIGLWP
] = "SIGLWP";
1835 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1838 sys_siglist
[SIGWIND
] = "SIGPHONE";
1840 sys_siglist
[SIGPIPE
] = "Broken pipe";
1842 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1845 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1848 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1851 sys_siglist
[SIGPWR
] = "Power-fail restart";
1853 sys_siglist
[SIGQUIT
] = "Quit";
1855 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1858 sys_siglist
[SIGSAK
] = "Secure attention";
1860 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1862 sys_siglist
[SIGSOUND
] = "Sound completed";
1865 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1868 sys_siglist
[SIGSTP
] = "Stopped (user)";
1871 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1873 sys_siglist
[SIGTERM
] = "Terminated";
1875 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1878 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1881 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1884 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1887 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1890 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1893 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1896 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1899 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1902 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1905 sys_siglist
[SIGWINCH
] = "Window size changed";
1908 sys_siglist
[SIGWIND
] = "SIGWIND";
1911 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1914 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1917 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1919 /* Don't alter signal handlers if dumping. On some machines,
1920 changing signal handlers sets static data that would make signals
1921 fail to work right when the dumped Emacs is run. */
1925 sigfillset (&process_fatal_action
.sa_mask
);
1926 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1927 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1929 sigfillset (&thread_fatal_action
.sa_mask
);
1930 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1931 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1933 /* SIGINT may need special treatment on MS-Windows. See
1934 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1935 Please update the doc of kill-emacs, kill-emacs-hook, and
1936 NEWS if you change this. */
1938 maybe_fatal_sig (SIGHUP
);
1939 maybe_fatal_sig (SIGINT
);
1940 maybe_fatal_sig (SIGTERM
);
1942 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1943 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1944 to behave more like typical batch applications do. */
1945 if (! noninteractive
)
1946 signal (SIGPIPE
, SIG_IGN
);
1948 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1949 sigaction (SIGILL
, &thread_fatal_action
, 0);
1950 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1952 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1953 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1954 interpreter's floating point operations, so treat SIGFPE as an
1955 arith-error if it arises in the main thread. */
1956 if (IEEE_FLOATING_POINT
)
1957 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1960 emacs_sigaction_init (&action
, deliver_arith_signal
);
1961 sigaction (SIGFPE
, &action
, 0);
1965 add_user_signal (SIGUSR1
, "sigusr1");
1968 add_user_signal (SIGUSR2
, "sigusr2");
1970 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1972 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1975 sigaction (SIGORE
, &thread_fatal_action
, 0);
1978 sigaction (SIGUME
, &thread_fatal_action
, 0);
1981 sigaction (SIGDLK
, &process_fatal_action
, 0);
1984 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1987 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1990 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1993 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1995 if (!init_sigsegv ())
1996 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
1998 sigaction (SIGSYS
, &thread_fatal_action
, 0);
2000 sigaction (SIGTERM
, &process_fatal_action
, 0);
2002 signal (SIGPROF
, SIG_IGN
);
2005 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
2008 sigaction (SIGXCPU
, &process_fatal_action
, 0);
2011 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
2015 /* This just means available memory is getting low. */
2016 emacs_sigaction_init (&action
, deliver_danger_signal
);
2017 sigaction (SIGDANGER
, &action
, 0);
2020 /* AIX-specific signals. */
2022 sigaction (SIGGRANT
, &process_fatal_action
, 0);
2025 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
2028 sigaction (SIGMSG
, &process_fatal_action
, 0);
2031 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
2034 sigaction (SIGSAK
, &process_fatal_action
, 0);
2037 sigaction (SIGSOUND
, &process_fatal_action
, 0);
2040 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
2050 /* Figure out how many bits the system's random number generator uses.
2051 `random' and `lrand48' are assumed to return 31 usable bits.
2052 BSD `rand' returns a 31 bit value but the low order bits are unusable;
2053 so we'll shift it and treat it like the 15-bit USG `rand'. */
2057 # define RAND_BITS 31
2058 # else /* !HAVE_RANDOM */
2059 # ifdef HAVE_LRAND48
2060 # define RAND_BITS 31
2061 # define random lrand48
2062 # else /* !HAVE_LRAND48 */
2063 # define RAND_BITS 15
2064 # if RAND_MAX == 32767
2065 # define random rand
2066 # else /* RAND_MAX != 32767 */
2067 # if RAND_MAX == 2147483647
2068 # define random() (rand () >> 16)
2069 # else /* RAND_MAX != 2147483647 */
2071 # define random rand
2073 # define random() (rand () >> 16)
2075 # endif /* RAND_MAX != 2147483647 */
2076 # endif /* RAND_MAX != 32767 */
2077 # endif /* !HAVE_LRAND48 */
2078 # endif /* !HAVE_RANDOM */
2079 #endif /* !RAND_BITS */
2082 typedef unsigned int random_seed
;
2083 static void set_random_seed (random_seed arg
) { srandom (arg
); }
2084 #elif defined HAVE_LRAND48
2085 /* Although srand48 uses a long seed, this is unsigned long to avoid
2086 undefined behavior on signed integer overflow in init_random. */
2087 typedef unsigned long int random_seed
;
2088 static void set_random_seed (random_seed arg
) { srand48 (arg
); }
2090 typedef unsigned int random_seed
;
2091 static void set_random_seed (random_seed arg
) { srand (arg
); }
2095 seed_random (void *seed
, ptrdiff_t seed_size
)
2097 random_seed arg
= 0;
2098 unsigned char *argp
= (unsigned char *) &arg
;
2099 unsigned char *seedp
= seed
;
2100 for (ptrdiff_t i
= 0; i
< seed_size
; i
++)
2101 argp
[i
% sizeof arg
] ^= seedp
[i
];
2102 set_random_seed (arg
);
2109 bool success
= false;
2111 /* First, try seeding the PRNG from the operating system's entropy
2112 source. This approach is both fast and secure. */
2114 success
= w32_init_random (&v
, sizeof v
) == 0;
2116 int fd
= emacs_open ("/dev/urandom", O_RDONLY
, 0);
2119 success
= emacs_read (fd
, &v
, sizeof v
) == sizeof v
;
2124 /* If that didn't work, try using GnuTLS, which is secure, but on
2125 some systems, can be somewhat slow. */
2127 success
= EQ (emacs_gnutls_global_init (), Qt
)
2128 && gnutls_rnd (GNUTLS_RND_NONCE
, &v
, sizeof v
) == 0;
2130 /* If _that_ didn't work, just use the current time value and PID.
2131 It's at least better than XKCD 221. */
2134 struct timespec t
= current_timespec ();
2135 v
= getpid () ^ t
.tv_sec
^ t
.tv_nsec
;
2138 set_random_seed (v
);
2142 * Return a nonnegative random integer out of whatever we've got.
2143 * It contains enough bits to make a random (signed) Emacs fixnum.
2144 * This suffices even for a 64-bit architecture with a 15-bit rand.
2151 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2152 val
= (random () ^ (val
<< RAND_BITS
)
2153 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2154 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2155 return val
& INTMASK
;
2158 #ifndef HAVE_SNPRINTF
2159 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2161 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2163 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2164 ptrdiff_t nbytes
= size
- 1;
2169 va_start (ap
, format
);
2170 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2174 if (nbytes
== size
- 1)
2176 /* Calculate the length of the string that would have been created
2177 had the buffer been large enough. */
2178 char stackbuf
[4000];
2180 ptrdiff_t bsize
= sizeof stackbuf
;
2181 va_start (ap
, format
);
2182 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2188 if (INT_MAX
< nbytes
)
2201 /* If a backtrace is available, output the top lines of it to stderr.
2202 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2203 This function may be called from a signal handler, so it should
2204 not invoke async-unsafe functions like malloc.
2206 If BACKTRACE_LIMIT is -1, initialize tables that 'backtrace' uses
2207 but do not output anything. This avoids some problems that can
2208 otherwise occur if the malloc arena is corrupted before 'backtrace'
2209 is called, since 'backtrace' may call malloc if the tables are not
2212 If the static variable THREAD_BACKTRACE_NPOINTERS is nonzero, a
2213 fatal error has occurred in some other thread; generate a thread
2214 backtrace instead, ignoring BACKTRACE_LIMIT. */
2216 emacs_backtrace (int backtrace_limit
)
2218 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2219 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2223 if (thread_backtrace_npointers
)
2225 buffer
= thread_backtrace_buffer
;
2226 npointers
= thread_backtrace_npointers
;
2230 buffer
= main_backtrace_buffer
;
2232 /* Work around 'backtrace' bug; see Bug#19959 and glibc bug#18084. */
2233 if (bounded_limit
< 0)
2235 backtrace (buffer
, 1);
2239 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2244 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2245 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2246 if (bounded_limit
< npointers
)
2247 emacs_write (STDERR_FILENO
, "...\n", 4);
2255 terminate_due_to_signal (SIGABRT
, 40);
2259 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2260 Use binary I/O on systems that care about text vs binary I/O.
2261 Arrange for subprograms to not inherit the file descriptor.
2262 Prefer a method that is multithread-safe, if available.
2263 Do not fail merely because the open was interrupted by a signal.
2264 Allow the user to quit. */
2267 emacs_open (const char *file
, int oflags
, int mode
)
2270 if (! (oflags
& O_TEXT
))
2272 oflags
|= O_CLOEXEC
;
2273 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2275 if (! O_CLOEXEC
&& 0 <= fd
)
2276 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2280 /* Open FILE as a stream for Emacs use, with mode MODE.
2281 Act like emacs_open with respect to threads, signals, and quits. */
2284 emacs_fopen (char const *file
, char const *mode
)
2286 int fd
, omode
, oflags
;
2288 char const *m
= mode
;
2292 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2293 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2294 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2295 default: emacs_abort ();
2301 case '+': omode
= O_RDWR
; break;
2302 case 'b': bflag
= O_BINARY
; break;
2303 case 't': bflag
= O_TEXT
; break;
2304 default: /* Ignore. */ break;
2307 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2308 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2311 /* Create a pipe for Emacs use. */
2314 emacs_pipe (int fd
[2])
2319 int result
= pipe2 (fd
, O_BINARY
| O_CLOEXEC
);
2320 if (! O_CLOEXEC
&& result
== 0)
2322 fcntl (fd
[0], F_SETFD
, FD_CLOEXEC
);
2323 fcntl (fd
[1], F_SETFD
, FD_CLOEXEC
);
2329 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2330 For the background behind this mess, please see Austin Group defect 529
2331 <http://austingroupbugs.net/view.php?id=529>. */
2333 #ifndef POSIX_CLOSE_RESTART
2334 # define POSIX_CLOSE_RESTART 1
2336 posix_close (int fd
, int flag
)
2338 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2339 eassert (flag
== POSIX_CLOSE_RESTART
);
2341 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2342 on a system that does not define POSIX_CLOSE_RESTART.
2344 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2345 closed, and retrying the close could inadvertently close a file
2346 descriptor allocated by some other thread. In other systems
2347 (e.g., HP/UX) FD is not closed. And in still other systems
2348 (e.g., macOS, Solaris), maybe FD is closed, maybe not, and in a
2349 multithreaded program there can be no way to tell.
2351 So, in this case, pretend that the close succeeded. This works
2352 well on systems like GNU/Linux that close FD. Although it may
2353 leak a file descriptor on other systems, the leak is unlikely and
2354 it's better to leak than to close a random victim. */
2355 return close (fd
) == 0 || errno
== EINTR
? 0 : -1;
2359 /* Close FD, retrying if interrupted. If successful, return 0;
2360 otherwise, return -1 and set errno to a non-EINTR value. Consider
2361 an EINPROGRESS error to be successful, as that's merely a signal
2362 arriving. FD is always closed when this function returns, even
2365 Do not call this function if FD is nonnegative and might already be closed,
2366 as that might close an innocent victim opened by some other thread. */
2369 emacs_close (int fd
)
2373 int r
= posix_close (fd
, POSIX_CLOSE_RESTART
);
2376 if (!POSIX_CLOSE_RESTART
|| errno
!= EINTR
)
2378 eassert (errno
!= EBADF
|| fd
< 0);
2379 return errno
== EINPROGRESS
? 0 : r
;
2384 /* Maximum number of bytes to read or write in a single system call.
2385 This works around a serious bug in Linux kernels before 2.6.16; see
2386 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2387 It's likely to work around similar bugs in other operating systems, so do it
2388 on all platforms. Round INT_MAX down to a page size, with the conservative
2389 assumption that page sizes are at most 2**18 bytes (any kernel with a
2390 page size larger than that shouldn't have the bug). */
2391 #ifndef MAX_RW_COUNT
2392 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2395 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2396 Return the number of bytes read, which might be less than NBYTE.
2397 On error, set errno and return -1. */
2399 emacs_read (int fildes
, void *buf
, ptrdiff_t nbyte
)
2403 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2404 passes a size that large to emacs_read. */
2406 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2407 && (errno
== EINTR
))
2412 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2413 or if a partial write occurs. If interrupted, process pending
2414 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2415 errno if this is less than NBYTE. */
2417 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2418 bool process_signals
)
2420 ptrdiff_t bytes_written
= 0;
2424 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2430 /* I originally used `QUIT' but that might cause files to
2431 be truncated if you hit C-g in the middle of it. --Stef */
2432 if (process_signals
&& pending_signals
)
2433 process_pending_signals ();
2445 return bytes_written
;
2448 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2449 interrupted or if a partial write occurs. Return the number of
2450 bytes written, setting errno if this is less than NBYTE. */
2452 emacs_write (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2454 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2457 /* Like emacs_write, but also process pending signals if interrupted. */
2459 emacs_write_sig (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2461 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2464 /* Write a diagnostic to standard error that contains MESSAGE and a
2465 string derived from errno. Preserve errno. Do not buffer stderr.
2466 Do not process pending signals if interrupted. */
2468 emacs_perror (char const *message
)
2471 char const *error_string
= strerror (err
);
2472 char const *command
= (initial_argv
&& initial_argv
[0]
2473 ? initial_argv
[0] : "emacs");
2474 /* Write it out all at once, if it's short; this is less likely to
2475 be interleaved with other output. */
2477 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2478 command
, message
, error_string
);
2479 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2480 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2483 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2484 emacs_write (STDERR_FILENO
, ": ", 2);
2485 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2486 emacs_write (STDERR_FILENO
, ": ", 2);
2487 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2488 emacs_write (STDERR_FILENO
, "\n", 1);
2493 /* Return a struct timeval that is roughly equivalent to T.
2494 Use the least timeval not less than T.
2495 Return an extremal value if the result would overflow. */
2497 make_timeval (struct timespec t
)
2500 tv
.tv_sec
= t
.tv_sec
;
2501 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2503 if (t
.tv_nsec
% 1000 != 0)
2505 if (tv
.tv_usec
< 999999)
2507 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2517 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2518 ATIME and MTIME, respectively.
2519 FD must be either negative -- in which case it is ignored --
2520 or a file descriptor that is open on FILE.
2521 If FD is nonnegative, then FILE can be NULL. */
2523 set_file_times (int fd
, const char *filename
,
2524 struct timespec atime
, struct timespec mtime
)
2526 struct timespec timespec
[2];
2527 timespec
[0] = atime
;
2528 timespec
[1] = mtime
;
2529 return fdutimens (fd
, filename
, timespec
);
2532 /* Like strsignal, except async-signal-safe, and this function typically
2533 returns a string in the C locale rather than the current locale. */
2535 safe_strsignal (int code
)
2537 char const *signame
= 0;
2539 if (0 <= code
&& code
< sys_siglist_entries
)
2540 signame
= sys_siglist
[code
];
2542 signame
= "Unknown signal";
2548 /* For make-serial-process */
2550 serial_open (Lisp_Object port
)
2552 int fd
= emacs_open (SSDATA (port
), O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2554 report_file_error ("Opening serial port", port
);
2556 ioctl (fd
, TIOCEXCL
, (char *) 0);
2562 #if !defined (HAVE_CFMAKERAW)
2563 /* Workaround for targets which are missing cfmakeraw. */
2564 /* Pasted from man page. */
2566 cfmakeraw (struct termios
*termios_p
)
2568 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2569 termios_p
->c_oflag
&= ~OPOST
;
2570 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2571 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2572 termios_p
->c_cflag
|= CS8
;
2574 #endif /* !defined (HAVE_CFMAKERAW */
2576 #if !defined (HAVE_CFSETSPEED)
2577 /* Workaround for targets which are missing cfsetspeed. */
2579 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2581 return (cfsetispeed (termios_p
, vitesse
)
2582 + cfsetospeed (termios_p
, vitesse
));
2586 /* For serial-process-configure */
2588 serial_configure (struct Lisp_Process
*p
,
2589 Lisp_Object contact
)
2591 Lisp_Object childp2
= Qnil
;
2592 Lisp_Object tem
= Qnil
;
2593 struct termios attr
;
2595 char summary
[4] = "???"; /* This usually becomes "8N1". */
2597 childp2
= Fcopy_sequence (p
->childp
);
2599 /* Read port attributes and prepare default configuration. */
2600 err
= tcgetattr (p
->outfd
, &attr
);
2602 report_file_error ("Failed tcgetattr", Qnil
);
2604 #if defined (CLOCAL)
2605 attr
.c_cflag
|= CLOCAL
;
2608 attr
.c_cflag
|= CREAD
;
2611 /* Configure speed. */
2612 if (!NILP (Fplist_member (contact
, QCspeed
)))
2613 tem
= Fplist_get (contact
, QCspeed
);
2615 tem
= Fplist_get (p
->childp
, QCspeed
);
2617 err
= cfsetspeed (&attr
, XINT (tem
));
2619 report_file_error ("Failed cfsetspeed", tem
);
2620 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2622 /* Configure bytesize. */
2623 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2624 tem
= Fplist_get (contact
, QCbytesize
);
2626 tem
= Fplist_get (p
->childp
, QCbytesize
);
2628 tem
= make_number (8);
2630 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2631 error (":bytesize must be nil (8), 7, or 8");
2632 summary
[0] = XINT (tem
) + '0';
2633 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2634 attr
.c_cflag
&= ~CSIZE
;
2635 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2637 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2638 if (XINT (tem
) != 8)
2639 error ("Bytesize cannot be changed");
2641 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2643 /* Configure parity. */
2644 if (!NILP (Fplist_member (contact
, QCparity
)))
2645 tem
= Fplist_get (contact
, QCparity
);
2647 tem
= Fplist_get (p
->childp
, QCparity
);
2648 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2649 error (":parity must be nil (no parity), `even', or `odd'");
2650 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2651 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2652 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2657 else if (EQ (tem
, Qeven
))
2660 attr
.c_cflag
|= PARENB
;
2661 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2663 else if (EQ (tem
, Qodd
))
2666 attr
.c_cflag
|= (PARENB
| PARODD
);
2667 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2670 /* Don't error on no parity, which should be set by cfmakeraw. */
2672 error ("Parity cannot be configured");
2674 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2676 /* Configure stopbits. */
2677 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2678 tem
= Fplist_get (contact
, QCstopbits
);
2680 tem
= Fplist_get (p
->childp
, QCstopbits
);
2682 tem
= make_number (1);
2684 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2685 error (":stopbits must be nil (1 stopbit), 1, or 2");
2686 summary
[2] = XINT (tem
) + '0';
2687 #if defined (CSTOPB)
2688 attr
.c_cflag
&= ~CSTOPB
;
2689 if (XINT (tem
) == 2)
2690 attr
.c_cflag
|= CSTOPB
;
2692 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2693 if (XINT (tem
) != 1)
2694 error ("Stopbits cannot be configured");
2696 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2698 /* Configure flowcontrol. */
2699 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2700 tem
= Fplist_get (contact
, QCflowcontrol
);
2702 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2703 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2704 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2705 #if defined (CRTSCTS)
2706 attr
.c_cflag
&= ~CRTSCTS
;
2708 #if defined (CNEW_RTSCTS)
2709 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2711 #if defined (IXON) && defined (IXOFF)
2712 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2716 /* Already configured. */
2718 else if (EQ (tem
, Qhw
))
2720 #if defined (CRTSCTS)
2721 attr
.c_cflag
|= CRTSCTS
;
2722 #elif defined (CNEW_RTSCTS)
2723 attr
.c_cflag
|= CNEW_RTSCTS
;
2725 error ("Hardware flowcontrol (RTS/CTS) not supported");
2728 else if (EQ (tem
, Qsw
))
2730 #if defined (IXON) && defined (IXOFF)
2731 attr
.c_iflag
|= (IXON
| IXOFF
);
2733 error ("Software flowcontrol (XON/XOFF) not supported");
2736 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2738 /* Activate configuration. */
2739 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2741 report_file_error ("Failed tcsetattr", Qnil
);
2743 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2744 pset_childp (p
, childp2
);
2746 #endif /* not DOS_NT */
2748 /* System depended enumeration of and access to system processes a-la ps(1). */
2752 /* Process enumeration and access via /proc. */
2755 list_system_processes (void)
2757 Lisp_Object procdir
, match
, proclist
, next
;
2760 /* For every process on the system, there's a directory in the
2761 "/proc" pseudo-directory whose name is the numeric ID of that
2763 procdir
= build_string ("/proc");
2764 match
= build_string ("[0-9]+");
2765 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2767 /* `proclist' gives process IDs as strings. Destructively convert
2768 each string into a number. */
2769 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2772 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2775 /* directory_files_internal returns the files in reverse order; undo
2777 proclist
= Fnreverse (proclist
);
2781 #elif defined DARWIN_OS || defined __FreeBSD__
2784 list_system_processes (void)
2787 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2789 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2792 struct kinfo_proc
*procs
;
2795 Lisp_Object proclist
= Qnil
;
2797 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2800 procs
= xmalloc (len
);
2801 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2807 len
/= sizeof (struct kinfo_proc
);
2808 for (i
= 0; i
< len
; i
++)
2811 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2813 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2822 /* The WINDOWSNT implementation is in w32.c.
2823 The MSDOS implementation is in dosfns.c. */
2824 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2827 list_system_processes (void)
2832 #endif /* !defined (WINDOWSNT) */
2834 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2835 static struct timespec
2836 time_from_jiffies (unsigned long long tval
, long hz
)
2838 unsigned long long s
= tval
/ hz
;
2839 unsigned long long frac
= tval
% hz
;
2842 if (TYPE_MAXIMUM (time_t) < s
)
2844 if (LONG_MAX
- 1 <= ULLONG_MAX
/ TIMESPEC_RESOLUTION
2845 || frac
<= ULLONG_MAX
/ TIMESPEC_RESOLUTION
)
2846 ns
= frac
* TIMESPEC_RESOLUTION
/ hz
;
2849 /* This is reachable only in the unlikely case that HZ * HZ
2850 exceeds ULLONG_MAX. It calculates an approximation that is
2851 guaranteed to be in range. */
2852 long hz_per_ns
= (hz
/ TIMESPEC_RESOLUTION
2853 + (hz
% TIMESPEC_RESOLUTION
!= 0));
2854 ns
= frac
/ hz_per_ns
;
2857 return make_timespec (s
, ns
);
2861 ltime_from_jiffies (unsigned long long tval
, long hz
)
2863 struct timespec t
= time_from_jiffies (tval
, hz
);
2864 return make_lisp_time (t
);
2867 static struct timespec
2871 struct timespec up
= make_timespec (0, 0);
2874 fup
= emacs_fopen ("/proc/uptime", "r");
2878 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2879 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2881 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2882 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2883 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2886 if (TYPE_MAXIMUM (time_t) < upsec
)
2888 upsec
= TYPE_MAXIMUM (time_t);
2889 upfrac
= TIMESPEC_RESOLUTION
- 1;
2893 int upfraclen
= upfrac_end
- upfrac_start
;
2894 for (; upfraclen
< LOG10_TIMESPEC_RESOLUTION
; upfraclen
++)
2896 for (; LOG10_TIMESPEC_RESOLUTION
< upfraclen
; upfraclen
--)
2898 upfrac
= min (upfrac
, TIMESPEC_RESOLUTION
- 1);
2900 up
= make_timespec (upsec
, upfrac
);
2909 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2910 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2913 procfs_ttyname (int rdev
)
2916 char name
[PATH_MAX
];
2919 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2925 unsigned long minor_beg
, minor_end
;
2926 char minor
[25]; /* 2 32-bit numbers + dash */
2929 for (; !feof (fdev
) && !ferror (fdev
); name
[0] = 0)
2931 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2932 && major
== MAJOR (rdev
))
2934 minor_beg
= strtoul (minor
, &endp
, 0);
2936 minor_end
= minor_beg
;
2937 else if (*endp
== '-')
2938 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2942 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2944 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2952 return build_string (name
);
2956 procfs_get_total_memory (void)
2959 uintmax_t retval
= 2 * 1024 * 1024; /* default: 2 GiB */
2963 fmem
= emacs_fopen ("/proc/meminfo", "r");
2967 uintmax_t entry_value
;
2971 switch (fscanf (fmem
, "MemTotal: %"SCNuMAX
, &entry_value
))
2974 retval
= entry_value
;
2979 while ((c
= getc (fmem
)) != EOF
&& c
!= '\n')
2997 system_process_attributes (Lisp_Object pid
)
2999 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3003 long clocks_per_sec
;
3005 char procbuf
[1025], *p
, *q
;
3008 static char const default_cmd
[] = "???";
3009 const char *cmd
= default_cmd
;
3010 int cmdsize
= sizeof default_cmd
- 1;
3011 char *cmdline
= NULL
;
3012 ptrdiff_t cmdline_size
;
3015 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
3018 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
3019 long priority
, niceness
, rss
;
3020 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
3021 struct timespec tnow
, tstart
, tboot
, telapsed
, us_time
;
3023 Lisp_Object attrs
= Qnil
;
3024 Lisp_Object cmd_str
, decoded_cmd
;
3027 CHECK_NUMBER_OR_FLOAT (pid
);
3028 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3029 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3030 if (stat (procfn
, &st
) < 0)
3035 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3037 pw
= getpwuid (uid
);
3040 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3043 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3045 gr
= getgrgid (gid
);
3048 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3050 count
= SPECPDL_INDEX ();
3051 strcpy (fn
, procfn
);
3052 procfn_end
= fn
+ strlen (fn
);
3053 strcpy (procfn_end
, "/stat");
3054 fd
= emacs_open (fn
, O_RDONLY
, 0);
3059 record_unwind_protect_int (close_file_unwind
, fd
);
3060 nread
= emacs_read (fd
, procbuf
, sizeof procbuf
- 1);
3064 procbuf
[nread
] = '\0';
3067 p
= strchr (p
, '(');
3070 q
= strrchr (p
+ 1, ')');
3080 /* Command name is encoded in locale-coding-system; decode it. */
3081 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
3082 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3083 Vlocale_coding_system
, 0);
3084 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3086 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
3087 utime stime cutime cstime priority nice thcount . start vsize rss */
3089 && (sscanf (q
+ 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
3090 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
3091 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
3092 &minflt
, &cminflt
, &majflt
, &cmajflt
,
3093 &u_time
, &s_time
, &cutime
, &cstime
,
3094 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
)
3099 state_str
[1] = '\0';
3100 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3101 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid
)), attrs
);
3102 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp
)), attrs
);
3103 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess
)), attrs
);
3104 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
3105 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid
)), attrs
);
3106 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
3107 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
3108 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)),
3110 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)),
3112 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
3113 if (clocks_per_sec
< 0)
3114 clocks_per_sec
= 100;
3115 attrs
= Fcons (Fcons (Qutime
,
3116 ltime_from_jiffies (u_time
, clocks_per_sec
)),
3118 attrs
= Fcons (Fcons (Qstime
,
3119 ltime_from_jiffies (s_time
, clocks_per_sec
)),
3121 attrs
= Fcons (Fcons (Qtime
,
3122 ltime_from_jiffies (s_time
+ u_time
,
3125 attrs
= Fcons (Fcons (Qcutime
,
3126 ltime_from_jiffies (cutime
, clocks_per_sec
)),
3128 attrs
= Fcons (Fcons (Qcstime
,
3129 ltime_from_jiffies (cstime
, clocks_per_sec
)),
3131 attrs
= Fcons (Fcons (Qctime
,
3132 ltime_from_jiffies (cstime
+ cutime
,
3135 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
3136 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
3137 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount
)),
3139 tnow
= current_timespec ();
3140 telapsed
= get_up_time ();
3141 tboot
= timespec_sub (tnow
, telapsed
);
3142 tstart
= time_from_jiffies (start
, clocks_per_sec
);
3143 tstart
= timespec_add (tboot
, tstart
);
3144 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
3145 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/ 1024)),
3147 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4 * rss
)), attrs
);
3148 telapsed
= timespec_sub (tnow
, tstart
);
3149 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
3150 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
3151 pcpu
= timespectod (us_time
) / timespectod (telapsed
);
3154 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
3155 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
3158 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
3161 unbind_to (count
, Qnil
);
3164 strcpy (procfn_end
, "/cmdline");
3165 fd
= emacs_open (fn
, O_RDONLY
, 0);
3168 ptrdiff_t readsize
, nread_incr
;
3169 record_unwind_protect_int (close_file_unwind
, fd
);
3170 record_unwind_protect_nothing ();
3171 nread
= cmdline_size
= 0;
3175 cmdline
= xpalloc (cmdline
, &cmdline_size
, 2, STRING_BYTES_BOUND
, 1);
3176 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3178 /* Leave room even if every byte needs escaping below. */
3179 readsize
= (cmdline_size
>> 1) - nread
;
3181 nread_incr
= emacs_read (fd
, cmdline
+ nread
, readsize
);
3182 nread
+= max (0, nread_incr
);
3184 while (nread_incr
== readsize
);
3188 /* We don't want trailing null characters. */
3189 for (p
= cmdline
+ nread
; cmdline
< p
&& !p
[-1]; p
--)
3192 /* Escape-quote whitespace and backslashes. */
3193 q
= cmdline
+ cmdline_size
;
3198 if (c_isspace (c
) || c
== '\\')
3202 nread
= cmdline
+ cmdline_size
- q
;
3207 nread
= cmdsize
+ 2;
3208 cmdline_size
= nread
+ 1;
3209 q
= cmdline
= xrealloc (cmdline
, cmdline_size
);
3210 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3211 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3213 /* Command line is encoded in locale-coding-system; decode it. */
3214 cmd_str
= make_unibyte_string (q
, nread
);
3215 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3216 Vlocale_coding_system
, 0);
3217 unbind_to (count
, Qnil
);
3218 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3224 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3226 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3227 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3228 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3229 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3230 #undef _FILE_OFFSET_BITS
3232 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3237 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3238 #define _FILE_OFFSET_BITS 64
3239 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3241 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3244 system_process_attributes (Lisp_Object pid
)
3246 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3251 struct psinfo pinfo
;
3257 Lisp_Object attrs
= Qnil
;
3258 Lisp_Object decoded_cmd
;
3261 CHECK_NUMBER_OR_FLOAT (pid
);
3262 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3263 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3264 if (stat (procfn
, &st
) < 0)
3269 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3271 pw
= getpwuid (uid
);
3274 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3277 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3279 gr
= getgrgid (gid
);
3282 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3284 count
= SPECPDL_INDEX ();
3285 strcpy (fn
, procfn
);
3286 procfn_end
= fn
+ strlen (fn
);
3287 strcpy (procfn_end
, "/psinfo");
3288 fd
= emacs_open (fn
, O_RDONLY
, 0);
3293 record_unwind_protect (close_file_unwind
, fd
);
3294 nread
= emacs_read (fd
, &pinfo
, sizeof pinfo
);
3297 if (nread
== sizeof pinfo
)
3299 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3300 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3301 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3305 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3306 state_str
[1] = '\0';
3307 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3310 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3311 need to get a string from it. */
3313 /* FIXME: missing: Qtpgid */
3325 Are they available? */
3327 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3328 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3329 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3330 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3331 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)),
3334 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3335 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)),
3337 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)),
3340 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3341 range 0 .. 2**15, representing 0.0 .. 1.0. */
3342 attrs
= Fcons (Fcons (Qpcpu
,
3343 make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)),
3345 attrs
= Fcons (Fcons (Qpmem
,
3346 make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)),
3349 decoded_cmd
= (code_convert_string_norecord
3350 (build_unibyte_string (pinfo
.pr_fname
),
3351 Vlocale_coding_system
, 0));
3352 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3353 decoded_cmd
= (code_convert_string_norecord
3354 (build_unibyte_string (pinfo
.pr_psargs
),
3355 Vlocale_coding_system
, 0));
3356 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3358 unbind_to (count
, Qnil
);
3362 #elif defined __FreeBSD__
3364 static struct timespec
3365 timeval_to_timespec (struct timeval t
)
3367 return make_timespec (t
.tv_sec
, t
.tv_usec
* 1000);
3371 make_lisp_timeval (struct timeval t
)
3373 return make_lisp_time (timeval_to_timespec (t
));
3377 system_process_attributes (Lisp_Object pid
)
3380 int pagesize
= getpagesize ();
3381 unsigned long npages
;
3387 char args
[MAXPATHLEN
];
3388 struct timespec t
, now
;
3390 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3391 struct kinfo_proc proc
;
3392 size_t proclen
= sizeof proc
;
3394 Lisp_Object attrs
= Qnil
;
3395 Lisp_Object decoded_comm
;
3397 CHECK_NUMBER_OR_FLOAT (pid
);
3398 CONS_TO_INTEGER (pid
, int, proc_id
);
3401 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3404 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3407 pw
= getpwuid (proc
.ki_uid
);
3410 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3412 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3415 gr
= getgrgid (proc
.ki_svgid
);
3418 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3420 decoded_comm
= (code_convert_string_norecord
3421 (build_unibyte_string (proc
.ki_comm
),
3422 Vlocale_coding_system
, 0));
3424 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3426 char state
[2] = {'\0', '\0'};
3427 switch (proc
.ki_stat
)
3449 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3452 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3453 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3454 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3457 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3460 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3462 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3463 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3464 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3465 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3466 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3468 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3470 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3472 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage
.ru_utime
),
3473 timeval_to_timespec (proc
.ki_rusage
.ru_stime
));
3474 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3476 attrs
= Fcons (Fcons (Qcutime
,
3477 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3479 attrs
= Fcons (Fcons (Qcstime
,
3480 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3482 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage_ch
.ru_utime
),
3483 timeval_to_timespec (proc
.ki_rusage_ch
.ru_stime
));
3484 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3486 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3488 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3489 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3490 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3491 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3492 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3495 now
= current_timespec ();
3496 t
= timespec_sub (now
, timeval_to_timespec (proc
.ki_start
));
3497 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3499 len
= sizeof fscale
;
3500 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3505 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3507 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3508 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3509 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3513 len
= sizeof npages
;
3514 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3516 double pmem
= (proc
.ki_flag
& P_INMEM
3517 ? 100.0 * proc
.ki_rssize
/ npages
3519 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3522 mib
[2] = KERN_PROC_ARGS
;
3524 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3527 for (i
= 0; i
< len
; i
++)
3529 if (! args
[i
] && i
< len
- 1)
3534 (code_convert_string_norecord
3535 (build_unibyte_string (args
),
3536 Vlocale_coding_system
, 0));
3538 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3544 /* The WINDOWSNT implementation is in w32.c.
3545 The MSDOS implementation is in dosfns.c. */
3546 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3549 system_process_attributes (Lisp_Object pid
)
3554 #endif /* !defined (WINDOWSNT) */
3556 /* Wide character string collation. */
3558 #ifdef __STDC_ISO_10646__
3560 # include <wctype.h>
3562 # if defined HAVE_NEWLOCALE || defined HAVE_SETLOCALE
3563 # include <locale.h>
3566 # define LC_COLLATE 0
3568 # ifndef LC_COLLATE_MASK
3569 # define LC_COLLATE_MASK 0
3574 # ifndef LC_CTYPE_MASK
3575 # define LC_CTYPE_MASK 0
3578 # ifndef HAVE_NEWLOCALE
3584 # define freelocale emacs_freelocale
3585 # define locale_t emacs_locale_t
3586 # define newlocale emacs_newlocale
3587 # define wcscoll_l emacs_wcscoll_l
3588 # define towlower_l emacs_towlower_l
3590 typedef char const *locale_t
;
3593 newlocale (int category_mask
, char const *locale
, locale_t loc
)
3599 freelocale (locale_t loc
)
3604 emacs_setlocale (int category
, char const *locale
)
3606 # ifdef HAVE_SETLOCALE
3608 char *loc
= setlocale (category
, locale
);
3619 wcscoll_l (wchar_t const *a
, wchar_t const *b
, locale_t loc
)
3622 char *oldloc
= emacs_setlocale (LC_COLLATE
, NULL
);
3630 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3631 strcpy (oldcopy
, oldloc
);
3632 if (! emacs_setlocale (LC_COLLATE
, loc
))
3637 result
= wcscoll (a
, b
);
3639 if (! emacs_setlocale (LC_COLLATE
, oldcopy
))
3650 towlower_l (wint_t wc
, locale_t loc
)
3653 char *oldloc
= emacs_setlocale (LC_CTYPE
, NULL
);
3658 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3659 strcpy (oldcopy
, oldloc
);
3660 if (emacs_setlocale (LC_CTYPE
, loc
))
3662 result
= towlower (wc
);
3663 emacs_setlocale (LC_COLLATE
, oldcopy
);
3673 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3674 Lisp_Object locale
, Lisp_Object ignore_case
)
3677 ptrdiff_t len
, i
, i_byte
;
3682 /* Convert byte stream to code points. */
3683 len
= SCHARS (s1
); i
= i_byte
= 0;
3684 SAFE_NALLOCA (p1
, 1, len
+ 1);
3686 FETCH_STRING_CHAR_ADVANCE (*(p1
+i
-1), s1
, i
, i_byte
);
3689 len
= SCHARS (s2
); i
= i_byte
= 0;
3690 SAFE_NALLOCA (p2
, 1, len
+ 1);
3692 FETCH_STRING_CHAR_ADVANCE (*(p2
+i
-1), s2
, i
, i_byte
);
3695 if (STRINGP (locale
))
3697 locale_t loc
= newlocale (LC_COLLATE_MASK
| LC_CTYPE_MASK
,
3698 SSDATA (locale
), 0);
3700 error ("Invalid locale %s: %s", SSDATA (locale
), strerror (errno
));
3702 if (! NILP (ignore_case
))
3703 for (int i
= 1; i
< 3; i
++)
3705 wchar_t *p
= (i
== 1) ? p1
: p2
;
3707 *p
= towlower_l (*p
, loc
);
3711 res
= wcscoll_l (p1
, p2
, loc
);
3717 if (! NILP (ignore_case
))
3718 for (int i
= 1; i
< 3; i
++)
3720 wchar_t *p
= (i
== 1) ? p1
: p2
;
3726 res
= wcscoll (p1
, p2
);
3729 # ifndef HAVE_NEWLOCALE
3731 error ("Invalid locale or string for collation: %s", strerror (err
));
3734 error ("Invalid string for collation: %s", strerror (err
));
3740 #endif /* __STDC_ISO_10646__ */
3744 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3745 Lisp_Object locale
, Lisp_Object ignore_case
)
3748 char *loc
= STRINGP (locale
) ? SSDATA (locale
) : NULL
;
3749 int res
, err
= errno
;
3752 res
= w32_compare_strings (SDATA (s1
), SDATA (s2
), loc
, !NILP (ignore_case
));
3754 error ("Invalid string for collation: %s", strerror (errno
));
3759 #endif /* WINDOWSNT */