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
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/>. */
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 if (!attempt_stack_overflow_recovery
)
1638 /* In theory, a more-accurate heuristic can be obtained by using
1639 GNU/Linux pthread_getattr_np along with POSIX pthread_attr_getstack
1640 and pthread_attr_getguardsize to find the location and size of the
1641 guard area. In practice, though, these functions are so hard to
1642 use reliably that they're not worth bothering with. E.g., see:
1643 https://sourceware.org/bugzilla/show_bug.cgi?id=16291
1644 Other operating systems also have problems, e.g., Solaris's
1645 stack_violation function is tailor-made for this problem, but it
1646 doesn't work on Solaris 11.2 x86-64 with a 32-bit executable.
1648 GNU libsigsegv is overkill for Emacs; otherwise it might be a
1654 /* The faulting address. */
1655 char *addr
= siginfo
->si_addr
;
1659 /* The known top and bottom of the stack. The actual stack may
1660 extend a bit beyond these boundaries. */
1661 char *bot
= stack_bottom
;
1662 char *top
= near_C_stack_top ();
1664 /* Log base 2 of the stack heuristic ratio. This ratio is the size
1665 of the known stack divided by the size of the guard area past the
1666 end of the stack top. The heuristic is that a bad address is
1667 considered to be a stack overflow if it occurs within
1668 stacksize>>LG_STACK_HEURISTIC bytes above the top of the known
1669 stack. This heuristic is not exactly correct but it's good
1670 enough in practice. */
1671 enum { LG_STACK_HEURISTIC
= 8 };
1674 return 0 <= addr
- top
&& addr
- top
< (top
- bot
) >> LG_STACK_HEURISTIC
;
1676 return 0 <= top
- addr
&& top
- addr
< (bot
- top
) >> LG_STACK_HEURISTIC
;
1680 /* Attempt to recover from SIGSEGV caused by C stack overflow. */
1683 handle_sigsegv (int sig
, siginfo_t
*siginfo
, void *arg
)
1685 /* Hard GC error may lead to stack overflow caused by
1686 too nested calls to mark_object. No way to survive. */
1687 bool fatal
= gc_in_progress
;
1689 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1690 if (!fatal
&& !pthread_equal (pthread_self (), main_thread
))
1694 if (!fatal
&& stack_overflow (siginfo
))
1695 siglongjmp (return_to_command_loop
, 1);
1697 /* Otherwise we can't do anything with this. */
1698 deliver_fatal_thread_signal (sig
);
1701 /* Return true if we have successfully set up SIGSEGV handler on alternate
1702 stack. Otherwise we just treat SIGSEGV among the rest of fatal signals. */
1707 struct sigaction sa
;
1710 ss
.ss_sp
= sigsegv_stack
;
1711 ss
.ss_size
= sizeof (sigsegv_stack
);
1713 if (sigaltstack (&ss
, NULL
) < 0)
1716 sigfillset (&sa
.sa_mask
);
1717 sa
.sa_sigaction
= handle_sigsegv
;
1718 sa
.sa_flags
= SA_SIGINFO
| SA_ONSTACK
| emacs_sigaction_flags ();
1719 return sigaction (SIGSEGV
, &sa
, NULL
) < 0 ? 0 : 1;
1722 #else /* not HAVE_STACK_OVERFLOW_HANDLING or WINDOWSNT */
1730 #endif /* HAVE_STACK_OVERFLOW_HANDLING && !WINDOWSNT */
1733 deliver_arith_signal (int sig
)
1735 deliver_thread_signal (sig
, handle_arith_signal
);
1740 /* Handler for SIGDANGER. */
1742 handle_danger_signal (int sig
)
1744 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1746 /* It might be unsafe to call do_auto_save now. */
1747 force_auto_save_soon ();
1751 deliver_danger_signal (int sig
)
1753 deliver_process_signal (sig
, handle_danger_signal
);
1757 /* Treat SIG as a terminating signal, unless it is already ignored and
1758 we are in --batch mode. Among other things, this makes nohup work. */
1760 maybe_fatal_sig (int sig
)
1762 bool catch_sig
= !noninteractive
;
1765 struct sigaction old_action
;
1766 sigaction (sig
, 0, &old_action
);
1767 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1770 sigaction (sig
, &process_fatal_action
, 0);
1774 init_signals (bool dumping
)
1776 struct sigaction thread_fatal_action
;
1777 struct sigaction action
;
1779 sigemptyset (&empty_mask
);
1781 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1782 main_thread
= pthread_self ();
1785 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1788 sys_siglist
[SIGABRT
] = "Aborted";
1790 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1792 sys_siglist
[SIGALRM
] = "Alarm clock";
1794 sys_siglist
[SIGBUS
] = "Bus error";
1797 sys_siglist
[SIGCHLD
] = "Child status changed";
1800 sys_siglist
[SIGCONT
] = "Continued";
1803 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1806 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1809 sys_siglist
[SIGEMT
] = "Emulation trap";
1811 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1813 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1816 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1818 sys_siglist
[SIGHUP
] = "Hangup";
1819 sys_siglist
[SIGILL
] = "Illegal instruction";
1820 sys_siglist
[SIGINT
] = "Interrupt";
1822 sys_siglist
[SIGIO
] = "I/O possible";
1825 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1828 sys_siglist
[SIGIOT
] = "IOT trap";
1830 sys_siglist
[SIGKILL
] = "Killed";
1832 sys_siglist
[SIGLOST
] = "Resource lost";
1835 sys_siglist
[SIGLWP
] = "SIGLWP";
1838 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1841 sys_siglist
[SIGWIND
] = "SIGPHONE";
1843 sys_siglist
[SIGPIPE
] = "Broken pipe";
1845 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1848 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1851 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1854 sys_siglist
[SIGPWR
] = "Power-fail restart";
1856 sys_siglist
[SIGQUIT
] = "Quit";
1858 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1861 sys_siglist
[SIGSAK
] = "Secure attention";
1863 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1865 sys_siglist
[SIGSOUND
] = "Sound completed";
1868 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1871 sys_siglist
[SIGSTP
] = "Stopped (user)";
1874 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1876 sys_siglist
[SIGTERM
] = "Terminated";
1878 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1881 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1884 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1887 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1890 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1893 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1896 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1899 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1902 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1905 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1908 sys_siglist
[SIGWINCH
] = "Window size changed";
1911 sys_siglist
[SIGWIND
] = "SIGWIND";
1914 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1917 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1920 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1922 /* Don't alter signal handlers if dumping. On some machines,
1923 changing signal handlers sets static data that would make signals
1924 fail to work right when the dumped Emacs is run. */
1928 sigfillset (&process_fatal_action
.sa_mask
);
1929 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1930 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1932 sigfillset (&thread_fatal_action
.sa_mask
);
1933 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1934 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1936 /* SIGINT may need special treatment on MS-Windows. See
1937 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1938 Please update the doc of kill-emacs, kill-emacs-hook, and
1939 NEWS if you change this. */
1941 maybe_fatal_sig (SIGHUP
);
1942 maybe_fatal_sig (SIGINT
);
1943 maybe_fatal_sig (SIGTERM
);
1945 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1946 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1947 to behave more like typical batch applications do. */
1948 if (! noninteractive
)
1949 signal (SIGPIPE
, SIG_IGN
);
1951 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1952 sigaction (SIGILL
, &thread_fatal_action
, 0);
1953 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1955 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1956 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1957 interpreter's floating point operations, so treat SIGFPE as an
1958 arith-error if it arises in the main thread. */
1959 if (IEEE_FLOATING_POINT
)
1960 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1963 emacs_sigaction_init (&action
, deliver_arith_signal
);
1964 sigaction (SIGFPE
, &action
, 0);
1968 add_user_signal (SIGUSR1
, "sigusr1");
1971 add_user_signal (SIGUSR2
, "sigusr2");
1973 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1975 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1978 sigaction (SIGORE
, &thread_fatal_action
, 0);
1981 sigaction (SIGUME
, &thread_fatal_action
, 0);
1984 sigaction (SIGDLK
, &process_fatal_action
, 0);
1987 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1990 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1993 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1996 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1998 if (!init_sigsegv ())
1999 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
2001 sigaction (SIGSYS
, &thread_fatal_action
, 0);
2003 sigaction (SIGTERM
, &process_fatal_action
, 0);
2005 signal (SIGPROF
, SIG_IGN
);
2008 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
2011 sigaction (SIGXCPU
, &process_fatal_action
, 0);
2014 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
2018 /* This just means available memory is getting low. */
2019 emacs_sigaction_init (&action
, deliver_danger_signal
);
2020 sigaction (SIGDANGER
, &action
, 0);
2023 /* AIX-specific signals. */
2025 sigaction (SIGGRANT
, &process_fatal_action
, 0);
2028 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
2031 sigaction (SIGMSG
, &process_fatal_action
, 0);
2034 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
2037 sigaction (SIGSAK
, &process_fatal_action
, 0);
2040 sigaction (SIGSOUND
, &process_fatal_action
, 0);
2043 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
2053 /* Figure out how many bits the system's random number generator uses.
2054 `random' and `lrand48' are assumed to return 31 usable bits.
2055 BSD `rand' returns a 31 bit value but the low order bits are unusable;
2056 so we'll shift it and treat it like the 15-bit USG `rand'. */
2060 # define RAND_BITS 31
2061 # else /* !HAVE_RANDOM */
2062 # ifdef HAVE_LRAND48
2063 # define RAND_BITS 31
2064 # define random lrand48
2065 # else /* !HAVE_LRAND48 */
2066 # define RAND_BITS 15
2067 # if RAND_MAX == 32767
2068 # define random rand
2069 # else /* RAND_MAX != 32767 */
2070 # if RAND_MAX == 2147483647
2071 # define random() (rand () >> 16)
2072 # else /* RAND_MAX != 2147483647 */
2074 # define random rand
2076 # define random() (rand () >> 16)
2078 # endif /* RAND_MAX != 2147483647 */
2079 # endif /* RAND_MAX != 32767 */
2080 # endif /* !HAVE_LRAND48 */
2081 # endif /* !HAVE_RANDOM */
2082 #endif /* !RAND_BITS */
2085 typedef unsigned int random_seed
;
2086 static void set_random_seed (random_seed arg
) { srandom (arg
); }
2087 #elif defined HAVE_LRAND48
2088 /* Although srand48 uses a long seed, this is unsigned long to avoid
2089 undefined behavior on signed integer overflow in init_random. */
2090 typedef unsigned long int random_seed
;
2091 static void set_random_seed (random_seed arg
) { srand48 (arg
); }
2093 typedef unsigned int random_seed
;
2094 static void set_random_seed (random_seed arg
) { srand (arg
); }
2098 seed_random (void *seed
, ptrdiff_t seed_size
)
2100 random_seed arg
= 0;
2101 unsigned char *argp
= (unsigned char *) &arg
;
2102 unsigned char *seedp
= seed
;
2103 for (ptrdiff_t i
= 0; i
< seed_size
; i
++)
2104 argp
[i
% sizeof arg
] ^= seedp
[i
];
2105 set_random_seed (arg
);
2112 if (! (EQ (emacs_gnutls_global_init (), Qt
)
2113 && gnutls_rnd (GNUTLS_RND_NONCE
, &v
, sizeof v
) == 0))
2115 bool success
= false;
2117 int fd
= emacs_open ("/dev/urandom", O_RDONLY
| O_BINARY
, 0);
2120 success
= emacs_read (fd
, &v
, sizeof v
) == sizeof v
;
2124 success
= w32_init_random (&v
, sizeof v
) == 0;
2128 /* Fall back to current time value + PID. */
2129 struct timespec t
= current_timespec ();
2130 v
= getpid () ^ t
.tv_sec
^ t
.tv_nsec
;
2133 set_random_seed (v
);
2137 * Return a nonnegative random integer out of whatever we've got.
2138 * It contains enough bits to make a random (signed) Emacs fixnum.
2139 * This suffices even for a 64-bit architecture with a 15-bit rand.
2146 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2147 val
= (random () ^ (val
<< RAND_BITS
)
2148 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2149 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2150 return val
& INTMASK
;
2153 #ifndef HAVE_SNPRINTF
2154 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2156 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2158 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2159 ptrdiff_t nbytes
= size
- 1;
2164 va_start (ap
, format
);
2165 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2169 if (nbytes
== size
- 1)
2171 /* Calculate the length of the string that would have been created
2172 had the buffer been large enough. */
2173 char stackbuf
[4000];
2175 ptrdiff_t bsize
= sizeof stackbuf
;
2176 va_start (ap
, format
);
2177 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2183 if (INT_MAX
< nbytes
)
2196 /* If a backtrace is available, output the top lines of it to stderr.
2197 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2198 This function may be called from a signal handler, so it should
2199 not invoke async-unsafe functions like malloc.
2201 If BACKTRACE_LIMIT is -1, initialize tables that 'backtrace' uses
2202 but do not output anything. This avoids some problems that can
2203 otherwise occur if the malloc arena is corrupted before 'backtrace'
2204 is called, since 'backtrace' may call malloc if the tables are not
2207 If the static variable THREAD_BACKTRACE_NPOINTERS is nonzero, a
2208 fatal error has occurred in some other thread; generate a thread
2209 backtrace instead, ignoring BACKTRACE_LIMIT. */
2211 emacs_backtrace (int backtrace_limit
)
2213 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2214 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2218 if (thread_backtrace_npointers
)
2220 buffer
= thread_backtrace_buffer
;
2221 npointers
= thread_backtrace_npointers
;
2225 buffer
= main_backtrace_buffer
;
2227 /* Work around 'backtrace' bug; see Bug#19959 and glibc bug#18084. */
2228 if (bounded_limit
< 0)
2230 backtrace (buffer
, 1);
2234 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2239 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2240 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2241 if (bounded_limit
< npointers
)
2242 emacs_write (STDERR_FILENO
, "...\n", 4);
2250 terminate_due_to_signal (SIGABRT
, 40);
2254 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2255 Use binary I/O on systems that care about text vs binary I/O.
2256 Arrange for subprograms to not inherit the file descriptor.
2257 Prefer a method that is multithread-safe, if available.
2258 Do not fail merely because the open was interrupted by a signal.
2259 Allow the user to quit. */
2262 emacs_open (const char *file
, int oflags
, int mode
)
2265 if (! (oflags
& O_TEXT
))
2267 oflags
|= O_CLOEXEC
;
2268 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2270 if (! O_CLOEXEC
&& 0 <= fd
)
2271 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2275 /* Open FILE as a stream for Emacs use, with mode MODE.
2276 Act like emacs_open with respect to threads, signals, and quits. */
2279 emacs_fopen (char const *file
, char const *mode
)
2281 int fd
, omode
, oflags
;
2283 char const *m
= mode
;
2287 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2288 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2289 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2290 default: emacs_abort ();
2296 case '+': omode
= O_RDWR
; break;
2297 case 'b': bflag
= O_BINARY
; break;
2298 case 't': bflag
= O_TEXT
; break;
2299 default: /* Ignore. */ break;
2302 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2303 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2306 /* Create a pipe for Emacs use. */
2309 emacs_pipe (int fd
[2])
2314 int result
= pipe2 (fd
, O_BINARY
| O_CLOEXEC
);
2315 if (! O_CLOEXEC
&& result
== 0)
2317 fcntl (fd
[0], F_SETFD
, FD_CLOEXEC
);
2318 fcntl (fd
[1], F_SETFD
, FD_CLOEXEC
);
2324 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2325 For the background behind this mess, please see Austin Group defect 529
2326 <http://austingroupbugs.net/view.php?id=529>. */
2328 #ifndef POSIX_CLOSE_RESTART
2329 # define POSIX_CLOSE_RESTART 1
2331 posix_close (int fd
, int flag
)
2333 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2334 eassert (flag
== POSIX_CLOSE_RESTART
);
2336 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2337 on a system that does not define POSIX_CLOSE_RESTART.
2339 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2340 closed, and retrying the close could inadvertently close a file
2341 descriptor allocated by some other thread. In other systems
2342 (e.g., HP/UX) FD is not closed. And in still other systems
2343 (e.g., OS X, Solaris), maybe FD is closed, maybe not, and in a
2344 multithreaded program there can be no way to tell.
2346 So, in this case, pretend that the close succeeded. This works
2347 well on systems like GNU/Linux that close FD. Although it may
2348 leak a file descriptor on other systems, the leak is unlikely and
2349 it's better to leak than to close a random victim. */
2350 return close (fd
) == 0 || errno
== EINTR
? 0 : -1;
2354 /* Close FD, retrying if interrupted. If successful, return 0;
2355 otherwise, return -1 and set errno to a non-EINTR value. Consider
2356 an EINPROGRESS error to be successful, as that's merely a signal
2357 arriving. FD is always closed when this function returns, even
2360 Do not call this function if FD is nonnegative and might already be closed,
2361 as that might close an innocent victim opened by some other thread. */
2364 emacs_close (int fd
)
2368 int r
= posix_close (fd
, POSIX_CLOSE_RESTART
);
2371 if (!POSIX_CLOSE_RESTART
|| errno
!= EINTR
)
2373 eassert (errno
!= EBADF
|| fd
< 0);
2374 return errno
== EINPROGRESS
? 0 : r
;
2379 /* Maximum number of bytes to read or write in a single system call.
2380 This works around a serious bug in Linux kernels before 2.6.16; see
2381 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2382 It's likely to work around similar bugs in other operating systems, so do it
2383 on all platforms. Round INT_MAX down to a page size, with the conservative
2384 assumption that page sizes are at most 2**18 bytes (any kernel with a
2385 page size larger than that shouldn't have the bug). */
2386 #ifndef MAX_RW_COUNT
2387 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2390 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2391 Return the number of bytes read, which might be less than NBYTE.
2392 On error, set errno and return -1. */
2394 emacs_read (int fildes
, void *buf
, ptrdiff_t nbyte
)
2398 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2399 passes a size that large to emacs_read. */
2401 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2402 && (errno
== EINTR
))
2407 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2408 or if a partial write occurs. If interrupted, process pending
2409 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2410 errno if this is less than NBYTE. */
2412 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2413 bool process_signals
)
2415 ptrdiff_t bytes_written
= 0;
2419 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2425 /* I originally used `QUIT' but that might cause files to
2426 be truncated if you hit C-g in the middle of it. --Stef */
2427 if (process_signals
&& pending_signals
)
2428 process_pending_signals ();
2440 return bytes_written
;
2443 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2444 interrupted or if a partial write occurs. Return the number of
2445 bytes written, setting errno if this is less than NBYTE. */
2447 emacs_write (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2449 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2452 /* Like emacs_write, but also process pending signals if interrupted. */
2454 emacs_write_sig (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2456 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2459 /* Write a diagnostic to standard error that contains MESSAGE and a
2460 string derived from errno. Preserve errno. Do not buffer stderr.
2461 Do not process pending signals if interrupted. */
2463 emacs_perror (char const *message
)
2466 char const *error_string
= strerror (err
);
2467 char const *command
= (initial_argv
&& initial_argv
[0]
2468 ? initial_argv
[0] : "emacs");
2469 /* Write it out all at once, if it's short; this is less likely to
2470 be interleaved with other output. */
2472 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2473 command
, message
, error_string
);
2474 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2475 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2478 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2479 emacs_write (STDERR_FILENO
, ": ", 2);
2480 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2481 emacs_write (STDERR_FILENO
, ": ", 2);
2482 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2483 emacs_write (STDERR_FILENO
, "\n", 1);
2488 /* Return a struct timeval that is roughly equivalent to T.
2489 Use the least timeval not less than T.
2490 Return an extremal value if the result would overflow. */
2492 make_timeval (struct timespec t
)
2495 tv
.tv_sec
= t
.tv_sec
;
2496 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2498 if (t
.tv_nsec
% 1000 != 0)
2500 if (tv
.tv_usec
< 999999)
2502 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2512 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2513 ATIME and MTIME, respectively.
2514 FD must be either negative -- in which case it is ignored --
2515 or a file descriptor that is open on FILE.
2516 If FD is nonnegative, then FILE can be NULL. */
2518 set_file_times (int fd
, const char *filename
,
2519 struct timespec atime
, struct timespec mtime
)
2521 struct timespec timespec
[2];
2522 timespec
[0] = atime
;
2523 timespec
[1] = mtime
;
2524 return fdutimens (fd
, filename
, timespec
);
2527 /* Like strsignal, except async-signal-safe, and this function typically
2528 returns a string in the C locale rather than the current locale. */
2530 safe_strsignal (int code
)
2532 char const *signame
= 0;
2534 if (0 <= code
&& code
< sys_siglist_entries
)
2535 signame
= sys_siglist
[code
];
2537 signame
= "Unknown signal";
2543 /* For make-serial-process */
2545 serial_open (Lisp_Object port
)
2547 int fd
= emacs_open (SSDATA (port
), O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2549 report_file_error ("Opening serial port", port
);
2551 ioctl (fd
, TIOCEXCL
, (char *) 0);
2557 #if !defined (HAVE_CFMAKERAW)
2558 /* Workaround for targets which are missing cfmakeraw. */
2559 /* Pasted from man page. */
2561 cfmakeraw (struct termios
*termios_p
)
2563 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2564 termios_p
->c_oflag
&= ~OPOST
;
2565 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2566 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2567 termios_p
->c_cflag
|= CS8
;
2569 #endif /* !defined (HAVE_CFMAKERAW */
2571 #if !defined (HAVE_CFSETSPEED)
2572 /* Workaround for targets which are missing cfsetspeed. */
2574 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2576 return (cfsetispeed (termios_p
, vitesse
)
2577 + cfsetospeed (termios_p
, vitesse
));
2581 /* For serial-process-configure */
2583 serial_configure (struct Lisp_Process
*p
,
2584 Lisp_Object contact
)
2586 Lisp_Object childp2
= Qnil
;
2587 Lisp_Object tem
= Qnil
;
2588 struct termios attr
;
2590 char summary
[4] = "???"; /* This usually becomes "8N1". */
2592 childp2
= Fcopy_sequence (p
->childp
);
2594 /* Read port attributes and prepare default configuration. */
2595 err
= tcgetattr (p
->outfd
, &attr
);
2597 report_file_error ("Failed tcgetattr", Qnil
);
2599 #if defined (CLOCAL)
2600 attr
.c_cflag
|= CLOCAL
;
2603 attr
.c_cflag
|= CREAD
;
2606 /* Configure speed. */
2607 if (!NILP (Fplist_member (contact
, QCspeed
)))
2608 tem
= Fplist_get (contact
, QCspeed
);
2610 tem
= Fplist_get (p
->childp
, QCspeed
);
2612 err
= cfsetspeed (&attr
, XINT (tem
));
2614 report_file_error ("Failed cfsetspeed", tem
);
2615 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2617 /* Configure bytesize. */
2618 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2619 tem
= Fplist_get (contact
, QCbytesize
);
2621 tem
= Fplist_get (p
->childp
, QCbytesize
);
2623 tem
= make_number (8);
2625 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2626 error (":bytesize must be nil (8), 7, or 8");
2627 summary
[0] = XINT (tem
) + '0';
2628 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2629 attr
.c_cflag
&= ~CSIZE
;
2630 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2632 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2633 if (XINT (tem
) != 8)
2634 error ("Bytesize cannot be changed");
2636 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2638 /* Configure parity. */
2639 if (!NILP (Fplist_member (contact
, QCparity
)))
2640 tem
= Fplist_get (contact
, QCparity
);
2642 tem
= Fplist_get (p
->childp
, QCparity
);
2643 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2644 error (":parity must be nil (no parity), `even', or `odd'");
2645 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2646 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2647 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2652 else if (EQ (tem
, Qeven
))
2655 attr
.c_cflag
|= PARENB
;
2656 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2658 else if (EQ (tem
, Qodd
))
2661 attr
.c_cflag
|= (PARENB
| PARODD
);
2662 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2665 /* Don't error on no parity, which should be set by cfmakeraw. */
2667 error ("Parity cannot be configured");
2669 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2671 /* Configure stopbits. */
2672 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2673 tem
= Fplist_get (contact
, QCstopbits
);
2675 tem
= Fplist_get (p
->childp
, QCstopbits
);
2677 tem
= make_number (1);
2679 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2680 error (":stopbits must be nil (1 stopbit), 1, or 2");
2681 summary
[2] = XINT (tem
) + '0';
2682 #if defined (CSTOPB)
2683 attr
.c_cflag
&= ~CSTOPB
;
2684 if (XINT (tem
) == 2)
2685 attr
.c_cflag
|= CSTOPB
;
2687 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2688 if (XINT (tem
) != 1)
2689 error ("Stopbits cannot be configured");
2691 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2693 /* Configure flowcontrol. */
2694 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2695 tem
= Fplist_get (contact
, QCflowcontrol
);
2697 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2698 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2699 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2700 #if defined (CRTSCTS)
2701 attr
.c_cflag
&= ~CRTSCTS
;
2703 #if defined (CNEW_RTSCTS)
2704 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2706 #if defined (IXON) && defined (IXOFF)
2707 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2711 /* Already configured. */
2713 else if (EQ (tem
, Qhw
))
2715 #if defined (CRTSCTS)
2716 attr
.c_cflag
|= CRTSCTS
;
2717 #elif defined (CNEW_RTSCTS)
2718 attr
.c_cflag
|= CNEW_RTSCTS
;
2720 error ("Hardware flowcontrol (RTS/CTS) not supported");
2723 else if (EQ (tem
, Qsw
))
2725 #if defined (IXON) && defined (IXOFF)
2726 attr
.c_iflag
|= (IXON
| IXOFF
);
2728 error ("Software flowcontrol (XON/XOFF) not supported");
2731 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2733 /* Activate configuration. */
2734 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2736 report_file_error ("Failed tcsetattr", Qnil
);
2738 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2739 pset_childp (p
, childp2
);
2741 #endif /* not DOS_NT */
2743 /* System depended enumeration of and access to system processes a-la ps(1). */
2747 /* Process enumeration and access via /proc. */
2750 list_system_processes (void)
2752 Lisp_Object procdir
, match
, proclist
, next
;
2755 /* For every process on the system, there's a directory in the
2756 "/proc" pseudo-directory whose name is the numeric ID of that
2758 procdir
= build_string ("/proc");
2759 match
= build_string ("[0-9]+");
2760 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2762 /* `proclist' gives process IDs as strings. Destructively convert
2763 each string into a number. */
2764 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2767 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2770 /* directory_files_internal returns the files in reverse order; undo
2772 proclist
= Fnreverse (proclist
);
2776 #elif defined DARWIN_OS || defined __FreeBSD__
2779 list_system_processes (void)
2782 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2784 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2787 struct kinfo_proc
*procs
;
2790 Lisp_Object proclist
= Qnil
;
2792 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2795 procs
= xmalloc (len
);
2796 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2802 len
/= sizeof (struct kinfo_proc
);
2803 for (i
= 0; i
< len
; i
++)
2806 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2808 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2817 /* The WINDOWSNT implementation is in w32.c.
2818 The MSDOS implementation is in dosfns.c. */
2819 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2822 list_system_processes (void)
2827 #endif /* !defined (WINDOWSNT) */
2829 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2830 static struct timespec
2831 time_from_jiffies (unsigned long long tval
, long hz
)
2833 unsigned long long s
= tval
/ hz
;
2834 unsigned long long frac
= tval
% hz
;
2837 if (TYPE_MAXIMUM (time_t) < s
)
2839 if (LONG_MAX
- 1 <= ULLONG_MAX
/ TIMESPEC_RESOLUTION
2840 || frac
<= ULLONG_MAX
/ TIMESPEC_RESOLUTION
)
2841 ns
= frac
* TIMESPEC_RESOLUTION
/ hz
;
2844 /* This is reachable only in the unlikely case that HZ * HZ
2845 exceeds ULLONG_MAX. It calculates an approximation that is
2846 guaranteed to be in range. */
2847 long hz_per_ns
= (hz
/ TIMESPEC_RESOLUTION
2848 + (hz
% TIMESPEC_RESOLUTION
!= 0));
2849 ns
= frac
/ hz_per_ns
;
2852 return make_timespec (s
, ns
);
2856 ltime_from_jiffies (unsigned long long tval
, long hz
)
2858 struct timespec t
= time_from_jiffies (tval
, hz
);
2859 return make_lisp_time (t
);
2862 static struct timespec
2866 struct timespec up
= make_timespec (0, 0);
2869 fup
= emacs_fopen ("/proc/uptime", "r");
2873 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2874 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2876 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2877 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2878 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2881 if (TYPE_MAXIMUM (time_t) < upsec
)
2883 upsec
= TYPE_MAXIMUM (time_t);
2884 upfrac
= TIMESPEC_RESOLUTION
- 1;
2888 int upfraclen
= upfrac_end
- upfrac_start
;
2889 for (; upfraclen
< LOG10_TIMESPEC_RESOLUTION
; upfraclen
++)
2891 for (; LOG10_TIMESPEC_RESOLUTION
< upfraclen
; upfraclen
--)
2893 upfrac
= min (upfrac
, TIMESPEC_RESOLUTION
- 1);
2895 up
= make_timespec (upsec
, upfrac
);
2904 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2905 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2908 procfs_ttyname (int rdev
)
2911 char name
[PATH_MAX
];
2914 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2920 unsigned long minor_beg
, minor_end
;
2921 char minor
[25]; /* 2 32-bit numbers + dash */
2924 for (; !feof (fdev
) && !ferror (fdev
); name
[0] = 0)
2926 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2927 && major
== MAJOR (rdev
))
2929 minor_beg
= strtoul (minor
, &endp
, 0);
2931 minor_end
= minor_beg
;
2932 else if (*endp
== '-')
2933 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2937 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2939 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2947 return build_string (name
);
2951 procfs_get_total_memory (void)
2954 uintmax_t retval
= 2 * 1024 * 1024; /* default: 2 GiB */
2958 fmem
= emacs_fopen ("/proc/meminfo", "r");
2962 uintmax_t entry_value
;
2966 switch (fscanf (fmem
, "MemTotal: %"SCNuMAX
, &entry_value
))
2969 retval
= entry_value
;
2974 while ((c
= getc (fmem
)) != EOF
&& c
!= '\n')
2992 system_process_attributes (Lisp_Object pid
)
2994 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
2998 long clocks_per_sec
;
3000 char procbuf
[1025], *p
, *q
;
3003 static char const default_cmd
[] = "???";
3004 const char *cmd
= default_cmd
;
3005 int cmdsize
= sizeof default_cmd
- 1;
3006 char *cmdline
= NULL
;
3007 ptrdiff_t cmdline_size
;
3010 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
3013 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
3014 long priority
, niceness
, rss
;
3015 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
3016 struct timespec tnow
, tstart
, tboot
, telapsed
, us_time
;
3018 Lisp_Object attrs
= Qnil
;
3019 Lisp_Object cmd_str
, decoded_cmd
;
3022 CHECK_NUMBER_OR_FLOAT (pid
);
3023 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3024 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3025 if (stat (procfn
, &st
) < 0)
3030 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3032 pw
= getpwuid (uid
);
3035 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3038 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3040 gr
= getgrgid (gid
);
3043 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3045 count
= SPECPDL_INDEX ();
3046 strcpy (fn
, procfn
);
3047 procfn_end
= fn
+ strlen (fn
);
3048 strcpy (procfn_end
, "/stat");
3049 fd
= emacs_open (fn
, O_RDONLY
, 0);
3054 record_unwind_protect_int (close_file_unwind
, fd
);
3055 nread
= emacs_read (fd
, procbuf
, sizeof procbuf
- 1);
3059 procbuf
[nread
] = '\0';
3062 p
= strchr (p
, '(');
3065 q
= strrchr (p
+ 1, ')');
3075 /* Command name is encoded in locale-coding-system; decode it. */
3076 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
3077 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3078 Vlocale_coding_system
, 0);
3079 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3081 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
3082 utime stime cutime cstime priority nice thcount . start vsize rss */
3084 && (sscanf (q
+ 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
3085 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
3086 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
3087 &minflt
, &cminflt
, &majflt
, &cmajflt
,
3088 &u_time
, &s_time
, &cutime
, &cstime
,
3089 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
)
3094 state_str
[1] = '\0';
3095 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3096 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid
)), attrs
);
3097 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp
)), attrs
);
3098 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess
)), attrs
);
3099 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
3100 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid
)), attrs
);
3101 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
3102 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
3103 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)),
3105 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)),
3107 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
3108 if (clocks_per_sec
< 0)
3109 clocks_per_sec
= 100;
3110 attrs
= Fcons (Fcons (Qutime
,
3111 ltime_from_jiffies (u_time
, clocks_per_sec
)),
3113 attrs
= Fcons (Fcons (Qstime
,
3114 ltime_from_jiffies (s_time
, clocks_per_sec
)),
3116 attrs
= Fcons (Fcons (Qtime
,
3117 ltime_from_jiffies (s_time
+ u_time
,
3120 attrs
= Fcons (Fcons (Qcutime
,
3121 ltime_from_jiffies (cutime
, clocks_per_sec
)),
3123 attrs
= Fcons (Fcons (Qcstime
,
3124 ltime_from_jiffies (cstime
, clocks_per_sec
)),
3126 attrs
= Fcons (Fcons (Qctime
,
3127 ltime_from_jiffies (cstime
+ cutime
,
3130 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
3131 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
3132 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount
)),
3134 tnow
= current_timespec ();
3135 telapsed
= get_up_time ();
3136 tboot
= timespec_sub (tnow
, telapsed
);
3137 tstart
= time_from_jiffies (start
, clocks_per_sec
);
3138 tstart
= timespec_add (tboot
, tstart
);
3139 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
3140 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/ 1024)),
3142 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4 * rss
)), attrs
);
3143 telapsed
= timespec_sub (tnow
, tstart
);
3144 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
3145 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
3146 pcpu
= timespectod (us_time
) / timespectod (telapsed
);
3149 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
3150 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
3153 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
3156 unbind_to (count
, Qnil
);
3159 strcpy (procfn_end
, "/cmdline");
3160 fd
= emacs_open (fn
, O_RDONLY
, 0);
3163 ptrdiff_t readsize
, nread_incr
;
3164 record_unwind_protect_int (close_file_unwind
, fd
);
3165 record_unwind_protect_nothing ();
3166 nread
= cmdline_size
= 0;
3170 cmdline
= xpalloc (cmdline
, &cmdline_size
, 2, STRING_BYTES_BOUND
, 1);
3171 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3173 /* Leave room even if every byte needs escaping below. */
3174 readsize
= (cmdline_size
>> 1) - nread
;
3176 nread_incr
= emacs_read (fd
, cmdline
+ nread
, readsize
);
3177 nread
+= max (0, nread_incr
);
3179 while (nread_incr
== readsize
);
3183 /* We don't want trailing null characters. */
3184 for (p
= cmdline
+ nread
; cmdline
< p
&& !p
[-1]; p
--)
3187 /* Escape-quote whitespace and backslashes. */
3188 q
= cmdline
+ cmdline_size
;
3193 if (c_isspace (c
) || c
== '\\')
3197 nread
= cmdline
+ cmdline_size
- q
;
3202 nread
= cmdsize
+ 2;
3203 cmdline_size
= nread
+ 1;
3204 q
= cmdline
= xrealloc (cmdline
, cmdline_size
);
3205 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3206 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3208 /* Command line is encoded in locale-coding-system; decode it. */
3209 cmd_str
= make_unibyte_string (q
, nread
);
3210 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3211 Vlocale_coding_system
, 0);
3212 unbind_to (count
, Qnil
);
3213 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3219 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3221 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3222 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3223 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3224 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3225 #undef _FILE_OFFSET_BITS
3227 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3232 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3233 #define _FILE_OFFSET_BITS 64
3234 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3236 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3239 system_process_attributes (Lisp_Object pid
)
3241 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3246 struct psinfo pinfo
;
3252 Lisp_Object attrs
= Qnil
;
3253 Lisp_Object decoded_cmd
;
3256 CHECK_NUMBER_OR_FLOAT (pid
);
3257 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3258 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3259 if (stat (procfn
, &st
) < 0)
3264 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3266 pw
= getpwuid (uid
);
3269 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3272 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3274 gr
= getgrgid (gid
);
3277 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3279 count
= SPECPDL_INDEX ();
3280 strcpy (fn
, procfn
);
3281 procfn_end
= fn
+ strlen (fn
);
3282 strcpy (procfn_end
, "/psinfo");
3283 fd
= emacs_open (fn
, O_RDONLY
, 0);
3288 record_unwind_protect (close_file_unwind
, fd
);
3289 nread
= emacs_read (fd
, &pinfo
, sizeof pinfo
);
3292 if (nread
== sizeof pinfo
)
3294 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3295 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3296 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3300 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3301 state_str
[1] = '\0';
3302 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3305 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3306 need to get a string from it. */
3308 /* FIXME: missing: Qtpgid */
3320 Are they available? */
3322 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3323 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3324 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3325 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3326 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)),
3329 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3330 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)),
3332 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)),
3335 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3336 range 0 .. 2**15, representing 0.0 .. 1.0. */
3337 attrs
= Fcons (Fcons (Qpcpu
,
3338 make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)),
3340 attrs
= Fcons (Fcons (Qpmem
,
3341 make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)),
3344 decoded_cmd
= (code_convert_string_norecord
3345 (build_unibyte_string (pinfo
.pr_fname
),
3346 Vlocale_coding_system
, 0));
3347 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3348 decoded_cmd
= (code_convert_string_norecord
3349 (build_unibyte_string (pinfo
.pr_psargs
),
3350 Vlocale_coding_system
, 0));
3351 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3353 unbind_to (count
, Qnil
);
3357 #elif defined __FreeBSD__
3359 static struct timespec
3360 timeval_to_timespec (struct timeval t
)
3362 return make_timespec (t
.tv_sec
, t
.tv_usec
* 1000);
3366 make_lisp_timeval (struct timeval t
)
3368 return make_lisp_time (timeval_to_timespec (t
));
3372 system_process_attributes (Lisp_Object pid
)
3375 int pagesize
= getpagesize ();
3376 unsigned long npages
;
3382 char args
[MAXPATHLEN
];
3383 struct timespec t
, now
;
3385 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3386 struct kinfo_proc proc
;
3387 size_t proclen
= sizeof proc
;
3389 Lisp_Object attrs
= Qnil
;
3390 Lisp_Object decoded_comm
;
3392 CHECK_NUMBER_OR_FLOAT (pid
);
3393 CONS_TO_INTEGER (pid
, int, proc_id
);
3396 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3399 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3402 pw
= getpwuid (proc
.ki_uid
);
3405 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3407 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3410 gr
= getgrgid (proc
.ki_svgid
);
3413 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3415 decoded_comm
= (code_convert_string_norecord
3416 (build_unibyte_string (proc
.ki_comm
),
3417 Vlocale_coding_system
, 0));
3419 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3421 char state
[2] = {'\0', '\0'};
3422 switch (proc
.ki_stat
)
3444 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3447 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3448 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3449 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3452 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3455 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3457 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3458 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3459 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3460 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3461 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3463 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3465 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3467 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage
.ru_utime
),
3468 timeval_to_timespec (proc
.ki_rusage
.ru_stime
));
3469 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3471 attrs
= Fcons (Fcons (Qcutime
,
3472 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3474 attrs
= Fcons (Fcons (Qcstime
,
3475 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3477 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage_ch
.ru_utime
),
3478 timeval_to_timespec (proc
.ki_rusage_ch
.ru_stime
));
3479 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3481 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3483 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3484 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3485 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3486 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3487 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3490 now
= current_timespec ();
3491 t
= timespec_sub (now
, timeval_to_timespec (proc
.ki_start
));
3492 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3494 len
= sizeof fscale
;
3495 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3500 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3502 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3503 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3504 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3508 len
= sizeof npages
;
3509 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3511 double pmem
= (proc
.ki_flag
& P_INMEM
3512 ? 100.0 * proc
.ki_rssize
/ npages
3514 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3517 mib
[2] = KERN_PROC_ARGS
;
3519 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3522 for (i
= 0; i
< len
; i
++)
3524 if (! args
[i
] && i
< len
- 1)
3529 (code_convert_string_norecord
3530 (build_unibyte_string (args
),
3531 Vlocale_coding_system
, 0));
3533 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3539 /* The WINDOWSNT implementation is in w32.c.
3540 The MSDOS implementation is in dosfns.c. */
3541 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3544 system_process_attributes (Lisp_Object pid
)
3549 #endif /* !defined (WINDOWSNT) */
3551 /* Wide character string collation. */
3553 #ifdef __STDC_ISO_10646__
3555 # include <wctype.h>
3557 # if defined HAVE_NEWLOCALE || defined HAVE_SETLOCALE
3558 # include <locale.h>
3561 # define LC_COLLATE 0
3563 # ifndef LC_COLLATE_MASK
3564 # define LC_COLLATE_MASK 0
3569 # ifndef LC_CTYPE_MASK
3570 # define LC_CTYPE_MASK 0
3573 # ifndef HAVE_NEWLOCALE
3579 # define freelocale emacs_freelocale
3580 # define locale_t emacs_locale_t
3581 # define newlocale emacs_newlocale
3582 # define wcscoll_l emacs_wcscoll_l
3583 # define towlower_l emacs_towlower_l
3585 typedef char const *locale_t
;
3588 newlocale (int category_mask
, char const *locale
, locale_t loc
)
3594 freelocale (locale_t loc
)
3599 emacs_setlocale (int category
, char const *locale
)
3601 # ifdef HAVE_SETLOCALE
3603 char *loc
= setlocale (category
, locale
);
3614 wcscoll_l (wchar_t const *a
, wchar_t const *b
, locale_t loc
)
3617 char *oldloc
= emacs_setlocale (LC_COLLATE
, NULL
);
3625 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3626 strcpy (oldcopy
, oldloc
);
3627 if (! emacs_setlocale (LC_COLLATE
, loc
))
3632 result
= wcscoll (a
, b
);
3634 if (! emacs_setlocale (LC_COLLATE
, oldcopy
))
3645 towlower_l (wint_t wc
, locale_t loc
)
3648 char *oldloc
= emacs_setlocale (LC_CTYPE
, NULL
);
3653 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3654 strcpy (oldcopy
, oldloc
);
3655 if (emacs_setlocale (LC_CTYPE
, loc
))
3657 result
= towlower (wc
);
3658 emacs_setlocale (LC_COLLATE
, oldcopy
);
3668 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3669 Lisp_Object locale
, Lisp_Object ignore_case
)
3672 ptrdiff_t len
, i
, i_byte
;
3677 /* Convert byte stream to code points. */
3678 len
= SCHARS (s1
); i
= i_byte
= 0;
3679 SAFE_NALLOCA (p1
, 1, len
+ 1);
3681 FETCH_STRING_CHAR_ADVANCE (*(p1
+i
-1), s1
, i
, i_byte
);
3684 len
= SCHARS (s2
); i
= i_byte
= 0;
3685 SAFE_NALLOCA (p2
, 1, len
+ 1);
3687 FETCH_STRING_CHAR_ADVANCE (*(p2
+i
-1), s2
, i
, i_byte
);
3690 if (STRINGP (locale
))
3692 locale_t loc
= newlocale (LC_COLLATE_MASK
| LC_CTYPE_MASK
,
3693 SSDATA (locale
), 0);
3695 error ("Invalid locale %s: %s", SSDATA (locale
), strerror (errno
));
3697 if (! NILP (ignore_case
))
3698 for (int i
= 1; i
< 3; i
++)
3700 wchar_t *p
= (i
== 1) ? p1
: p2
;
3702 *p
= towlower_l (*p
, loc
);
3706 res
= wcscoll_l (p1
, p2
, loc
);
3712 if (! NILP (ignore_case
))
3713 for (int i
= 1; i
< 3; i
++)
3715 wchar_t *p
= (i
== 1) ? p1
: p2
;
3721 res
= wcscoll (p1
, p2
);
3724 # ifndef HAVE_NEWLOCALE
3726 error ("Invalid locale or string for collation: %s", strerror (err
));
3729 error ("Invalid string for collation: %s", strerror (err
));
3735 #endif /* __STDC_ISO_10646__ */
3739 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3740 Lisp_Object locale
, Lisp_Object ignore_case
)
3743 char *loc
= STRINGP (locale
) ? SSDATA (locale
) : NULL
;
3744 int res
, err
= errno
;
3747 res
= w32_compare_strings (SDATA (s1
), SDATA (s2
), loc
, !NILP (ignore_case
));
3749 error ("Invalid string for collation: %s", strerror (errno
));
3754 #endif /* WINDOWSNT */