1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2015 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 */
97 #include "termhooks.h"
100 #include "dispextern.h"
102 #include "cm.h" /* for reset_sys_modes */
106 /* In process.h which conflicts with the local copy. */
108 int _cdecl
_spawnlp (int, const char *, const char *, ...);
109 int _cdecl
_getpid (void);
110 /* The following is needed for O_CLOEXEC, F_SETFD, FD_CLOEXEC, and
111 several prototypes of functions called below. */
112 #include <sys/socket.h>
115 #include "syssignal.h"
118 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
120 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
123 /* Declare here, including term.h is problematic on some systems. */
124 extern void tputs (const char *, int, int (*)(int));
126 static const int baud_convert
[] =
128 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
129 1800, 2400, 4800, 9600, 19200, 38400
132 #if !defined HAVE_GET_CURRENT_DIR_NAME || defined BROKEN_GET_CURRENT_DIR_NAME \
133 || (defined HYBRID_GET_CURRENT_DIR_NAME)
134 /* Return the current working directory. Returns NULL on errors.
135 Any other returned value must be freed with free. This is used
136 only when get_current_dir_name is not defined on the system. */
138 get_current_dir_name (void)
141 char *pwd
= getenv ("PWD");
142 struct stat dotstat
, pwdstat
;
143 /* If PWD is accurate, use it instead of calling getcwd. PWD is
144 sometimes a nicer name, and using it may avoid a fatal error if a
145 parent directory is searchable but not readable. */
147 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
148 && stat (pwd
, &pwdstat
) == 0
149 && stat (".", &dotstat
) == 0
150 && dotstat
.st_ino
== pwdstat
.st_ino
151 && dotstat
.st_dev
== pwdstat
.st_dev
153 && strlen (pwd
) < MAXPATHLEN
157 buf
= malloc (strlen (pwd
) + 1);
164 size_t buf_size
= 1024;
165 buf
= malloc (buf_size
);
170 if (getcwd (buf
, buf_size
) == buf
)
174 int tmp_errno
= errno
;
180 buf
= realloc (buf
, buf_size
);
190 /* Discard pending input on all input descriptors. */
193 discard_tty_input (void)
196 struct emacs_tty buf
;
201 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
202 while (dos_keyread () != -1)
204 #else /* not MSDOS */
206 struct tty_display_info
*tty
;
207 for (tty
= tty_list
; tty
; tty
= tty
->next
)
209 if (tty
->input
) /* Is the device suspended? */
211 emacs_get_tty (fileno (tty
->input
), &buf
);
212 emacs_set_tty (fileno (tty
->input
), &buf
, 0);
216 #endif /* not MSDOS */
217 #endif /* not WINDOWSNT */
223 /* Arrange for character C to be read as the next input from
225 XXX What if we have multiple ttys?
231 if (! (FRAMEP (selected_frame
)
232 && FRAME_LIVE_P (XFRAME (selected_frame
))
233 && FRAME_TERMCAP_P (XFRAME (selected_frame
))))
236 /* Should perhaps error if in batch mode */
238 ioctl (fileno (CURTTY()->input
), TIOCSTI
, &c
);
239 #else /* no TIOCSTI */
240 error ("Cannot stuff terminal input characters in this version of Unix");
241 #endif /* no TIOCSTI */
247 init_baud_rate (int fd
)
257 #else /* not DOS_NT */
262 emacs_ospeed
= cfgetospeed (&sg
);
263 #endif /* not DOS_NT */
266 baud_rate
= (emacs_ospeed
< ARRAYELTS (baud_convert
)
267 ? baud_convert
[emacs_ospeed
] : 9600);
276 /* Wait for the subprocess with process id CHILD to terminate or change status.
277 CHILD must be a child process that has not been reaped.
278 If STATUS is non-null, store the waitpid-style exit status into *STATUS
279 and tell wait_reading_process_output that it needs to look around.
280 Use waitpid-style OPTIONS when waiting.
281 If INTERRUPTIBLE, this function is interruptible by a signal.
283 Return CHILD if successful, 0 if no status is available;
284 the latter is possible only when options & NOHANG. */
286 get_child_status (pid_t child
, int *status
, int options
, bool interruptible
)
290 /* Invoke waitpid only with a known process ID; do not invoke
291 waitpid with a nonpositive argument. Otherwise, Emacs might
292 reap an unwanted process by mistake. For example, invoking
293 waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
294 so that another thread running glib won't find them. */
297 while ((pid
= waitpid (child
, status
, options
)) < 0)
299 /* Check that CHILD is a child process that has not been reaped,
300 and that STATUS and OPTIONS are valid. Otherwise abort,
301 as continuing after this internal error could cause Emacs to
302 become confused and kill innocent-victim processes. */
306 /* Note: the MS-Windows emulation of waitpid calls QUIT
312 /* If successful and status is requested, tell wait_reading_process_output
313 that it needs to wake up and look around. */
314 if (pid
&& status
&& input_available_clear_time
)
315 *input_available_clear_time
= make_timespec (0, 0);
320 /* Wait for the subprocess with process id CHILD to terminate.
321 CHILD must be a child process that has not been reaped.
322 If STATUS is non-null, store the waitpid-style exit status into *STATUS
323 and tell wait_reading_process_output that it needs to look around.
324 If INTERRUPTIBLE, this function is interruptible by a signal. */
326 wait_for_termination (pid_t child
, int *status
, bool interruptible
)
328 get_child_status (child
, status
, 0, interruptible
);
331 /* Report whether the subprocess with process id CHILD has changed status.
332 Termination counts as a change of status.
333 CHILD must be a child process that has not been reaped.
334 If STATUS is non-null, store the waitpid-style exit status into *STATUS
335 and tell wait_reading_process_output that it needs to look around.
336 Use waitpid-style OPTIONS to check status, but do not wait.
338 Return CHILD if successful, 0 if no status is available because
339 the process's state has not changed. */
341 child_status_changed (pid_t child
, int *status
, int options
)
343 return get_child_status (child
, status
, WNOHANG
| options
, 0);
347 /* Set up the terminal at the other end of a pseudo-terminal that
348 we will be controlling an inferior through.
349 It should not echo or do line-editing, since that is done
350 in Emacs. No padding needed for insertion into an Emacs buffer. */
353 child_setup_tty (int out
)
358 emacs_get_tty (out
, &s
);
359 s
.main
.c_oflag
|= OPOST
; /* Enable output postprocessing */
360 s
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL on output */
362 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
363 Some versions of GNU Hurd do not have FFDLY? */
365 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
|FFDLY
);
366 /* No output delays */
368 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
);
369 /* No output delays */
372 s
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
373 s
.main
.c_lflag
|= ISIG
; /* Enable signals */
375 s
.main
.c_iflag
&= ~IUCLC
; /* Disable downcasing on input. */
378 s
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
381 s
.main
.c_oflag
&= ~OLCUC
; /* Disable upcasing on output. */
383 s
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
384 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CSIZE
) | CS8
; /* Don't strip 8th bit */
385 s
.main
.c_cc
[VERASE
] = CDISABLE
; /* disable erase processing */
386 s
.main
.c_cc
[VKILL
] = CDISABLE
; /* disable kill processing */
389 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
392 #ifdef SIGNALS_VIA_CHARACTERS
393 /* the QUIT and INTR character are used in process_send_signal
394 so set them here to something useful. */
395 if (s
.main
.c_cc
[VQUIT
] == CDISABLE
)
396 s
.main
.c_cc
[VQUIT
] = '\\'&037; /* Control-\ */
397 if (s
.main
.c_cc
[VINTR
] == CDISABLE
)
398 s
.main
.c_cc
[VINTR
] = 'C'&037; /* Control-C */
399 #endif /* not SIGNALS_VIA_CHARACTERS */
402 /* Also, PTY overloads NUL and BREAK.
403 don't ignore break, but don't signal either, so it looks like NUL. */
404 s
.main
.c_iflag
&= ~IGNBRK
;
405 s
.main
.c_iflag
&= ~BRKINT
;
406 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
407 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
408 would force it to 0377. That looks like duplicated code. */
409 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
412 /* We originally enabled ICANON (and set VEOF to 04), and then had
413 process.c send additional EOF chars to flush the output when faced
414 with long lines, but this leads to weird effects when the
415 subprocess has disabled ICANON and ends up seeing those spurious
416 extra EOFs. So we don't send EOFs any more in
417 process.c:send_process. First we tried to disable ICANON by
418 default, so if a subsprocess sets up ICANON, it's his problem (or
419 the Elisp package that talks to it) to deal with lines that are
420 too long. But this disables some features, such as the ability
421 to send EOF signals. So we re-enabled ICANON but there is no
422 more "send eof to flush" going on (which is wrong and unportable
423 in itself). The correct way to handle too much output is to
424 buffer what could not be written and then write it again when
425 select returns ok for writing. This has it own set of
426 problems. Write is now asynchronous, is that a problem? How much
427 do we buffer, and what do we do when that limit is reached? */
429 s
.main
.c_lflag
|= ICANON
; /* Enable line editing and eof processing */
430 s
.main
.c_cc
[VEOF
] = 'D'&037; /* Control-D */
431 #if 0 /* These settings only apply to non-ICANON mode. */
432 s
.main
.c_cc
[VMIN
] = 1;
433 s
.main
.c_cc
[VTIME
] = 0;
436 emacs_set_tty (out
, &s
, 0);
437 #endif /* not WINDOWSNT */
439 #endif /* not MSDOS */
442 /* Record a signal code and the action for it. */
446 struct sigaction action
;
449 static void save_signal_handlers (struct save_signal
*);
450 static void restore_signal_handlers (struct save_signal
*);
452 /* Suspend the Emacs process; give terminal to its superior. */
460 /* On a system where suspending is not implemented,
461 instead fork a subshell and let it talk directly to the terminal
468 /* Fork a subshell. */
473 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
476 char oldwd
[MAXPATHLEN
+1]; /* Fixed length is safe on MSDOS. */
478 char oldwd
[MAX_UTF8_PATH
];
483 struct save_signal saved_handlers
[5];
484 char *str
= SSDATA (encode_current_directory ());
490 char *volatile str_volatile
= str
;
497 error ("Can't spawn subshell");
499 saved_handlers
[0].code
= SIGINT
;
500 saved_handlers
[1].code
= SIGQUIT
;
501 saved_handlers
[2].code
= SIGTERM
;
503 saved_handlers
[3].code
= SIGIO
;
504 saved_handlers
[4].code
= 0;
506 saved_handlers
[3].code
= 0;
510 save_signal_handlers (saved_handlers
);
517 #ifdef DOS_NT /* MW, Aug 1993 */
518 getcwd (oldwd
, sizeof oldwd
);
520 sh
= egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
523 sh
= egetenv ("SHELL");
527 /* Use our buffer's default directory for the subshell. */
528 if (chdir (str
) != 0)
532 _exit (EXIT_CANCELED
);
536 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
538 char *epwd
= getenv ("PWD");
539 char old_pwd
[MAXPATHLEN
+1+4];
541 /* If PWD is set, pass it with corrected value. */
544 strcpy (old_pwd
, epwd
);
545 setenv ("PWD", str
, 1);
548 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
550 putenv (old_pwd
); /* restore previous value */
552 #else /* not MSDOS */
554 /* Waits for process completion */
555 pid
= _spawnlp (_P_WAIT
, sh
, sh
, NULL
);
556 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
558 write (1, "Can't execute subshell", 22);
559 #else /* not WINDOWSNT */
560 execlp (sh
, sh
, (char *) 0);
562 _exit (errno
== ENOENT
? EXIT_ENOENT
: EXIT_CANNOT_INVOKE
);
563 #endif /* not WINDOWSNT */
564 #endif /* not MSDOS */
567 /* Do this now if we did not do it before. */
569 save_signal_handlers (saved_handlers
);
573 wait_for_termination (pid
, &status
, 0);
575 restore_signal_handlers (saved_handlers
);
579 save_signal_handlers (struct save_signal
*saved_handlers
)
581 while (saved_handlers
->code
)
583 struct sigaction action
;
584 emacs_sigaction_init (&action
, SIG_IGN
);
585 sigaction (saved_handlers
->code
, &action
, &saved_handlers
->action
);
591 restore_signal_handlers (struct save_signal
*saved_handlers
)
593 while (saved_handlers
->code
)
595 sigaction (saved_handlers
->code
, &saved_handlers
->action
, 0);
601 static int old_fcntl_flags
[FD_SETSIZE
];
608 old_fcntl_flags
[fd
] = fcntl (fd
, F_GETFL
, 0) & ~FASYNC
;
609 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
] | FASYNC
);
610 interrupts_deferred
= 0;
619 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
]);
633 sigemptyset (&unblocked
);
635 sigaddset (&unblocked
, SIGWINCH
);
637 sigaddset (&unblocked
, SIGIO
);
638 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
640 interrupts_deferred
= 0;
645 unrequest_sigio (void)
653 sigemptyset (&blocked
);
655 sigaddset (&blocked
, SIGWINCH
);
657 sigaddset (&blocked
, SIGIO
);
658 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
659 interrupts_deferred
= 1;
667 block_child_signal (sigset_t
*oldset
)
670 sigemptyset (&blocked
);
671 sigaddset (&blocked
, SIGCHLD
);
672 sigaddset (&blocked
, SIGINT
);
673 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
676 /* Unblock SIGCHLD. */
679 unblock_child_signal (sigset_t
const *oldset
)
681 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
686 /* Saving and restoring the process group of Emacs's terminal. */
688 /* The process group of which Emacs was a member when it initially
691 If Emacs was in its own process group (i.e. inherited_pgroup ==
692 getpid ()), then we know we're running under a shell with job
693 control (Emacs would never be run as part of a pipeline).
696 If Emacs was not in its own process group, then we know we're
697 running under a shell (or a caller) that doesn't know how to
698 separate itself from Emacs (like sh). Emacs must be in its own
699 process group in order to receive SIGIO correctly. In this
700 situation, we put ourselves in our own pgroup, forcibly set the
701 tty's pgroup to our pgroup, and make sure to restore and reinstate
702 the tty's pgroup just like any other terminal setting. If
703 inherited_group was not the tty's pgroup, then we'll get a
704 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
705 it goes foreground in the future, which is what should happen. */
707 static pid_t inherited_pgroup
;
710 init_foreground_group (void)
712 pid_t pgrp
= getpgrp ();
713 inherited_pgroup
= getpid () == pgrp
? 0 : pgrp
;
716 /* Block and unblock SIGTTOU. */
719 block_tty_out_signal (sigset_t
*oldset
)
723 sigemptyset (&blocked
);
724 sigaddset (&blocked
, SIGTTOU
);
725 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
730 unblock_tty_out_signal (sigset_t
const *oldset
)
733 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
737 /* Safely set a controlling terminal FD's process group to PGID.
738 If we are not in the foreground already, POSIX requires tcsetpgrp
739 to deliver a SIGTTOU signal, which would stop us. This is an
740 annoyance, so temporarily ignore the signal.
742 In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
743 skip all this unless SIGTTOU is defined. */
745 tcsetpgrp_without_stopping (int fd
, pid_t pgid
)
750 block_tty_out_signal (&oldset
);
751 tcsetpgrp (fd
, pgid
);
752 unblock_tty_out_signal (&oldset
);
757 /* Split off the foreground process group to Emacs alone. When we are
758 in the foreground, but not started in our own process group,
759 redirect the tty device handle FD to point to our own process
760 group. FD must be the file descriptor of the controlling tty. */
762 narrow_foreground_group (int fd
)
764 if (inherited_pgroup
&& setpgid (0, 0) == 0)
765 tcsetpgrp_without_stopping (fd
, getpid ());
768 /* Set the tty to our original foreground group. */
770 widen_foreground_group (int fd
)
772 if (inherited_pgroup
&& setpgid (0, inherited_pgroup
) == 0)
773 tcsetpgrp_without_stopping (fd
, inherited_pgroup
);
776 /* Getting and setting emacs_tty structures. */
778 /* Set *TC to the parameters associated with the terminal FD,
779 or clear it if the parameters are not available.
780 Return 0 on success, -1 on failure. */
782 emacs_get_tty (int fd
, struct emacs_tty
*settings
)
784 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
785 memset (&settings
->main
, 0, sizeof (settings
->main
));
788 HANDLE h
= (HANDLE
)_get_osfhandle (fd
);
791 if (h
&& h
!= INVALID_HANDLE_VALUE
&& GetConsoleMode (h
, &console_mode
))
793 settings
->main
= console_mode
;
796 #endif /* WINDOWSNT */
799 /* We have those nifty POSIX tcmumbleattr functions. */
800 return tcgetattr (fd
, &settings
->main
);
805 /* Set the parameters of the tty on FD according to the contents of
806 *SETTINGS. If FLUSHP, discard input.
807 Return 0 if all went well, and -1 (setting errno) if anything failed. */
810 emacs_set_tty (int fd
, struct emacs_tty
*settings
, bool flushp
)
812 /* Set the primary parameters - baud rate, character size, etcetera. */
815 HANDLE h
= (HANDLE
)_get_osfhandle (fd
);
817 if (h
&& h
!= INVALID_HANDLE_VALUE
)
821 /* Assume the handle is open for input. */
823 FlushConsoleInputBuffer (h
);
824 new_mode
= settings
->main
;
825 SetConsoleMode (h
, new_mode
);
827 #endif /* WINDOWSNT */
830 /* We have those nifty POSIX tcmumbleattr functions.
831 William J. Smith <wjs@wiis.wang.com> writes:
832 "POSIX 1003.1 defines tcsetattr to return success if it was
833 able to perform any of the requested actions, even if some
834 of the requested actions could not be performed.
835 We must read settings back to ensure tty setup properly.
836 AIX requires this to keep tty from hanging occasionally." */
837 /* This make sure that we don't loop indefinitely in here. */
838 for (i
= 0 ; i
< 10 ; i
++)
839 if (tcsetattr (fd
, flushp
? TCSAFLUSH
: TCSADRAIN
, &settings
->main
) < 0)
850 memset (&new, 0, sizeof (new));
851 /* Get the current settings, and see if they're what we asked for. */
852 tcgetattr (fd
, &new);
853 /* We cannot use memcmp on the whole structure here because under
854 * aix386 the termios structure has some reserved field that may
857 if ( new.c_iflag
== settings
->main
.c_iflag
858 && new.c_oflag
== settings
->main
.c_oflag
859 && new.c_cflag
== settings
->main
.c_cflag
860 && new.c_lflag
== settings
->main
.c_lflag
861 && memcmp (new.c_cc
, settings
->main
.c_cc
, NCCS
) == 0)
868 /* We have survived the tempest. */
875 static int old_fcntl_owner
[FD_SETSIZE
];
876 #endif /* F_SETOWN */
878 /* This may also be defined in stdio,
879 but if so, this does no harm,
880 and using the same name avoids wasting the other one's space. */
883 unsigned char _sobuf
[BUFSIZ
+8];
888 /* Initialize the terminal mode on all tty devices that are currently
892 init_all_sys_modes (void)
894 struct tty_display_info
*tty
;
895 for (tty
= tty_list
; tty
; tty
= tty
->next
)
896 init_sys_modes (tty
);
899 /* Initialize the terminal mode on the given tty device. */
902 init_sys_modes (struct tty_display_info
*tty_out
)
904 struct emacs_tty tty
;
905 Lisp_Object terminal
;
907 Vtty_erase_char
= Qnil
;
912 if (!tty_out
->output
)
913 return; /* The tty is suspended. */
915 narrow_foreground_group (fileno (tty_out
->input
));
917 if (! tty_out
->old_tty
)
918 tty_out
->old_tty
= xmalloc (sizeof *tty_out
->old_tty
);
920 emacs_get_tty (fileno (tty_out
->input
), tty_out
->old_tty
);
922 tty
= *tty_out
->old_tty
;
924 #if !defined (DOS_NT)
925 XSETINT (Vtty_erase_char
, tty
.main
.c_cc
[VERASE
]);
927 tty
.main
.c_iflag
|= (IGNBRK
); /* Ignore break condition */
928 tty
.main
.c_iflag
&= ~ICRNL
; /* Disable map of CR to NL on input */
929 #ifdef INLCR /* I'm just being cautious,
930 since I can't check how widespread INLCR is--rms. */
931 tty
.main
.c_iflag
&= ~INLCR
; /* Disable map of NL to CR on input */
934 tty
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
936 tty
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
937 tty
.main
.c_lflag
&= ~ICANON
; /* Disable erase/kill processing */
939 tty
.main
.c_lflag
&= ~IEXTEN
; /* Disable other editing characters. */
941 tty
.main
.c_lflag
|= ISIG
; /* Enable signals */
942 if (tty_out
->flow_control
)
944 tty
.main
.c_iflag
|= IXON
; /* Enable start/stop output control */
946 tty
.main
.c_iflag
&= ~IXANY
;
950 tty
.main
.c_iflag
&= ~IXON
; /* Disable start/stop output control */
951 tty
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL
953 tty
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
955 if (tty_out
->meta_key
)
957 tty
.main
.c_cflag
|= CS8
; /* allow 8th bit on input */
958 tty
.main
.c_cflag
&= ~PARENB
;/* Don't check parity */
962 XSETTERMINAL(terminal
, tty_out
->terminal
);
963 if (!NILP (Fcontrolling_tty_p (terminal
)))
965 tty
.main
.c_cc
[VINTR
] = quit_char
; /* C-g (usually) gives SIGINT */
966 /* Set up C-g for both SIGQUIT and SIGINT.
967 We don't know which we will get, but we handle both alike
968 so which one it really gives us does not matter. */
969 tty
.main
.c_cc
[VQUIT
] = quit_char
;
973 /* We normally don't get interrupt or quit signals from tty
974 devices other than our controlling terminal; therefore,
975 we must handle C-g as normal input. Unfortunately, this
976 means that the interrupt and quit feature must be
977 disabled on secondary ttys, or we would not even see the
980 Note that even though emacsclient could have special code
981 to pass SIGINT to Emacs, we should _not_ enable
982 interrupt/quit keys for emacsclient frames. This means
983 that we can't break out of loops in C code from a
984 secondary tty frame, but we can always decide what
985 display the C-g came from, which is more important from a
986 usability point of view. (Consider the case when two
987 people work together using the same Emacs instance.) */
988 tty
.main
.c_cc
[VINTR
] = CDISABLE
;
989 tty
.main
.c_cc
[VQUIT
] = CDISABLE
;
991 tty
.main
.c_cc
[VMIN
] = 1; /* Input should wait for at least 1 char */
992 tty
.main
.c_cc
[VTIME
] = 0; /* no matter how long that takes. */
994 tty
.main
.c_cc
[VSWTCH
] = CDISABLE
; /* Turn off shell layering use
999 tty
.main
.c_cc
[VSUSP
] = CDISABLE
; /* Turn off handling of C-z. */
1002 tty
.main
.c_cc
[V_DSUSP
] = CDISABLE
; /* Turn off handling of C-y. */
1003 #endif /* V_DSUSP */
1004 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1005 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1008 tty
.main
.c_cc
[VLNEXT
] = CDISABLE
;
1011 tty
.main
.c_cc
[VREPRINT
] = CDISABLE
;
1012 #endif /* VREPRINT */
1014 tty
.main
.c_cc
[VWERASE
] = CDISABLE
;
1015 #endif /* VWERASE */
1017 tty
.main
.c_cc
[VDISCARD
] = CDISABLE
;
1018 #endif /* VDISCARD */
1020 if (tty_out
->flow_control
)
1023 tty
.main
.c_cc
[VSTART
] = '\021';
1026 tty
.main
.c_cc
[VSTOP
] = '\023';
1032 tty
.main
.c_cc
[VSTART
] = CDISABLE
;
1035 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1040 tty
.main
.c_cc
[VSTRT
] = CDISABLE
;
1041 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1042 tty
.main
.c_cc
[VSUSP
] = CDISABLE
;
1043 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1044 if (tty_out
->flow_control
)
1047 tty
.main
.c_cc
[VSTART
] = '\021';
1050 tty
.main
.c_cc
[VSTOP
] = '\023';
1053 /* Also, PTY overloads NUL and BREAK.
1054 don't ignore break, but don't signal either, so it looks like NUL.
1055 This really serves a purpose only if running in an XTERM window
1056 or via TELNET or the like, but does no harm elsewhere. */
1057 tty
.main
.c_iflag
&= ~IGNBRK
;
1058 tty
.main
.c_iflag
&= ~BRKINT
;
1060 #endif /* not DOS_NT */
1062 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1063 if (!tty_out
->term_initted
)
1064 internal_terminal_init ();
1065 dos_ttraw (tty_out
);
1068 emacs_set_tty (fileno (tty_out
->input
), &tty
, 0);
1070 /* This code added to insure that, if flow-control is not to be used,
1071 we have an unlocked terminal at the start. */
1074 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TCXONC
, 1);
1077 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TIOCSTART
, 0);
1080 #if !defined (DOS_NT)
1082 if (!tty_out
->flow_control
) tcflow (fileno (tty_out
->input
), TCOON
);
1087 if (interrupt_input
)
1089 old_fcntl_owner
[fileno (tty_out
->input
)] =
1090 fcntl (fileno (tty_out
->input
), F_GETOWN
, 0);
1091 fcntl (fileno (tty_out
->input
), F_SETOWN
, getpid ());
1092 init_sigio (fileno (tty_out
->input
));
1094 if (gpm_tty
== tty_out
)
1096 /* Arrange for mouse events to give us SIGIO signals. */
1097 fcntl (gpm_fd
, F_SETOWN
, getpid ());
1098 fcntl (gpm_fd
, F_SETFL
, fcntl (gpm_fd
, F_GETFL
, 0) | O_NONBLOCK
);
1099 init_sigio (gpm_fd
);
1101 #endif /* HAVE_GPM */
1103 #endif /* F_GETOWN */
1106 /* This symbol is defined on recent USG systems.
1107 Someone says without this call USG won't really buffer the file
1108 even with a call to setbuf. */
1109 setvbuf (tty_out
->output
, (char *) _sobuf
, _IOFBF
, sizeof _sobuf
);
1111 setbuf (tty_out
->output
, (char *) _sobuf
);
1114 if (tty_out
->terminal
->set_terminal_modes_hook
)
1115 tty_out
->terminal
->set_terminal_modes_hook (tty_out
->terminal
);
1117 if (!tty_out
->term_initted
)
1119 Lisp_Object tail
, frame
;
1120 FOR_EACH_FRAME (tail
, frame
)
1122 /* XXX This needs to be revised. */
1123 if (FRAME_TERMCAP_P (XFRAME (frame
))
1124 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1125 init_frame_faces (XFRAME (frame
));
1129 if (tty_out
->term_initted
&& no_redraw_on_reenter
)
1131 /* We used to call "direct_output_forward_char(0)" here,
1132 but it's not clear why, since it may not do anything anyway. */
1136 Lisp_Object tail
, frame
;
1138 FOR_EACH_FRAME (tail
, frame
)
1140 if ((FRAME_TERMCAP_P (XFRAME (frame
))
1141 || FRAME_MSDOS_P (XFRAME (frame
)))
1142 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1143 FRAME_GARBAGED_P (XFRAME (frame
)) = 1;
1147 tty_out
->term_initted
= 1;
1150 /* Return true if safe to use tabs in output.
1151 At the time this is called, init_sys_modes has not been done yet. */
1154 tabs_safe_p (int fd
)
1156 struct emacs_tty etty
;
1158 emacs_get_tty (fd
, &etty
);
1161 return ((etty
.main
.c_oflag
& TABDLY
) != TAB3
);
1162 #else /* not TABDLY */
1164 #endif /* not TABDLY */
1170 /* Discard echoing. */
1173 suppress_echo_on_tty (int fd
)
1175 struct emacs_tty etty
;
1177 emacs_get_tty (fd
, &etty
);
1179 /* Set raw input mode. */
1182 etty
.main
.c_lflag
&= ~ICANON
; /* Disable buffering */
1183 etty
.main
.c_lflag
&= ~ECHO
; /* Disable echoing */
1184 #endif /* ! WINDOWSNT */
1185 emacs_set_tty (fd
, &etty
, 0);
1188 /* Get terminal size from system.
1189 Store number of lines into *HEIGHTP and width into *WIDTHP.
1190 We store 0 if there's no valid information. */
1193 get_tty_size (int fd
, int *widthp
, int *heightp
)
1195 #if defined TIOCGWINSZ
1198 struct winsize size
;
1200 if (ioctl (fd
, TIOCGWINSZ
, &size
) == -1)
1201 *widthp
= *heightp
= 0;
1204 *widthp
= size
.ws_col
;
1205 *heightp
= size
.ws_row
;
1208 #elif defined TIOCGSIZE
1210 /* SunOS - style. */
1211 struct ttysize size
;
1213 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1214 *widthp
= *heightp
= 0;
1217 *widthp
= size
.ts_cols
;
1218 *heightp
= size
.ts_lines
;
1221 #elif defined WINDOWSNT
1223 CONSOLE_SCREEN_BUFFER_INFO info
;
1224 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE
), &info
))
1226 *widthp
= info
.srWindow
.Right
- info
.srWindow
.Left
+ 1;
1227 *heightp
= info
.srWindow
.Bottom
- info
.srWindow
.Top
+ 1;
1230 *widthp
= *heightp
= 0;
1234 *widthp
= ScreenCols ();
1235 *heightp
= ScreenRows ();
1237 #else /* system doesn't know size */
1245 /* Set the logical window size associated with descriptor FD
1246 to HEIGHT and WIDTH. This is used mainly with ptys.
1247 Return a negative value on failure. */
1250 set_window_size (int fd
, int height
, int width
)
1255 struct winsize size
;
1256 size
.ws_row
= height
;
1257 size
.ws_col
= width
;
1259 return ioctl (fd
, TIOCSWINSZ
, &size
);
1264 /* SunOS - style. */
1265 struct ttysize size
;
1266 size
.ts_lines
= height
;
1267 size
.ts_cols
= width
;
1269 return ioctl (fd
, TIOCGSIZE
, &size
);
1272 #endif /* not SunOS-style */
1273 #endif /* not BSD-style */
1278 /* Prepare all terminal devices for exiting Emacs. */
1281 reset_all_sys_modes (void)
1283 struct tty_display_info
*tty
;
1284 for (tty
= tty_list
; tty
; tty
= tty
->next
)
1285 reset_sys_modes (tty
);
1288 /* Prepare the terminal for closing it; move the cursor to the
1289 bottom of the frame, turn off interrupt-driven I/O, etc. */
1292 reset_sys_modes (struct tty_display_info
*tty_out
)
1299 if (!tty_out
->term_initted
)
1302 if (!tty_out
->output
)
1303 return; /* The tty is suspended. */
1305 /* Go to and clear the last line of the terminal. */
1307 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1309 /* Code adapted from tty_clear_end_of_line. */
1310 if (tty_out
->TS_clr_line
)
1312 emacs_tputs (tty_out
, tty_out
->TS_clr_line
, 1, cmputc
);
1315 { /* have to do it the hard way */
1317 tty_turn_off_insert (tty_out
);
1319 for (i
= cursorX (tty_out
); i
< FrameCols (tty_out
) - 1; i
++)
1321 fputc (' ', tty_out
->output
);
1325 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1326 fflush (tty_out
->output
);
1328 if (tty_out
->terminal
->reset_terminal_modes_hook
)
1329 tty_out
->terminal
->reset_terminal_modes_hook (tty_out
->terminal
);
1331 /* Avoid possible loss of output when changing terminal modes. */
1332 while (fdatasync (fileno (tty_out
->output
)) != 0 && errno
== EINTR
)
1337 if (interrupt_input
)
1339 reset_sigio (fileno (tty_out
->input
));
1340 fcntl (fileno (tty_out
->input
), F_SETOWN
,
1341 old_fcntl_owner
[fileno (tty_out
->input
)]);
1343 #endif /* F_SETOWN */
1344 fcntl (fileno (tty_out
->input
), F_SETFL
,
1345 fcntl (fileno (tty_out
->input
), F_GETFL
, 0) & ~O_NONBLOCK
);
1348 if (tty_out
->old_tty
)
1349 while (emacs_set_tty (fileno (tty_out
->input
),
1350 tty_out
->old_tty
, 0) < 0 && errno
== EINTR
)
1353 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1357 widen_foreground_group (fileno (tty_out
->input
));
1362 /* Set up the proper status flags for use of a pty. */
1367 /* I'm told that TOICREMOTE does not mean control chars
1368 "can't be sent" but rather that they don't have
1369 input-editing or signaling effects.
1370 That should be good, because we have other ways
1371 to do those things in Emacs.
1372 However, telnet mode seems not to work on 4.2.
1373 So TIOCREMOTE is turned off now. */
1375 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1376 will hang. In particular, the "timeout" feature (which
1377 causes a read to return if there is no data available)
1378 does this. Also it is known that telnet mode will hang
1379 in such a way that Emacs must be stopped (perhaps this
1380 is the same problem).
1382 If TIOCREMOTE is turned off, then there is a bug in
1383 hp-ux which sometimes loses data. Apparently the
1384 code which blocks the master process when the internal
1385 buffer fills up does not work. Other than this,
1386 though, everything else seems to work fine.
1388 Since the latter lossage is more benign, we may as well
1389 lose that way. -- cph */
1391 #if defined (UNIX98_PTYS)
1394 ioctl (fd
, FIONBIO
, &on
);
1399 #endif /* HAVE_PTYS */
1402 init_system_name (void)
1404 char *hostname_alloc
= NULL
;
1406 #ifndef HAVE_GETHOSTNAME
1409 hostname
= uts
.nodename
;
1410 #else /* HAVE_GETHOSTNAME */
1411 char hostname_buf
[256];
1412 ptrdiff_t hostname_size
= sizeof hostname_buf
;
1413 hostname
= hostname_buf
;
1415 /* Try to get the host name; if the buffer is too short, try
1416 again. Apparently, the only indication gethostname gives of
1417 whether the buffer was large enough is the presence or absence
1418 of a '\0' in the string. Eech. */
1421 gethostname (hostname
, hostname_size
- 1);
1422 hostname
[hostname_size
- 1] = '\0';
1424 /* Was the buffer large enough for the '\0'? */
1425 if (strlen (hostname
) < hostname_size
- 1)
1428 hostname
= hostname_alloc
= xpalloc (hostname_alloc
, &hostname_size
, 1,
1429 min (PTRDIFF_MAX
, SIZE_MAX
), 1);
1431 #endif /* HAVE_GETHOSTNAME */
1433 for (p
= hostname
; *p
; p
++)
1434 if (*p
== ' ' || *p
== '\t')
1436 if (! (STRINGP (Vsystem_name
) && SBYTES (Vsystem_name
) == p
- hostname
1437 && strcmp (SSDATA (Vsystem_name
), hostname
) == 0))
1438 Vsystem_name
= build_string (hostname
);
1439 xfree (hostname_alloc
);
1442 sigset_t empty_mask
;
1444 static struct sigaction process_fatal_action
;
1447 emacs_sigaction_flags (void)
1450 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1451 'select') to reset their timeout on some platforms (e.g.,
1452 HP-UX 11), which is not what we want. Also, when Emacs is
1453 interactive, we don't want SA_RESTART because we need to poll
1454 for pending input so we need long-running syscalls to be interrupted
1455 after a signal that sets pending_signals.
1457 Non-interactive keyboard input goes through stdio, where we
1458 always want restartable system calls. */
1465 /* Store into *ACTION a signal action suitable for Emacs, with handler
1468 emacs_sigaction_init (struct sigaction
*action
, signal_handler_t handler
)
1470 sigemptyset (&action
->sa_mask
);
1472 /* When handling a signal, block nonfatal system signals that are caught
1473 by Emacs. This makes race conditions less likely. */
1474 sigaddset (&action
->sa_mask
, SIGALRM
);
1476 sigaddset (&action
->sa_mask
, SIGCHLD
);
1479 sigaddset (&action
->sa_mask
, SIGDANGER
);
1481 #ifdef PROFILER_CPU_SUPPORT
1482 sigaddset (&action
->sa_mask
, SIGPROF
);
1485 sigaddset (&action
->sa_mask
, SIGWINCH
);
1487 if (! noninteractive
)
1489 sigaddset (&action
->sa_mask
, SIGINT
);
1490 sigaddset (&action
->sa_mask
, SIGQUIT
);
1492 sigaddset (&action
->sa_mask
, SIGIO
);
1496 action
->sa_handler
= handler
;
1497 action
->sa_flags
= emacs_sigaction_flags ();
1500 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1501 static pthread_t main_thread
;
1504 /* SIG has arrived at the current process. Deliver it to the main
1505 thread, which should handle it with HANDLER.
1507 If we are on the main thread, handle the signal SIG with HANDLER.
1508 Otherwise, redirect the signal to the main thread, blocking it from
1509 this thread. POSIX says any thread can receive a signal that is
1510 associated with a process, process group, or asynchronous event.
1511 On GNU/Linux that is not true, but for other systems (FreeBSD at
1514 deliver_process_signal (int sig
, signal_handler_t handler
)
1516 /* Preserve errno, to avoid race conditions with signal handlers that
1517 might change errno. Races can occur even in single-threaded hosts. */
1518 int old_errno
= errno
;
1520 bool on_main_thread
= true;
1521 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1522 if (! pthread_equal (pthread_self (), main_thread
))
1525 sigemptyset (&blocked
);
1526 sigaddset (&blocked
, sig
);
1527 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1528 pthread_kill (main_thread
, sig
);
1529 on_main_thread
= false;
1538 /* Static location to save a fatal backtrace in a thread.
1539 FIXME: If two subsidiary threads fail simultaneously, the resulting
1540 backtrace may be garbage. */
1541 enum { BACKTRACE_LIMIT_MAX
= 500 };
1542 static void *thread_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
1543 static int thread_backtrace_npointers
;
1545 /* SIG has arrived at the current thread.
1546 If we are on the main thread, handle the signal SIG with HANDLER.
1547 Otherwise, this is a fatal error in the handling thread. */
1549 deliver_thread_signal (int sig
, signal_handler_t handler
)
1551 int old_errno
= errno
;
1553 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1554 if (! pthread_equal (pthread_self (), main_thread
))
1556 thread_backtrace_npointers
1557 = backtrace (thread_backtrace_buffer
, BACKTRACE_LIMIT_MAX
);
1558 sigaction (sig
, &process_fatal_action
, 0);
1559 pthread_kill (main_thread
, sig
);
1561 /* Avoid further damage while the main thread is exiting. */
1563 sigsuspend (&empty_mask
);
1571 #if !HAVE_DECL_SYS_SIGLIST
1573 # ifdef _sys_siglist
1574 # define sys_siglist _sys_siglist
1575 # elif HAVE_DECL___SYS_SIGLIST
1576 # define sys_siglist __sys_siglist
1578 # define sys_siglist my_sys_siglist
1579 static char const *sys_siglist
[NSIG
];
1584 # define sys_siglist_entries _sys_nsig
1586 # define sys_siglist_entries NSIG
1589 /* Handle bus errors, invalid instruction, etc. */
1591 handle_fatal_signal (int sig
)
1593 terminate_due_to_signal (sig
, 40);
1597 deliver_fatal_signal (int sig
)
1599 deliver_process_signal (sig
, handle_fatal_signal
);
1603 deliver_fatal_thread_signal (int sig
)
1605 deliver_thread_signal (sig
, handle_fatal_signal
);
1608 static _Noreturn
void
1609 handle_arith_signal (int sig
)
1611 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1612 xsignal0 (Qarith_error
);
1615 #if defined HAVE_STACK_OVERFLOW_HANDLING && !defined WINDOWSNT
1617 /* Alternate stack used by SIGSEGV handler below. */
1619 static unsigned char sigsegv_stack
[SIGSTKSZ
];
1622 /* Return true if SIGINFO indicates a stack overflow. */
1625 stack_overflow (siginfo_t
*siginfo
)
1627 /* In theory, a more-accurate heuristic can be obtained by using
1628 GNU/Linux pthread_getattr_np along with POSIX pthread_attr_getstack
1629 and pthread_attr_getguardsize to find the location and size of the
1630 guard area. In practice, though, these functions are so hard to
1631 use reliably that they're not worth bothering with. E.g., see:
1632 https://sourceware.org/bugzilla/show_bug.cgi?id=16291
1633 Other operating systems also have problems, e.g., Solaris's
1634 stack_violation function is tailor-made for this problem, but it
1635 doesn't work on Solaris 11.2 x86-64 with a 32-bit executable.
1637 GNU libsigsegv is overkill for Emacs; otherwise it might be a
1643 /* The faulting address. */
1644 char *addr
= siginfo
->si_addr
;
1648 /* The known top and bottom of the stack. The actual stack may
1649 extend a bit beyond these boundaries. */
1650 char *bot
= stack_bottom
;
1651 char *top
= near_C_stack_top ();
1653 /* Log base 2 of the stack heuristic ratio. This ratio is the size
1654 of the known stack divided by the size of the guard area past the
1655 end of the stack top. The heuristic is that a bad address is
1656 considered to be a stack overflow if it occurs within
1657 stacksize>>LG_STACK_HEURISTIC bytes above the top of the known
1658 stack. This heuristic is not exactly correct but it's good
1659 enough in practice. */
1660 enum { LG_STACK_HEURISTIC
= 8 };
1663 return 0 <= addr
- top
&& addr
- top
< (top
- bot
) >> LG_STACK_HEURISTIC
;
1665 return 0 <= top
- addr
&& top
- addr
< (bot
- top
) >> LG_STACK_HEURISTIC
;
1669 /* Attempt to recover from SIGSEGV caused by C stack overflow. */
1672 handle_sigsegv (int sig
, siginfo_t
*siginfo
, void *arg
)
1674 /* Hard GC error may lead to stack overflow caused by
1675 too nested calls to mark_object. No way to survive. */
1676 bool fatal
= gc_in_progress
;
1678 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1679 if (!fatal
&& !pthread_equal (pthread_self (), main_thread
))
1683 if (!fatal
&& stack_overflow (siginfo
))
1684 siglongjmp (return_to_command_loop
, 1);
1686 /* Otherwise we can't do anything with this. */
1687 deliver_fatal_thread_signal (sig
);
1690 /* Return true if we have successfully set up SIGSEGV handler on alternate
1691 stack. Otherwise we just treat SIGSEGV among the rest of fatal signals. */
1696 struct sigaction sa
;
1699 ss
.ss_sp
= sigsegv_stack
;
1700 ss
.ss_size
= sizeof (sigsegv_stack
);
1702 if (sigaltstack (&ss
, NULL
) < 0)
1705 sigfillset (&sa
.sa_mask
);
1706 sa
.sa_sigaction
= handle_sigsegv
;
1707 sa
.sa_flags
= SA_SIGINFO
| SA_ONSTACK
| emacs_sigaction_flags ();
1708 return sigaction (SIGSEGV
, &sa
, NULL
) < 0 ? 0 : 1;
1711 #else /* not HAVE_STACK_OVERFLOW_HANDLING or WINDOWSNT */
1719 #endif /* HAVE_STACK_OVERFLOW_HANDLING && !WINDOWSNT */
1722 deliver_arith_signal (int sig
)
1724 deliver_thread_signal (sig
, handle_arith_signal
);
1729 /* Handler for SIGDANGER. */
1731 handle_danger_signal (int sig
)
1733 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1735 /* It might be unsafe to call do_auto_save now. */
1736 force_auto_save_soon ();
1740 deliver_danger_signal (int sig
)
1742 deliver_process_signal (sig
, handle_danger_signal
);
1746 /* Treat SIG as a terminating signal, unless it is already ignored and
1747 we are in --batch mode. Among other things, this makes nohup work. */
1749 maybe_fatal_sig (int sig
)
1751 bool catch_sig
= !noninteractive
;
1754 struct sigaction old_action
;
1755 sigaction (sig
, 0, &old_action
);
1756 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1759 sigaction (sig
, &process_fatal_action
, 0);
1763 init_signals (bool dumping
)
1765 struct sigaction thread_fatal_action
;
1766 struct sigaction action
;
1768 sigemptyset (&empty_mask
);
1770 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1771 main_thread
= pthread_self ();
1774 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1777 sys_siglist
[SIGABRT
] = "Aborted";
1779 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1781 sys_siglist
[SIGALRM
] = "Alarm clock";
1783 sys_siglist
[SIGBUS
] = "Bus error";
1786 sys_siglist
[SIGCHLD
] = "Child status changed";
1789 sys_siglist
[SIGCONT
] = "Continued";
1792 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1795 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1798 sys_siglist
[SIGEMT
] = "Emulation trap";
1800 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1802 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1805 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1807 sys_siglist
[SIGHUP
] = "Hangup";
1808 sys_siglist
[SIGILL
] = "Illegal instruction";
1809 sys_siglist
[SIGINT
] = "Interrupt";
1811 sys_siglist
[SIGIO
] = "I/O possible";
1814 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1817 sys_siglist
[SIGIOT
] = "IOT trap";
1819 sys_siglist
[SIGKILL
] = "Killed";
1821 sys_siglist
[SIGLOST
] = "Resource lost";
1824 sys_siglist
[SIGLWP
] = "SIGLWP";
1827 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1830 sys_siglist
[SIGWIND
] = "SIGPHONE";
1832 sys_siglist
[SIGPIPE
] = "Broken pipe";
1834 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1837 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1840 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1843 sys_siglist
[SIGPWR
] = "Power-fail restart";
1845 sys_siglist
[SIGQUIT
] = "Quit";
1847 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1850 sys_siglist
[SIGSAK
] = "Secure attention";
1852 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1854 sys_siglist
[SIGSOUND
] = "Sound completed";
1857 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1860 sys_siglist
[SIGSTP
] = "Stopped (user)";
1863 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1865 sys_siglist
[SIGTERM
] = "Terminated";
1867 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1870 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1873 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1876 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1879 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1882 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1885 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1888 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1891 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1894 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1897 sys_siglist
[SIGWINCH
] = "Window size changed";
1900 sys_siglist
[SIGWIND
] = "SIGWIND";
1903 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1906 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1909 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1911 /* Don't alter signal handlers if dumping. On some machines,
1912 changing signal handlers sets static data that would make signals
1913 fail to work right when the dumped Emacs is run. */
1917 sigfillset (&process_fatal_action
.sa_mask
);
1918 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1919 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1921 sigfillset (&thread_fatal_action
.sa_mask
);
1922 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1923 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1925 /* SIGINT may need special treatment on MS-Windows. See
1926 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1927 Please update the doc of kill-emacs, kill-emacs-hook, and
1928 NEWS if you change this. */
1930 maybe_fatal_sig (SIGHUP
);
1931 maybe_fatal_sig (SIGINT
);
1932 maybe_fatal_sig (SIGTERM
);
1934 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1935 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1936 to behave more like typical batch applications do. */
1937 if (! noninteractive
)
1938 signal (SIGPIPE
, SIG_IGN
);
1940 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1941 sigaction (SIGILL
, &thread_fatal_action
, 0);
1942 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1944 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1945 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1946 interpreter's floating point operations, so treat SIGFPE as an
1947 arith-error if it arises in the main thread. */
1948 if (IEEE_FLOATING_POINT
)
1949 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1952 emacs_sigaction_init (&action
, deliver_arith_signal
);
1953 sigaction (SIGFPE
, &action
, 0);
1957 add_user_signal (SIGUSR1
, "sigusr1");
1960 add_user_signal (SIGUSR2
, "sigusr2");
1962 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1964 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1967 sigaction (SIGORE
, &thread_fatal_action
, 0);
1970 sigaction (SIGUME
, &thread_fatal_action
, 0);
1973 sigaction (SIGDLK
, &process_fatal_action
, 0);
1976 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1979 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1982 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1985 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1987 if (!init_sigsegv ())
1988 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
1990 sigaction (SIGSYS
, &thread_fatal_action
, 0);
1992 sigaction (SIGTERM
, &process_fatal_action
, 0);
1994 signal (SIGPROF
, SIG_IGN
);
1997 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
2000 sigaction (SIGXCPU
, &process_fatal_action
, 0);
2003 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
2007 /* This just means available memory is getting low. */
2008 emacs_sigaction_init (&action
, deliver_danger_signal
);
2009 sigaction (SIGDANGER
, &action
, 0);
2012 /* AIX-specific signals. */
2014 sigaction (SIGGRANT
, &process_fatal_action
, 0);
2017 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
2020 sigaction (SIGMSG
, &process_fatal_action
, 0);
2023 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
2026 sigaction (SIGSAK
, &process_fatal_action
, 0);
2029 sigaction (SIGSOUND
, &process_fatal_action
, 0);
2032 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
2042 /* Figure out how many bits the system's random number generator uses.
2043 `random' and `lrand48' are assumed to return 31 usable bits.
2044 BSD `rand' returns a 31 bit value but the low order bits are unusable;
2045 so we'll shift it and treat it like the 15-bit USG `rand'. */
2049 # define RAND_BITS 31
2050 # else /* !HAVE_RANDOM */
2051 # ifdef HAVE_LRAND48
2052 # define RAND_BITS 31
2053 # define random lrand48
2054 # else /* !HAVE_LRAND48 */
2055 # define RAND_BITS 15
2056 # if RAND_MAX == 32767
2057 # define random rand
2058 # else /* RAND_MAX != 32767 */
2059 # if RAND_MAX == 2147483647
2060 # define random() (rand () >> 16)
2061 # else /* RAND_MAX != 2147483647 */
2063 # define random rand
2065 # define random() (rand () >> 16)
2067 # endif /* RAND_MAX != 2147483647 */
2068 # endif /* RAND_MAX != 32767 */
2069 # endif /* !HAVE_LRAND48 */
2070 # endif /* !HAVE_RANDOM */
2071 #endif /* !RAND_BITS */
2074 seed_random (void *seed
, ptrdiff_t seed_size
)
2076 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
2077 unsigned int arg
= 0;
2081 unsigned char *argp
= (unsigned char *) &arg
;
2082 unsigned char *seedp
= seed
;
2084 for (i
= 0; i
< seed_size
; i
++)
2085 argp
[i
% sizeof arg
] ^= seedp
[i
];
2089 # ifdef HAVE_LRAND48
2100 struct timespec t
= current_timespec ();
2101 uintmax_t v
= getpid () ^ t
.tv_sec
^ t
.tv_nsec
;
2102 seed_random (&v
, sizeof v
);
2106 * Return a nonnegative random integer out of whatever we've got.
2107 * It contains enough bits to make a random (signed) Emacs fixnum.
2108 * This suffices even for a 64-bit architecture with a 15-bit rand.
2115 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2116 val
= (random () ^ (val
<< RAND_BITS
)
2117 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2118 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2119 return val
& INTMASK
;
2122 #ifndef HAVE_SNPRINTF
2123 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2125 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2127 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2128 ptrdiff_t nbytes
= size
- 1;
2133 va_start (ap
, format
);
2134 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2138 if (nbytes
== size
- 1)
2140 /* Calculate the length of the string that would have been created
2141 had the buffer been large enough. */
2142 char stackbuf
[4000];
2144 ptrdiff_t bsize
= sizeof stackbuf
;
2145 va_start (ap
, format
);
2146 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2152 if (INT_MAX
< nbytes
)
2165 /* If a backtrace is available, output the top lines of it to stderr.
2166 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2167 This function may be called from a signal handler, so it should
2168 not invoke async-unsafe functions like malloc.
2170 If BACKTRACE_LIMIT is -1, initialize tables that 'backtrace' uses
2171 but do not output anything. This avoids some problems that can
2172 otherwise occur if the malloc arena is corrupted before 'backtrace'
2173 is called, since 'backtrace' may call malloc if the tables are not
2176 If the static variable THREAD_BACKTRACE_NPOINTERS is nonzero, a
2177 fatal error has occurred in some other thread; generate a thread
2178 backtrace instead, ignoring BACKTRACE_LIMIT. */
2180 emacs_backtrace (int backtrace_limit
)
2182 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2183 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2187 if (thread_backtrace_npointers
)
2189 buffer
= thread_backtrace_buffer
;
2190 npointers
= thread_backtrace_npointers
;
2194 buffer
= main_backtrace_buffer
;
2196 /* Work around 'backtrace' bug; see Bug#19959 and glibc bug#18084. */
2197 if (bounded_limit
< 0)
2199 backtrace (buffer
, 1);
2203 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2208 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2209 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2210 if (bounded_limit
< npointers
)
2211 emacs_write (STDERR_FILENO
, "...\n", 4);
2219 terminate_due_to_signal (SIGABRT
, 40);
2223 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2224 Use binary I/O on systems that care about text vs binary I/O.
2225 Arrange for subprograms to not inherit the file descriptor.
2226 Prefer a method that is multithread-safe, if available.
2227 Do not fail merely because the open was interrupted by a signal.
2228 Allow the user to quit. */
2231 emacs_open (const char *file
, int oflags
, int mode
)
2234 if (! (oflags
& O_TEXT
))
2236 oflags
|= O_CLOEXEC
;
2237 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2239 if (! O_CLOEXEC
&& 0 <= fd
)
2240 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2244 /* Open FILE as a stream for Emacs use, with mode MODE.
2245 Act like emacs_open with respect to threads, signals, and quits. */
2248 emacs_fopen (char const *file
, char const *mode
)
2250 int fd
, omode
, oflags
;
2252 char const *m
= mode
;
2256 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2257 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2258 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2259 default: emacs_abort ();
2265 case '+': omode
= O_RDWR
; break;
2266 case 'b': bflag
= O_BINARY
; break;
2267 case 't': bflag
= O_TEXT
; break;
2268 default: /* Ignore. */ break;
2271 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2272 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2275 /* Create a pipe for Emacs use. */
2278 emacs_pipe (int fd
[2])
2283 int result
= pipe2 (fd
, O_BINARY
| O_CLOEXEC
);
2284 if (! O_CLOEXEC
&& result
== 0)
2286 fcntl (fd
[0], F_SETFD
, FD_CLOEXEC
);
2287 fcntl (fd
[1], F_SETFD
, FD_CLOEXEC
);
2293 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2294 For the background behind this mess, please see Austin Group defect 529
2295 <http://austingroupbugs.net/view.php?id=529>. */
2297 #ifndef POSIX_CLOSE_RESTART
2298 # define POSIX_CLOSE_RESTART 1
2300 posix_close (int fd
, int flag
)
2302 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2303 eassert (flag
== POSIX_CLOSE_RESTART
);
2305 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2306 on a system that does not define POSIX_CLOSE_RESTART.
2308 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2309 closed, and retrying the close could inadvertently close a file
2310 descriptor allocated by some other thread. In other systems
2311 (e.g., HP/UX) FD is not closed. And in still other systems
2312 (e.g., OS X, Solaris), maybe FD is closed, maybe not, and in a
2313 multithreaded program there can be no way to tell.
2315 So, in this case, pretend that the close succeeded. This works
2316 well on systems like GNU/Linux that close FD. Although it may
2317 leak a file descriptor on other systems, the leak is unlikely and
2318 it's better to leak than to close a random victim. */
2319 return close (fd
) == 0 || errno
== EINTR
? 0 : -1;
2323 /* Close FD, retrying if interrupted. If successful, return 0;
2324 otherwise, return -1 and set errno to a non-EINTR value. Consider
2325 an EINPROGRESS error to be successful, as that's merely a signal
2326 arriving. FD is always closed when this function returns, even
2329 Do not call this function if FD is nonnegative and might already be closed,
2330 as that might close an innocent victim opened by some other thread. */
2333 emacs_close (int fd
)
2337 int r
= posix_close (fd
, POSIX_CLOSE_RESTART
);
2340 if (!POSIX_CLOSE_RESTART
|| errno
!= EINTR
)
2342 eassert (errno
!= EBADF
|| fd
< 0);
2343 return errno
== EINPROGRESS
? 0 : r
;
2348 /* Maximum number of bytes to read or write in a single system call.
2349 This works around a serious bug in Linux kernels before 2.6.16; see
2350 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2351 It's likely to work around similar bugs in other operating systems, so do it
2352 on all platforms. Round INT_MAX down to a page size, with the conservative
2353 assumption that page sizes are at most 2**18 bytes (any kernel with a
2354 page size larger than that shouldn't have the bug). */
2355 #ifndef MAX_RW_COUNT
2356 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2359 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2360 Return the number of bytes read, which might be less than NBYTE.
2361 On error, set errno and return -1. */
2363 emacs_read (int fildes
, void *buf
, ptrdiff_t nbyte
)
2367 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2368 passes a size that large to emacs_read. */
2370 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2371 && (errno
== EINTR
))
2376 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2377 or if a partial write occurs. If interrupted, process pending
2378 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2379 errno if this is less than NBYTE. */
2381 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2382 bool process_signals
)
2384 ptrdiff_t bytes_written
= 0;
2388 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2394 /* I originally used `QUIT' but that might cause files to
2395 be truncated if you hit C-g in the middle of it. --Stef */
2396 if (process_signals
&& pending_signals
)
2397 process_pending_signals ();
2409 return bytes_written
;
2412 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2413 interrupted or if a partial write occurs. Return the number of
2414 bytes written, setting errno if this is less than NBYTE. */
2416 emacs_write (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2418 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2421 /* Like emacs_write, but also process pending signals if interrupted. */
2423 emacs_write_sig (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2425 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2428 /* Write a diagnostic to standard error that contains MESSAGE and a
2429 string derived from errno. Preserve errno. Do not buffer stderr.
2430 Do not process pending signals if interrupted. */
2432 emacs_perror (char const *message
)
2435 char const *error_string
= strerror (err
);
2436 char const *command
= (initial_argv
&& initial_argv
[0]
2437 ? initial_argv
[0] : "emacs");
2438 /* Write it out all at once, if it's short; this is less likely to
2439 be interleaved with other output. */
2441 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2442 command
, message
, error_string
);
2443 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2444 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2447 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2448 emacs_write (STDERR_FILENO
, ": ", 2);
2449 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2450 emacs_write (STDERR_FILENO
, ": ", 2);
2451 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2452 emacs_write (STDERR_FILENO
, "\n", 1);
2457 /* Return a struct timeval that is roughly equivalent to T.
2458 Use the least timeval not less than T.
2459 Return an extremal value if the result would overflow. */
2461 make_timeval (struct timespec t
)
2464 tv
.tv_sec
= t
.tv_sec
;
2465 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2467 if (t
.tv_nsec
% 1000 != 0)
2469 if (tv
.tv_usec
< 999999)
2471 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2481 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2482 ATIME and MTIME, respectively.
2483 FD must be either negative -- in which case it is ignored --
2484 or a file descriptor that is open on FILE.
2485 If FD is nonnegative, then FILE can be NULL. */
2487 set_file_times (int fd
, const char *filename
,
2488 struct timespec atime
, struct timespec mtime
)
2490 struct timespec timespec
[2];
2491 timespec
[0] = atime
;
2492 timespec
[1] = mtime
;
2493 return fdutimens (fd
, filename
, timespec
);
2496 /* Like strsignal, except async-signal-safe, and this function typically
2497 returns a string in the C locale rather than the current locale. */
2499 safe_strsignal (int code
)
2501 char const *signame
= 0;
2503 if (0 <= code
&& code
< sys_siglist_entries
)
2504 signame
= sys_siglist
[code
];
2506 signame
= "Unknown signal";
2512 /* For make-serial-process */
2514 serial_open (Lisp_Object port
)
2516 int fd
= emacs_open (SSDATA (port
), O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2518 report_file_error ("Opening serial port", port
);
2520 ioctl (fd
, TIOCEXCL
, (char *) 0);
2526 #if !defined (HAVE_CFMAKERAW)
2527 /* Workaround for targets which are missing cfmakeraw. */
2528 /* Pasted from man page. */
2530 cfmakeraw (struct termios
*termios_p
)
2532 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2533 termios_p
->c_oflag
&= ~OPOST
;
2534 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2535 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2536 termios_p
->c_cflag
|= CS8
;
2538 #endif /* !defined (HAVE_CFMAKERAW */
2540 #if !defined (HAVE_CFSETSPEED)
2541 /* Workaround for targets which are missing cfsetspeed. */
2543 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2545 return (cfsetispeed (termios_p
, vitesse
)
2546 + cfsetospeed (termios_p
, vitesse
));
2550 /* For serial-process-configure */
2552 serial_configure (struct Lisp_Process
*p
,
2553 Lisp_Object contact
)
2555 Lisp_Object childp2
= Qnil
;
2556 Lisp_Object tem
= Qnil
;
2557 struct termios attr
;
2559 char summary
[4] = "???"; /* This usually becomes "8N1". */
2561 childp2
= Fcopy_sequence (p
->childp
);
2563 /* Read port attributes and prepare default configuration. */
2564 err
= tcgetattr (p
->outfd
, &attr
);
2566 report_file_error ("Failed tcgetattr", Qnil
);
2568 #if defined (CLOCAL)
2569 attr
.c_cflag
|= CLOCAL
;
2572 attr
.c_cflag
|= CREAD
;
2575 /* Configure speed. */
2576 if (!NILP (Fplist_member (contact
, QCspeed
)))
2577 tem
= Fplist_get (contact
, QCspeed
);
2579 tem
= Fplist_get (p
->childp
, QCspeed
);
2581 err
= cfsetspeed (&attr
, XINT (tem
));
2583 report_file_error ("Failed cfsetspeed", tem
);
2584 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2586 /* Configure bytesize. */
2587 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2588 tem
= Fplist_get (contact
, QCbytesize
);
2590 tem
= Fplist_get (p
->childp
, QCbytesize
);
2592 tem
= make_number (8);
2594 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2595 error (":bytesize must be nil (8), 7, or 8");
2596 summary
[0] = XINT (tem
) + '0';
2597 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2598 attr
.c_cflag
&= ~CSIZE
;
2599 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2601 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2602 if (XINT (tem
) != 8)
2603 error ("Bytesize cannot be changed");
2605 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2607 /* Configure parity. */
2608 if (!NILP (Fplist_member (contact
, QCparity
)))
2609 tem
= Fplist_get (contact
, QCparity
);
2611 tem
= Fplist_get (p
->childp
, QCparity
);
2612 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2613 error (":parity must be nil (no parity), `even', or `odd'");
2614 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2615 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2616 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2621 else if (EQ (tem
, Qeven
))
2624 attr
.c_cflag
|= PARENB
;
2625 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2627 else if (EQ (tem
, Qodd
))
2630 attr
.c_cflag
|= (PARENB
| PARODD
);
2631 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2634 /* Don't error on no parity, which should be set by cfmakeraw. */
2636 error ("Parity cannot be configured");
2638 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2640 /* Configure stopbits. */
2641 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2642 tem
= Fplist_get (contact
, QCstopbits
);
2644 tem
= Fplist_get (p
->childp
, QCstopbits
);
2646 tem
= make_number (1);
2648 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2649 error (":stopbits must be nil (1 stopbit), 1, or 2");
2650 summary
[2] = XINT (tem
) + '0';
2651 #if defined (CSTOPB)
2652 attr
.c_cflag
&= ~CSTOPB
;
2653 if (XINT (tem
) == 2)
2654 attr
.c_cflag
|= CSTOPB
;
2656 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2657 if (XINT (tem
) != 1)
2658 error ("Stopbits cannot be configured");
2660 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2662 /* Configure flowcontrol. */
2663 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2664 tem
= Fplist_get (contact
, QCflowcontrol
);
2666 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2667 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2668 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2669 #if defined (CRTSCTS)
2670 attr
.c_cflag
&= ~CRTSCTS
;
2672 #if defined (CNEW_RTSCTS)
2673 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2675 #if defined (IXON) && defined (IXOFF)
2676 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2680 /* Already configured. */
2682 else if (EQ (tem
, Qhw
))
2684 #if defined (CRTSCTS)
2685 attr
.c_cflag
|= CRTSCTS
;
2686 #elif defined (CNEW_RTSCTS)
2687 attr
.c_cflag
|= CNEW_RTSCTS
;
2689 error ("Hardware flowcontrol (RTS/CTS) not supported");
2692 else if (EQ (tem
, Qsw
))
2694 #if defined (IXON) && defined (IXOFF)
2695 attr
.c_iflag
|= (IXON
| IXOFF
);
2697 error ("Software flowcontrol (XON/XOFF) not supported");
2700 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2702 /* Activate configuration. */
2703 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2705 report_file_error ("Failed tcsetattr", Qnil
);
2707 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2708 pset_childp (p
, childp2
);
2710 #endif /* not DOS_NT */
2712 /* System depended enumeration of and access to system processes a-la ps(1). */
2716 /* Process enumeration and access via /proc. */
2719 list_system_processes (void)
2721 Lisp_Object procdir
, match
, proclist
, next
;
2724 /* For every process on the system, there's a directory in the
2725 "/proc" pseudo-directory whose name is the numeric ID of that
2727 procdir
= build_string ("/proc");
2728 match
= build_string ("[0-9]+");
2729 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2731 /* `proclist' gives process IDs as strings. Destructively convert
2732 each string into a number. */
2733 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2736 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2739 /* directory_files_internal returns the files in reverse order; undo
2741 proclist
= Fnreverse (proclist
);
2745 #elif defined DARWIN_OS || defined __FreeBSD__
2748 list_system_processes (void)
2751 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2753 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2756 struct kinfo_proc
*procs
;
2759 Lisp_Object proclist
= Qnil
;
2761 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2764 procs
= xmalloc (len
);
2765 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2771 len
/= sizeof (struct kinfo_proc
);
2772 for (i
= 0; i
< len
; i
++)
2775 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2777 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2786 /* The WINDOWSNT implementation is in w32.c.
2787 The MSDOS implementation is in dosfns.c. */
2788 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2791 list_system_processes (void)
2796 #endif /* !defined (WINDOWSNT) */
2798 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2799 static struct timespec
2800 time_from_jiffies (unsigned long long tval
, long hz
)
2802 unsigned long long s
= tval
/ hz
;
2803 unsigned long long frac
= tval
% hz
;
2806 if (TYPE_MAXIMUM (time_t) < s
)
2808 if (LONG_MAX
- 1 <= ULLONG_MAX
/ TIMESPEC_RESOLUTION
2809 || frac
<= ULLONG_MAX
/ TIMESPEC_RESOLUTION
)
2810 ns
= frac
* TIMESPEC_RESOLUTION
/ hz
;
2813 /* This is reachable only in the unlikely case that HZ * HZ
2814 exceeds ULLONG_MAX. It calculates an approximation that is
2815 guaranteed to be in range. */
2816 long hz_per_ns
= (hz
/ TIMESPEC_RESOLUTION
2817 + (hz
% TIMESPEC_RESOLUTION
!= 0));
2818 ns
= frac
/ hz_per_ns
;
2821 return make_timespec (s
, ns
);
2825 ltime_from_jiffies (unsigned long long tval
, long hz
)
2827 struct timespec t
= time_from_jiffies (tval
, hz
);
2828 return make_lisp_time (t
);
2831 static struct timespec
2835 struct timespec up
= make_timespec (0, 0);
2838 fup
= emacs_fopen ("/proc/uptime", "r");
2842 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2843 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2845 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2846 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2847 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2850 if (TYPE_MAXIMUM (time_t) < upsec
)
2852 upsec
= TYPE_MAXIMUM (time_t);
2853 upfrac
= TIMESPEC_RESOLUTION
- 1;
2857 int upfraclen
= upfrac_end
- upfrac_start
;
2858 for (; upfraclen
< LOG10_TIMESPEC_RESOLUTION
; upfraclen
++)
2860 for (; LOG10_TIMESPEC_RESOLUTION
< upfraclen
; upfraclen
--)
2862 upfrac
= min (upfrac
, TIMESPEC_RESOLUTION
- 1);
2864 up
= make_timespec (upsec
, upfrac
);
2873 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2874 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2877 procfs_ttyname (int rdev
)
2880 char name
[PATH_MAX
];
2883 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2889 unsigned long minor_beg
, minor_end
;
2890 char minor
[25]; /* 2 32-bit numbers + dash */
2893 for (; !feof (fdev
) && !ferror (fdev
); name
[0] = 0)
2895 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2896 && major
== MAJOR (rdev
))
2898 minor_beg
= strtoul (minor
, &endp
, 0);
2900 minor_end
= minor_beg
;
2901 else if (*endp
== '-')
2902 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2906 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2908 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2916 return build_string (name
);
2920 procfs_get_total_memory (void)
2923 uintmax_t retval
= 2 * 1024 * 1024; /* default: 2 GiB */
2927 fmem
= emacs_fopen ("/proc/meminfo", "r");
2931 uintmax_t entry_value
;
2935 switch (fscanf (fmem
, "MemTotal: %"SCNuMAX
, &entry_value
))
2938 retval
= entry_value
;
2943 while ((c
= getc (fmem
)) != EOF
&& c
!= '\n')
2961 system_process_attributes (Lisp_Object pid
)
2963 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
2967 long clocks_per_sec
;
2969 char procbuf
[1025], *p
, *q
;
2972 static char const default_cmd
[] = "???";
2973 const char *cmd
= default_cmd
;
2974 int cmdsize
= sizeof default_cmd
- 1;
2975 char *cmdline
= NULL
;
2976 ptrdiff_t cmdline_size
;
2979 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
2982 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
2983 long priority
, niceness
, rss
;
2984 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
2985 struct timespec tnow
, tstart
, tboot
, telapsed
, us_time
;
2987 Lisp_Object attrs
= Qnil
;
2988 Lisp_Object cmd_str
, decoded_cmd
;
2991 CHECK_NUMBER_OR_FLOAT (pid
);
2992 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
2993 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
2994 if (stat (procfn
, &st
) < 0)
2999 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3001 pw
= getpwuid (uid
);
3004 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3007 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3009 gr
= getgrgid (gid
);
3012 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3014 count
= SPECPDL_INDEX ();
3015 strcpy (fn
, procfn
);
3016 procfn_end
= fn
+ strlen (fn
);
3017 strcpy (procfn_end
, "/stat");
3018 fd
= emacs_open (fn
, O_RDONLY
, 0);
3023 record_unwind_protect_int (close_file_unwind
, fd
);
3024 nread
= emacs_read (fd
, procbuf
, sizeof procbuf
- 1);
3028 procbuf
[nread
] = '\0';
3031 p
= strchr (p
, '(');
3034 q
= strrchr (p
+ 1, ')');
3044 /* Command name is encoded in locale-coding-system; decode it. */
3045 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
3046 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3047 Vlocale_coding_system
, 0);
3048 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3050 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
3051 utime stime cutime cstime priority nice thcount . start vsize rss */
3053 && (sscanf (q
+ 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
3054 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
3055 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
3056 &minflt
, &cminflt
, &majflt
, &cmajflt
,
3057 &u_time
, &s_time
, &cutime
, &cstime
,
3058 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
)
3063 state_str
[1] = '\0';
3064 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3065 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid
)), attrs
);
3066 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp
)), attrs
);
3067 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess
)), attrs
);
3068 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
3069 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid
)), attrs
);
3070 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
3071 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
3072 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)),
3074 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)),
3076 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
3077 if (clocks_per_sec
< 0)
3078 clocks_per_sec
= 100;
3079 attrs
= Fcons (Fcons (Qutime
,
3080 ltime_from_jiffies (u_time
, clocks_per_sec
)),
3082 attrs
= Fcons (Fcons (Qstime
,
3083 ltime_from_jiffies (s_time
, clocks_per_sec
)),
3085 attrs
= Fcons (Fcons (Qtime
,
3086 ltime_from_jiffies (s_time
+ u_time
,
3089 attrs
= Fcons (Fcons (Qcutime
,
3090 ltime_from_jiffies (cutime
, clocks_per_sec
)),
3092 attrs
= Fcons (Fcons (Qcstime
,
3093 ltime_from_jiffies (cstime
, clocks_per_sec
)),
3095 attrs
= Fcons (Fcons (Qctime
,
3096 ltime_from_jiffies (cstime
+ cutime
,
3099 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
3100 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
3101 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount
)),
3103 tnow
= current_timespec ();
3104 telapsed
= get_up_time ();
3105 tboot
= timespec_sub (tnow
, telapsed
);
3106 tstart
= time_from_jiffies (start
, clocks_per_sec
);
3107 tstart
= timespec_add (tboot
, tstart
);
3108 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
3109 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/ 1024)),
3111 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4 * rss
)), attrs
);
3112 telapsed
= timespec_sub (tnow
, tstart
);
3113 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
3114 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
3115 pcpu
= timespectod (us_time
) / timespectod (telapsed
);
3118 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
3119 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
3122 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
3125 unbind_to (count
, Qnil
);
3128 strcpy (procfn_end
, "/cmdline");
3129 fd
= emacs_open (fn
, O_RDONLY
, 0);
3132 ptrdiff_t readsize
, nread_incr
;
3133 record_unwind_protect_int (close_file_unwind
, fd
);
3134 record_unwind_protect_nothing ();
3135 nread
= cmdline_size
= 0;
3139 cmdline
= xpalloc (cmdline
, &cmdline_size
, 2, STRING_BYTES_BOUND
, 1);
3140 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3142 /* Leave room even if every byte needs escaping below. */
3143 readsize
= (cmdline_size
>> 1) - nread
;
3145 nread_incr
= emacs_read (fd
, cmdline
+ nread
, readsize
);
3146 nread
+= max (0, nread_incr
);
3148 while (nread_incr
== readsize
);
3152 /* We don't want trailing null characters. */
3153 for (p
= cmdline
+ nread
; cmdline
< p
&& !p
[-1]; p
--)
3156 /* Escape-quote whitespace and backslashes. */
3157 q
= cmdline
+ cmdline_size
;
3162 if (c_isspace (c
) || c
== '\\')
3166 nread
= cmdline
+ cmdline_size
- q
;
3171 nread
= cmdsize
+ 2;
3172 cmdline_size
= nread
+ 1;
3173 q
= cmdline
= xrealloc (cmdline
, cmdline_size
);
3174 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3175 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3177 /* Command line is encoded in locale-coding-system; decode it. */
3178 cmd_str
= make_unibyte_string (q
, nread
);
3179 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3180 Vlocale_coding_system
, 0);
3181 unbind_to (count
, Qnil
);
3182 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3188 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3190 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3191 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3192 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3193 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3194 #undef _FILE_OFFSET_BITS
3196 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3201 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3202 #define _FILE_OFFSET_BITS 64
3203 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3205 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3208 system_process_attributes (Lisp_Object pid
)
3210 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3215 struct psinfo pinfo
;
3221 Lisp_Object attrs
= Qnil
;
3222 Lisp_Object decoded_cmd
;
3225 CHECK_NUMBER_OR_FLOAT (pid
);
3226 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3227 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3228 if (stat (procfn
, &st
) < 0)
3233 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3235 pw
= getpwuid (uid
);
3238 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3241 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3243 gr
= getgrgid (gid
);
3246 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3248 count
= SPECPDL_INDEX ();
3249 strcpy (fn
, procfn
);
3250 procfn_end
= fn
+ strlen (fn
);
3251 strcpy (procfn_end
, "/psinfo");
3252 fd
= emacs_open (fn
, O_RDONLY
, 0);
3257 record_unwind_protect (close_file_unwind
, fd
);
3258 nread
= emacs_read (fd
, &pinfo
, sizeof pinfo
);
3261 if (nread
== sizeof pinfo
)
3263 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3264 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3265 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3269 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3270 state_str
[1] = '\0';
3271 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3274 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3275 need to get a string from it. */
3277 /* FIXME: missing: Qtpgid */
3289 Are they available? */
3291 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3292 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3293 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3294 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3295 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)),
3298 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3299 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)),
3301 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)),
3304 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3305 range 0 .. 2**15, representing 0.0 .. 1.0. */
3306 attrs
= Fcons (Fcons (Qpcpu
,
3307 make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)),
3309 attrs
= Fcons (Fcons (Qpmem
,
3310 make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)),
3313 decoded_cmd
= (code_convert_string_norecord
3314 (build_unibyte_string (pinfo
.pr_fname
),
3315 Vlocale_coding_system
, 0));
3316 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3317 decoded_cmd
= (code_convert_string_norecord
3318 (build_unibyte_string (pinfo
.pr_psargs
),
3319 Vlocale_coding_system
, 0));
3320 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3322 unbind_to (count
, Qnil
);
3326 #elif defined __FreeBSD__
3328 static struct timespec
3329 timeval_to_timespec (struct timeval t
)
3331 return make_timespec (t
.tv_sec
, t
.tv_usec
* 1000);
3335 make_lisp_timeval (struct timeval t
)
3337 return make_lisp_time (timeval_to_timespec (t
));
3341 system_process_attributes (Lisp_Object pid
)
3344 int pagesize
= getpagesize ();
3345 unsigned long npages
;
3351 char args
[MAXPATHLEN
];
3352 struct timespec t
, now
;
3354 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3355 struct kinfo_proc proc
;
3356 size_t proclen
= sizeof proc
;
3358 Lisp_Object attrs
= Qnil
;
3359 Lisp_Object decoded_comm
;
3361 CHECK_NUMBER_OR_FLOAT (pid
);
3362 CONS_TO_INTEGER (pid
, int, proc_id
);
3365 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3368 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3371 pw
= getpwuid (proc
.ki_uid
);
3374 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3376 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3379 gr
= getgrgid (proc
.ki_svgid
);
3382 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3384 decoded_comm
= (code_convert_string_norecord
3385 (build_unibyte_string (proc
.ki_comm
),
3386 Vlocale_coding_system
, 0));
3388 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3390 char state
[2] = {'\0', '\0'};
3391 switch (proc
.ki_stat
)
3413 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3416 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3417 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3418 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3421 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3424 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3426 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3427 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3428 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3429 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3430 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3432 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3434 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3436 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage
.ru_utime
),
3437 timeval_to_timespec (proc
.ki_rusage
.ru_stime
));
3438 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3440 attrs
= Fcons (Fcons (Qcutime
,
3441 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3443 attrs
= Fcons (Fcons (Qcstime
,
3444 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3446 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage_ch
.ru_utime
),
3447 timeval_to_timespec (proc
.ki_rusage_ch
.ru_stime
));
3448 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3450 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3452 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3453 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3454 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3455 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3456 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3459 now
= current_timespec ();
3460 t
= timespec_sub (now
, timeval_to_timespec (proc
.ki_start
));
3461 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3463 len
= sizeof fscale
;
3464 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3469 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3471 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3472 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3473 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3477 len
= sizeof npages
;
3478 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3480 double pmem
= (proc
.ki_flag
& P_INMEM
3481 ? 100.0 * proc
.ki_rssize
/ npages
3483 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3486 mib
[2] = KERN_PROC_ARGS
;
3488 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3491 for (i
= 0; i
< len
; i
++)
3493 if (! args
[i
] && i
< len
- 1)
3498 (code_convert_string_norecord
3499 (build_unibyte_string (args
),
3500 Vlocale_coding_system
, 0));
3502 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3508 /* The WINDOWSNT implementation is in w32.c.
3509 The MSDOS implementation is in dosfns.c. */
3510 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3513 system_process_attributes (Lisp_Object pid
)
3518 #endif /* !defined (WINDOWSNT) */
3520 /* Wide character string collation. */
3522 #ifdef __STDC_ISO_10646__
3524 # include <wctype.h>
3526 # if defined HAVE_NEWLOCALE || defined HAVE_SETLOCALE
3527 # include <locale.h>
3530 # define LC_COLLATE 0
3532 # ifndef LC_COLLATE_MASK
3533 # define LC_COLLATE_MASK 0
3538 # ifndef LC_CTYPE_MASK
3539 # define LC_CTYPE_MASK 0
3542 # ifndef HAVE_NEWLOCALE
3548 # define freelocale emacs_freelocale
3549 # define locale_t emacs_locale_t
3550 # define newlocale emacs_newlocale
3551 # define wcscoll_l emacs_wcscoll_l
3552 # define towlower_l emacs_towlower_l
3554 typedef char const *locale_t
;
3557 newlocale (int category_mask
, char const *locale
, locale_t loc
)
3563 freelocale (locale_t loc
)
3568 emacs_setlocale (int category
, char const *locale
)
3570 # ifdef HAVE_SETLOCALE
3572 char *loc
= setlocale (category
, locale
);
3583 wcscoll_l (wchar_t const *a
, wchar_t const *b
, locale_t loc
)
3586 char *oldloc
= emacs_setlocale (LC_COLLATE
, NULL
);
3594 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3595 strcpy (oldcopy
, oldloc
);
3596 if (! emacs_setlocale (LC_COLLATE
, loc
))
3601 result
= wcscoll (a
, b
);
3603 if (! emacs_setlocale (LC_COLLATE
, oldcopy
))
3614 towlower_l (wint_t wc
, locale_t loc
)
3617 char *oldloc
= emacs_setlocale (LC_CTYPE
, NULL
);
3622 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3623 strcpy (oldcopy
, oldloc
);
3624 if (emacs_setlocale (LC_CTYPE
, loc
))
3626 result
= towlower (wc
);
3627 emacs_setlocale (LC_COLLATE
, oldcopy
);
3637 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3638 Lisp_Object locale
, Lisp_Object ignore_case
)
3641 ptrdiff_t len
, i
, i_byte
;
3646 /* Convert byte stream to code points. */
3647 len
= SCHARS (s1
); i
= i_byte
= 0;
3648 SAFE_NALLOCA (p1
, 1, len
+ 1);
3650 FETCH_STRING_CHAR_ADVANCE (*(p1
+i
-1), s1
, i
, i_byte
);
3653 len
= SCHARS (s2
); i
= i_byte
= 0;
3654 SAFE_NALLOCA (p2
, 1, len
+ 1);
3656 FETCH_STRING_CHAR_ADVANCE (*(p2
+i
-1), s2
, i
, i_byte
);
3659 if (STRINGP (locale
))
3661 locale_t loc
= newlocale (LC_COLLATE_MASK
| LC_CTYPE_MASK
,
3662 SSDATA (locale
), 0);
3664 error ("Invalid locale %s: %s", SSDATA (locale
), strerror (errno
));
3666 if (! NILP (ignore_case
))
3667 for (int i
= 1; i
< 3; i
++)
3669 wchar_t *p
= (i
== 1) ? p1
: p2
;
3671 *p
= towlower_l (*p
, loc
);
3675 res
= wcscoll_l (p1
, p2
, loc
);
3681 if (! NILP (ignore_case
))
3682 for (int i
= 1; i
< 3; i
++)
3684 wchar_t *p
= (i
== 1) ? p1
: p2
;
3690 res
= wcscoll (p1
, p2
);
3693 # ifndef HAVE_NEWLOCALE
3695 error ("Invalid locale or string for collation: %s", strerror (err
));
3698 error ("Invalid string for collation: %s", strerror (err
));
3704 #endif /* __STDC_ISO_10646__ */
3708 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3709 Lisp_Object locale
, Lisp_Object ignore_case
)
3712 char *loc
= STRINGP (locale
) ? SSDATA (locale
) : NULL
;
3713 int res
, err
= errno
;
3716 res
= w32_compare_strings (SDATA (s1
), SDATA (s2
), loc
, !NILP (ignore_case
));
3718 error ("Invalid string for collation: %s", strerror (errno
));
3723 #endif /* WINDOWSNT */