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 #ifdef HAVE_SYS_RESOURCE_H
83 #include <sys/resource.h>
85 #include <sys/param.h>
92 #ifdef HAVE_SYS_UTSNAME_H
93 #include <sys/utsname.h>
95 #endif /* HAVE_SYS_UTSNAME_H */
100 #include "termhooks.h"
101 #include "termchar.h"
102 #include "termopts.h"
103 #include "dispextern.h"
105 #include "cm.h" /* for reset_sys_modes */
109 /* In process.h which conflicts with the local copy. */
111 int _cdecl
_spawnlp (int, const char *, const char *, ...);
112 int _cdecl
_getpid (void);
113 /* The following is needed for O_CLOEXEC, F_SETFD, FD_CLOEXEC, and
114 several prototypes of functions called below. */
115 #include <sys/socket.h>
118 #include "syssignal.h"
121 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
123 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
126 /* Declare here, including term.h is problematic on some systems. */
127 extern void tputs (const char *, int, int (*)(int));
129 static const int baud_convert
[] =
131 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
132 1800, 2400, 4800, 9600, 19200, 38400
135 #if !defined HAVE_GET_CURRENT_DIR_NAME || defined BROKEN_GET_CURRENT_DIR_NAME \
136 || (defined HYBRID_GET_CURRENT_DIR_NAME)
137 /* Return the current working directory. Returns NULL on errors.
138 Any other returned value must be freed with free. This is used
139 only when get_current_dir_name is not defined on the system. */
141 get_current_dir_name (void)
144 char *pwd
= getenv ("PWD");
145 struct stat dotstat
, pwdstat
;
146 /* If PWD is accurate, use it instead of calling getcwd. PWD is
147 sometimes a nicer name, and using it may avoid a fatal error if a
148 parent directory is searchable but not readable. */
150 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
151 && stat (pwd
, &pwdstat
) == 0
152 && stat (".", &dotstat
) == 0
153 && dotstat
.st_ino
== pwdstat
.st_ino
154 && dotstat
.st_dev
== pwdstat
.st_dev
156 && strlen (pwd
) < MAXPATHLEN
160 buf
= malloc (strlen (pwd
) + 1);
167 size_t buf_size
= 1024;
168 buf
= malloc (buf_size
);
173 if (getcwd (buf
, buf_size
) == buf
)
177 int tmp_errno
= errno
;
183 buf
= realloc (buf
, buf_size
);
193 /* Discard pending input on all input descriptors. */
196 discard_tty_input (void)
199 struct emacs_tty buf
;
204 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
205 while (dos_keyread () != -1)
207 #else /* not MSDOS */
209 struct tty_display_info
*tty
;
210 for (tty
= tty_list
; tty
; tty
= tty
->next
)
212 if (tty
->input
) /* Is the device suspended? */
214 emacs_get_tty (fileno (tty
->input
), &buf
);
215 emacs_set_tty (fileno (tty
->input
), &buf
, 0);
219 #endif /* not MSDOS */
220 #endif /* not WINDOWSNT */
226 /* Arrange for character C to be read as the next input from
228 XXX What if we have multiple ttys?
234 if (! (FRAMEP (selected_frame
)
235 && FRAME_LIVE_P (XFRAME (selected_frame
))
236 && FRAME_TERMCAP_P (XFRAME (selected_frame
))))
239 /* Should perhaps error if in batch mode */
241 ioctl (fileno (CURTTY()->input
), TIOCSTI
, &c
);
242 #else /* no TIOCSTI */
243 error ("Cannot stuff terminal input characters in this version of Unix");
244 #endif /* no TIOCSTI */
250 init_baud_rate (int fd
)
260 #else /* not DOS_NT */
265 emacs_ospeed
= cfgetospeed (&sg
);
266 #endif /* not DOS_NT */
269 baud_rate
= (emacs_ospeed
< ARRAYELTS (baud_convert
)
270 ? baud_convert
[emacs_ospeed
] : 9600);
279 /* Wait for the subprocess with process id CHILD to terminate or change status.
280 CHILD must be a child process that has not been reaped.
281 If STATUS is non-null, store the waitpid-style exit status into *STATUS
282 and tell wait_reading_process_output that it needs to look around.
283 Use waitpid-style OPTIONS when waiting.
284 If INTERRUPTIBLE, this function is interruptible by a signal.
286 Return CHILD if successful, 0 if no status is available;
287 the latter is possible only when options & NOHANG. */
289 get_child_status (pid_t child
, int *status
, int options
, bool interruptible
)
293 /* Invoke waitpid only with a known process ID; do not invoke
294 waitpid with a nonpositive argument. Otherwise, Emacs might
295 reap an unwanted process by mistake. For example, invoking
296 waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
297 so that another thread running glib won't find them. */
300 while ((pid
= waitpid (child
, status
, options
)) < 0)
302 /* Check that CHILD is a child process that has not been reaped,
303 and that STATUS and OPTIONS are valid. Otherwise abort,
304 as continuing after this internal error could cause Emacs to
305 become confused and kill innocent-victim processes. */
309 /* Note: the MS-Windows emulation of waitpid calls QUIT
315 /* If successful and status is requested, tell wait_reading_process_output
316 that it needs to wake up and look around. */
317 if (pid
&& status
&& input_available_clear_time
)
318 *input_available_clear_time
= make_timespec (0, 0);
323 /* Wait for the subprocess with process id CHILD to terminate.
324 CHILD must be a child process that has not been reaped.
325 If STATUS is non-null, store the waitpid-style exit status into *STATUS
326 and tell wait_reading_process_output that it needs to look around.
327 If INTERRUPTIBLE, this function is interruptible by a signal. */
329 wait_for_termination (pid_t child
, int *status
, bool interruptible
)
331 get_child_status (child
, status
, 0, interruptible
);
334 /* Report whether the subprocess with process id CHILD has changed status.
335 Termination counts as a change of status.
336 CHILD must be a child process that has not been reaped.
337 If STATUS is non-null, store the waitpid-style exit status into *STATUS
338 and tell wait_reading_process_output that it needs to look around.
339 Use waitpid-style OPTIONS to check status, but do not wait.
341 Return CHILD if successful, 0 if no status is available because
342 the process's state has not changed. */
344 child_status_changed (pid_t child
, int *status
, int options
)
346 return get_child_status (child
, status
, WNOHANG
| options
, 0);
350 /* Set up the terminal at the other end of a pseudo-terminal that
351 we will be controlling an inferior through.
352 It should not echo or do line-editing, since that is done
353 in Emacs. No padding needed for insertion into an Emacs buffer. */
356 child_setup_tty (int out
)
361 emacs_get_tty (out
, &s
);
362 s
.main
.c_oflag
|= OPOST
; /* Enable output postprocessing */
363 s
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL on output */
365 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
366 Some versions of GNU Hurd do not have FFDLY? */
368 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
|FFDLY
);
369 /* No output delays */
371 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
);
372 /* No output delays */
375 s
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
376 s
.main
.c_lflag
|= ISIG
; /* Enable signals */
378 s
.main
.c_iflag
&= ~IUCLC
; /* Disable downcasing on input. */
381 s
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
384 s
.main
.c_oflag
&= ~OLCUC
; /* Disable upcasing on output. */
386 s
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
387 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CSIZE
) | CS8
; /* Don't strip 8th bit */
388 s
.main
.c_cc
[VERASE
] = CDISABLE
; /* disable erase processing */
389 s
.main
.c_cc
[VKILL
] = CDISABLE
; /* disable kill processing */
392 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
395 #ifdef SIGNALS_VIA_CHARACTERS
396 /* the QUIT and INTR character are used in process_send_signal
397 so set them here to something useful. */
398 if (s
.main
.c_cc
[VQUIT
] == CDISABLE
)
399 s
.main
.c_cc
[VQUIT
] = '\\'&037; /* Control-\ */
400 if (s
.main
.c_cc
[VINTR
] == CDISABLE
)
401 s
.main
.c_cc
[VINTR
] = 'C'&037; /* Control-C */
402 #endif /* not SIGNALS_VIA_CHARACTERS */
405 /* Also, PTY overloads NUL and BREAK.
406 don't ignore break, but don't signal either, so it looks like NUL. */
407 s
.main
.c_iflag
&= ~IGNBRK
;
408 s
.main
.c_iflag
&= ~BRKINT
;
409 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
410 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
411 would force it to 0377. That looks like duplicated code. */
412 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
415 /* We originally enabled ICANON (and set VEOF to 04), and then had
416 process.c send additional EOF chars to flush the output when faced
417 with long lines, but this leads to weird effects when the
418 subprocess has disabled ICANON and ends up seeing those spurious
419 extra EOFs. So we don't send EOFs any more in
420 process.c:send_process. First we tried to disable ICANON by
421 default, so if a subsprocess sets up ICANON, it's his problem (or
422 the Elisp package that talks to it) to deal with lines that are
423 too long. But this disables some features, such as the ability
424 to send EOF signals. So we re-enabled ICANON but there is no
425 more "send eof to flush" going on (which is wrong and unportable
426 in itself). The correct way to handle too much output is to
427 buffer what could not be written and then write it again when
428 select returns ok for writing. This has it own set of
429 problems. Write is now asynchronous, is that a problem? How much
430 do we buffer, and what do we do when that limit is reached? */
432 s
.main
.c_lflag
|= ICANON
; /* Enable line editing and eof processing */
433 s
.main
.c_cc
[VEOF
] = 'D'&037; /* Control-D */
434 #if 0 /* These settings only apply to non-ICANON mode. */
435 s
.main
.c_cc
[VMIN
] = 1;
436 s
.main
.c_cc
[VTIME
] = 0;
439 emacs_set_tty (out
, &s
, 0);
440 #endif /* not WINDOWSNT */
442 #endif /* not MSDOS */
445 /* Record a signal code and the action for it. */
449 struct sigaction action
;
452 static void save_signal_handlers (struct save_signal
*);
453 static void restore_signal_handlers (struct save_signal
*);
455 /* Suspend the Emacs process; give terminal to its superior. */
463 /* On a system where suspending is not implemented,
464 instead fork a subshell and let it talk directly to the terminal
471 /* Fork a subshell. */
476 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
479 char oldwd
[MAXPATHLEN
+1]; /* Fixed length is safe on MSDOS. */
481 char oldwd
[MAX_UTF8_PATH
];
486 struct save_signal saved_handlers
[5];
487 char *str
= SSDATA (encode_current_directory ());
493 char *volatile str_volatile
= str
;
500 error ("Can't spawn subshell");
502 saved_handlers
[0].code
= SIGINT
;
503 saved_handlers
[1].code
= SIGQUIT
;
504 saved_handlers
[2].code
= SIGTERM
;
506 saved_handlers
[3].code
= SIGIO
;
507 saved_handlers
[4].code
= 0;
509 saved_handlers
[3].code
= 0;
513 save_signal_handlers (saved_handlers
);
520 #ifdef DOS_NT /* MW, Aug 1993 */
521 getcwd (oldwd
, sizeof oldwd
);
523 sh
= egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
526 sh
= egetenv ("SHELL");
530 /* Use our buffer's default directory for the subshell. */
531 if (chdir (str
) != 0)
535 _exit (EXIT_CANCELED
);
539 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
541 char *epwd
= getenv ("PWD");
542 char old_pwd
[MAXPATHLEN
+1+4];
544 /* If PWD is set, pass it with corrected value. */
547 strcpy (old_pwd
, epwd
);
548 setenv ("PWD", str
, 1);
551 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
553 putenv (old_pwd
); /* restore previous value */
555 #else /* not MSDOS */
557 /* Waits for process completion */
558 pid
= _spawnlp (_P_WAIT
, sh
, sh
, NULL
);
559 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
561 write (1, "Can't execute subshell", 22);
562 #else /* not WINDOWSNT */
563 execlp (sh
, sh
, (char *) 0);
565 _exit (errno
== ENOENT
? EXIT_ENOENT
: EXIT_CANNOT_INVOKE
);
566 #endif /* not WINDOWSNT */
567 #endif /* not MSDOS */
570 /* Do this now if we did not do it before. */
572 save_signal_handlers (saved_handlers
);
576 wait_for_termination (pid
, &status
, 0);
578 restore_signal_handlers (saved_handlers
);
582 save_signal_handlers (struct save_signal
*saved_handlers
)
584 while (saved_handlers
->code
)
586 struct sigaction action
;
587 emacs_sigaction_init (&action
, SIG_IGN
);
588 sigaction (saved_handlers
->code
, &action
, &saved_handlers
->action
);
594 restore_signal_handlers (struct save_signal
*saved_handlers
)
596 while (saved_handlers
->code
)
598 sigaction (saved_handlers
->code
, &saved_handlers
->action
, 0);
604 static int old_fcntl_flags
[FD_SETSIZE
];
611 old_fcntl_flags
[fd
] = fcntl (fd
, F_GETFL
, 0) & ~FASYNC
;
612 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
] | FASYNC
);
613 interrupts_deferred
= 0;
622 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
]);
636 sigemptyset (&unblocked
);
638 sigaddset (&unblocked
, SIGWINCH
);
640 sigaddset (&unblocked
, SIGIO
);
641 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
643 interrupts_deferred
= 0;
648 unrequest_sigio (void)
656 sigemptyset (&blocked
);
658 sigaddset (&blocked
, SIGWINCH
);
660 sigaddset (&blocked
, SIGIO
);
661 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
662 interrupts_deferred
= 1;
670 signal (SIGIO
, SIG_IGN
);
678 block_child_signal (sigset_t
*oldset
)
681 sigemptyset (&blocked
);
682 sigaddset (&blocked
, SIGCHLD
);
683 sigaddset (&blocked
, SIGINT
);
684 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
687 /* Unblock SIGCHLD. */
690 unblock_child_signal (sigset_t
const *oldset
)
692 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
697 /* Saving and restoring the process group of Emacs's terminal. */
699 /* The process group of which Emacs was a member when it initially
702 If Emacs was in its own process group (i.e. inherited_pgroup ==
703 getpid ()), then we know we're running under a shell with job
704 control (Emacs would never be run as part of a pipeline).
707 If Emacs was not in its own process group, then we know we're
708 running under a shell (or a caller) that doesn't know how to
709 separate itself from Emacs (like sh). Emacs must be in its own
710 process group in order to receive SIGIO correctly. In this
711 situation, we put ourselves in our own pgroup, forcibly set the
712 tty's pgroup to our pgroup, and make sure to restore and reinstate
713 the tty's pgroup just like any other terminal setting. If
714 inherited_group was not the tty's pgroup, then we'll get a
715 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
716 it goes foreground in the future, which is what should happen. */
718 static pid_t inherited_pgroup
;
721 init_foreground_group (void)
723 pid_t pgrp
= getpgrp ();
724 inherited_pgroup
= getpid () == pgrp
? 0 : pgrp
;
727 /* Block and unblock SIGTTOU. */
730 block_tty_out_signal (sigset_t
*oldset
)
734 sigemptyset (&blocked
);
735 sigaddset (&blocked
, SIGTTOU
);
736 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
741 unblock_tty_out_signal (sigset_t
const *oldset
)
744 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
748 /* Safely set a controlling terminal FD's process group to PGID.
749 If we are not in the foreground already, POSIX requires tcsetpgrp
750 to deliver a SIGTTOU signal, which would stop us. This is an
751 annoyance, so temporarily ignore the signal.
753 In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
754 skip all this unless SIGTTOU is defined. */
756 tcsetpgrp_without_stopping (int fd
, pid_t pgid
)
761 block_tty_out_signal (&oldset
);
762 tcsetpgrp (fd
, pgid
);
763 unblock_tty_out_signal (&oldset
);
768 /* Split off the foreground process group to Emacs alone. When we are
769 in the foreground, but not started in our own process group,
770 redirect the tty device handle FD to point to our own process
771 group. FD must be the file descriptor of the controlling tty. */
773 narrow_foreground_group (int fd
)
775 if (inherited_pgroup
&& setpgid (0, 0) == 0)
776 tcsetpgrp_without_stopping (fd
, getpid ());
779 /* Set the tty to our original foreground group. */
781 widen_foreground_group (int fd
)
783 if (inherited_pgroup
&& setpgid (0, inherited_pgroup
) == 0)
784 tcsetpgrp_without_stopping (fd
, inherited_pgroup
);
787 /* Getting and setting emacs_tty structures. */
789 /* Set *TC to the parameters associated with the terminal FD,
790 or clear it if the parameters are not available.
791 Return 0 on success, -1 on failure. */
793 emacs_get_tty (int fd
, struct emacs_tty
*settings
)
795 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
796 memset (&settings
->main
, 0, sizeof (settings
->main
));
799 HANDLE h
= (HANDLE
)_get_osfhandle (fd
);
802 if (h
&& h
!= INVALID_HANDLE_VALUE
&& GetConsoleMode (h
, &console_mode
))
804 settings
->main
= console_mode
;
807 #endif /* WINDOWSNT */
810 /* We have those nifty POSIX tcmumbleattr functions. */
811 return tcgetattr (fd
, &settings
->main
);
816 /* Set the parameters of the tty on FD according to the contents of
817 *SETTINGS. If FLUSHP, discard input.
818 Return 0 if all went well, and -1 (setting errno) if anything failed. */
821 emacs_set_tty (int fd
, struct emacs_tty
*settings
, bool flushp
)
823 /* Set the primary parameters - baud rate, character size, etcetera. */
826 HANDLE h
= (HANDLE
)_get_osfhandle (fd
);
828 if (h
&& h
!= INVALID_HANDLE_VALUE
)
832 /* Assume the handle is open for input. */
834 FlushConsoleInputBuffer (h
);
835 new_mode
= settings
->main
;
836 SetConsoleMode (h
, new_mode
);
838 #endif /* WINDOWSNT */
841 /* We have those nifty POSIX tcmumbleattr functions.
842 William J. Smith <wjs@wiis.wang.com> writes:
843 "POSIX 1003.1 defines tcsetattr to return success if it was
844 able to perform any of the requested actions, even if some
845 of the requested actions could not be performed.
846 We must read settings back to ensure tty setup properly.
847 AIX requires this to keep tty from hanging occasionally." */
848 /* This make sure that we don't loop indefinitely in here. */
849 for (i
= 0 ; i
< 10 ; i
++)
850 if (tcsetattr (fd
, flushp
? TCSAFLUSH
: TCSADRAIN
, &settings
->main
) < 0)
861 memset (&new, 0, sizeof (new));
862 /* Get the current settings, and see if they're what we asked for. */
863 tcgetattr (fd
, &new);
864 /* We cannot use memcmp on the whole structure here because under
865 * aix386 the termios structure has some reserved field that may
868 if ( new.c_iflag
== settings
->main
.c_iflag
869 && new.c_oflag
== settings
->main
.c_oflag
870 && new.c_cflag
== settings
->main
.c_cflag
871 && new.c_lflag
== settings
->main
.c_lflag
872 && memcmp (new.c_cc
, settings
->main
.c_cc
, NCCS
) == 0)
879 /* We have survived the tempest. */
886 static int old_fcntl_owner
[FD_SETSIZE
];
887 #endif /* F_SETOWN */
889 /* This may also be defined in stdio,
890 but if so, this does no harm,
891 and using the same name avoids wasting the other one's space. */
894 unsigned char _sobuf
[BUFSIZ
+8];
899 /* Initialize the terminal mode on all tty devices that are currently
903 init_all_sys_modes (void)
905 struct tty_display_info
*tty
;
906 for (tty
= tty_list
; tty
; tty
= tty
->next
)
907 init_sys_modes (tty
);
910 /* Initialize the terminal mode on the given tty device. */
913 init_sys_modes (struct tty_display_info
*tty_out
)
915 struct emacs_tty tty
;
916 Lisp_Object terminal
;
918 Vtty_erase_char
= Qnil
;
923 if (!tty_out
->output
)
924 return; /* The tty is suspended. */
926 narrow_foreground_group (fileno (tty_out
->input
));
928 if (! tty_out
->old_tty
)
929 tty_out
->old_tty
= xmalloc (sizeof *tty_out
->old_tty
);
931 emacs_get_tty (fileno (tty_out
->input
), tty_out
->old_tty
);
933 tty
= *tty_out
->old_tty
;
935 #if !defined (DOS_NT)
936 XSETINT (Vtty_erase_char
, tty
.main
.c_cc
[VERASE
]);
938 tty
.main
.c_iflag
|= (IGNBRK
); /* Ignore break condition */
939 tty
.main
.c_iflag
&= ~ICRNL
; /* Disable map of CR to NL on input */
940 #ifdef INLCR /* I'm just being cautious,
941 since I can't check how widespread INLCR is--rms. */
942 tty
.main
.c_iflag
&= ~INLCR
; /* Disable map of NL to CR on input */
945 tty
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
947 tty
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
948 tty
.main
.c_lflag
&= ~ICANON
; /* Disable erase/kill processing */
950 tty
.main
.c_lflag
&= ~IEXTEN
; /* Disable other editing characters. */
952 tty
.main
.c_lflag
|= ISIG
; /* Enable signals */
953 if (tty_out
->flow_control
)
955 tty
.main
.c_iflag
|= IXON
; /* Enable start/stop output control */
957 tty
.main
.c_iflag
&= ~IXANY
;
961 tty
.main
.c_iflag
&= ~IXON
; /* Disable start/stop output control */
962 tty
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL
964 tty
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
966 if (tty_out
->meta_key
)
968 tty
.main
.c_cflag
|= CS8
; /* allow 8th bit on input */
969 tty
.main
.c_cflag
&= ~PARENB
;/* Don't check parity */
973 XSETTERMINAL(terminal
, tty_out
->terminal
);
974 if (!NILP (Fcontrolling_tty_p (terminal
)))
976 tty
.main
.c_cc
[VINTR
] = quit_char
; /* C-g (usually) gives SIGINT */
977 /* Set up C-g for both SIGQUIT and SIGINT.
978 We don't know which we will get, but we handle both alike
979 so which one it really gives us does not matter. */
980 tty
.main
.c_cc
[VQUIT
] = quit_char
;
984 /* We normally don't get interrupt or quit signals from tty
985 devices other than our controlling terminal; therefore,
986 we must handle C-g as normal input. Unfortunately, this
987 means that the interrupt and quit feature must be
988 disabled on secondary ttys, or we would not even see the
991 Note that even though emacsclient could have special code
992 to pass SIGINT to Emacs, we should _not_ enable
993 interrupt/quit keys for emacsclient frames. This means
994 that we can't break out of loops in C code from a
995 secondary tty frame, but we can always decide what
996 display the C-g came from, which is more important from a
997 usability point of view. (Consider the case when two
998 people work together using the same Emacs instance.) */
999 tty
.main
.c_cc
[VINTR
] = CDISABLE
;
1000 tty
.main
.c_cc
[VQUIT
] = CDISABLE
;
1002 tty
.main
.c_cc
[VMIN
] = 1; /* Input should wait for at least 1 char */
1003 tty
.main
.c_cc
[VTIME
] = 0; /* no matter how long that takes. */
1005 tty
.main
.c_cc
[VSWTCH
] = CDISABLE
; /* Turn off shell layering use
1010 tty
.main
.c_cc
[VSUSP
] = CDISABLE
; /* Turn off handling of C-z. */
1013 tty
.main
.c_cc
[V_DSUSP
] = CDISABLE
; /* Turn off handling of C-y. */
1014 #endif /* V_DSUSP */
1015 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1016 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1019 tty
.main
.c_cc
[VLNEXT
] = CDISABLE
;
1022 tty
.main
.c_cc
[VREPRINT
] = CDISABLE
;
1023 #endif /* VREPRINT */
1025 tty
.main
.c_cc
[VWERASE
] = CDISABLE
;
1026 #endif /* VWERASE */
1028 tty
.main
.c_cc
[VDISCARD
] = CDISABLE
;
1029 #endif /* VDISCARD */
1031 if (tty_out
->flow_control
)
1034 tty
.main
.c_cc
[VSTART
] = '\021';
1037 tty
.main
.c_cc
[VSTOP
] = '\023';
1043 tty
.main
.c_cc
[VSTART
] = CDISABLE
;
1046 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1051 tty
.main
.c_cc
[VSTRT
] = CDISABLE
;
1052 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1053 tty
.main
.c_cc
[VSUSP
] = CDISABLE
;
1054 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1055 if (tty_out
->flow_control
)
1058 tty
.main
.c_cc
[VSTART
] = '\021';
1061 tty
.main
.c_cc
[VSTOP
] = '\023';
1064 /* Also, PTY overloads NUL and BREAK.
1065 don't ignore break, but don't signal either, so it looks like NUL.
1066 This really serves a purpose only if running in an XTERM window
1067 or via TELNET or the like, but does no harm elsewhere. */
1068 tty
.main
.c_iflag
&= ~IGNBRK
;
1069 tty
.main
.c_iflag
&= ~BRKINT
;
1071 #endif /* not DOS_NT */
1073 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1074 if (!tty_out
->term_initted
)
1075 internal_terminal_init ();
1076 dos_ttraw (tty_out
);
1079 emacs_set_tty (fileno (tty_out
->input
), &tty
, 0);
1081 /* This code added to insure that, if flow-control is not to be used,
1082 we have an unlocked terminal at the start. */
1085 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TCXONC
, 1);
1088 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TIOCSTART
, 0);
1091 #if !defined (DOS_NT)
1093 if (!tty_out
->flow_control
) tcflow (fileno (tty_out
->input
), TCOON
);
1098 if (interrupt_input
)
1100 old_fcntl_owner
[fileno (tty_out
->input
)] =
1101 fcntl (fileno (tty_out
->input
), F_GETOWN
, 0);
1102 fcntl (fileno (tty_out
->input
), F_SETOWN
, getpid ());
1103 init_sigio (fileno (tty_out
->input
));
1105 if (gpm_tty
== tty_out
)
1107 /* Arrange for mouse events to give us SIGIO signals. */
1108 fcntl (gpm_fd
, F_SETOWN
, getpid ());
1109 fcntl (gpm_fd
, F_SETFL
, fcntl (gpm_fd
, F_GETFL
, 0) | O_NONBLOCK
);
1110 init_sigio (gpm_fd
);
1112 #endif /* HAVE_GPM */
1114 #endif /* F_GETOWN */
1117 /* This symbol is defined on recent USG systems.
1118 Someone says without this call USG won't really buffer the file
1119 even with a call to setbuf. */
1120 setvbuf (tty_out
->output
, (char *) _sobuf
, _IOFBF
, sizeof _sobuf
);
1122 setbuf (tty_out
->output
, (char *) _sobuf
);
1125 if (tty_out
->terminal
->set_terminal_modes_hook
)
1126 tty_out
->terminal
->set_terminal_modes_hook (tty_out
->terminal
);
1128 if (!tty_out
->term_initted
)
1130 Lisp_Object tail
, frame
;
1131 FOR_EACH_FRAME (tail
, frame
)
1133 /* XXX This needs to be revised. */
1134 if (FRAME_TERMCAP_P (XFRAME (frame
))
1135 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1136 init_frame_faces (XFRAME (frame
));
1140 if (tty_out
->term_initted
&& no_redraw_on_reenter
)
1142 /* We used to call "direct_output_forward_char(0)" here,
1143 but it's not clear why, since it may not do anything anyway. */
1147 Lisp_Object tail
, frame
;
1149 FOR_EACH_FRAME (tail
, frame
)
1151 if ((FRAME_TERMCAP_P (XFRAME (frame
))
1152 || FRAME_MSDOS_P (XFRAME (frame
)))
1153 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1154 FRAME_GARBAGED_P (XFRAME (frame
)) = 1;
1158 tty_out
->term_initted
= 1;
1161 /* Return true if safe to use tabs in output.
1162 At the time this is called, init_sys_modes has not been done yet. */
1165 tabs_safe_p (int fd
)
1167 struct emacs_tty etty
;
1169 emacs_get_tty (fd
, &etty
);
1172 return ((etty
.main
.c_oflag
& TABDLY
) != TAB3
);
1173 #else /* not TABDLY */
1175 #endif /* not TABDLY */
1181 /* Discard echoing. */
1184 suppress_echo_on_tty (int fd
)
1186 struct emacs_tty etty
;
1188 emacs_get_tty (fd
, &etty
);
1190 /* Set raw input mode. */
1193 etty
.main
.c_lflag
&= ~ICANON
; /* Disable buffering */
1194 etty
.main
.c_lflag
&= ~ECHO
; /* Disable echoing */
1195 #endif /* ! WINDOWSNT */
1196 emacs_set_tty (fd
, &etty
, 0);
1199 /* Get terminal size from system.
1200 Store number of lines into *HEIGHTP and width into *WIDTHP.
1201 We store 0 if there's no valid information. */
1204 get_tty_size (int fd
, int *widthp
, int *heightp
)
1206 #if defined TIOCGWINSZ
1209 struct winsize size
;
1211 if (ioctl (fd
, TIOCGWINSZ
, &size
) == -1)
1212 *widthp
= *heightp
= 0;
1215 *widthp
= size
.ws_col
;
1216 *heightp
= size
.ws_row
;
1219 #elif defined TIOCGSIZE
1221 /* SunOS - style. */
1222 struct ttysize size
;
1224 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1225 *widthp
= *heightp
= 0;
1228 *widthp
= size
.ts_cols
;
1229 *heightp
= size
.ts_lines
;
1232 #elif defined WINDOWSNT
1234 CONSOLE_SCREEN_BUFFER_INFO info
;
1235 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE
), &info
))
1237 *widthp
= info
.srWindow
.Right
- info
.srWindow
.Left
+ 1;
1238 *heightp
= info
.srWindow
.Bottom
- info
.srWindow
.Top
+ 1;
1241 *widthp
= *heightp
= 0;
1245 *widthp
= ScreenCols ();
1246 *heightp
= ScreenRows ();
1248 #else /* system doesn't know size */
1256 /* Set the logical window size associated with descriptor FD
1257 to HEIGHT and WIDTH. This is used mainly with ptys.
1258 Return a negative value on failure. */
1261 set_window_size (int fd
, int height
, int width
)
1266 struct winsize size
;
1267 size
.ws_row
= height
;
1268 size
.ws_col
= width
;
1270 return ioctl (fd
, TIOCSWINSZ
, &size
);
1275 /* SunOS - style. */
1276 struct ttysize size
;
1277 size
.ts_lines
= height
;
1278 size
.ts_cols
= width
;
1280 return ioctl (fd
, TIOCGSIZE
, &size
);
1283 #endif /* not SunOS-style */
1284 #endif /* not BSD-style */
1289 /* Prepare all terminal devices for exiting Emacs. */
1292 reset_all_sys_modes (void)
1294 struct tty_display_info
*tty
;
1295 for (tty
= tty_list
; tty
; tty
= tty
->next
)
1296 reset_sys_modes (tty
);
1299 /* Prepare the terminal for closing it; move the cursor to the
1300 bottom of the frame, turn off interrupt-driven I/O, etc. */
1303 reset_sys_modes (struct tty_display_info
*tty_out
)
1310 if (!tty_out
->term_initted
)
1313 if (!tty_out
->output
)
1314 return; /* The tty is suspended. */
1316 /* Go to and clear the last line of the terminal. */
1318 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1320 /* Code adapted from tty_clear_end_of_line. */
1321 if (tty_out
->TS_clr_line
)
1323 emacs_tputs (tty_out
, tty_out
->TS_clr_line
, 1, cmputc
);
1326 { /* have to do it the hard way */
1328 tty_turn_off_insert (tty_out
);
1330 for (i
= cursorX (tty_out
); i
< FrameCols (tty_out
) - 1; i
++)
1332 fputc (' ', tty_out
->output
);
1336 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1337 fflush (tty_out
->output
);
1339 if (tty_out
->terminal
->reset_terminal_modes_hook
)
1340 tty_out
->terminal
->reset_terminal_modes_hook (tty_out
->terminal
);
1342 /* Avoid possible loss of output when changing terminal modes. */
1343 while (fdatasync (fileno (tty_out
->output
)) != 0 && errno
== EINTR
)
1348 if (interrupt_input
)
1350 reset_sigio (fileno (tty_out
->input
));
1351 fcntl (fileno (tty_out
->input
), F_SETOWN
,
1352 old_fcntl_owner
[fileno (tty_out
->input
)]);
1354 #endif /* F_SETOWN */
1355 fcntl (fileno (tty_out
->input
), F_SETFL
,
1356 fcntl (fileno (tty_out
->input
), F_GETFL
, 0) & ~O_NONBLOCK
);
1359 if (tty_out
->old_tty
)
1360 while (emacs_set_tty (fileno (tty_out
->input
),
1361 tty_out
->old_tty
, 0) < 0 && errno
== EINTR
)
1364 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1368 widen_foreground_group (fileno (tty_out
->input
));
1373 /* Set up the proper status flags for use of a pty. */
1378 /* I'm told that TOICREMOTE does not mean control chars
1379 "can't be sent" but rather that they don't have
1380 input-editing or signaling effects.
1381 That should be good, because we have other ways
1382 to do those things in Emacs.
1383 However, telnet mode seems not to work on 4.2.
1384 So TIOCREMOTE is turned off now. */
1386 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1387 will hang. In particular, the "timeout" feature (which
1388 causes a read to return if there is no data available)
1389 does this. Also it is known that telnet mode will hang
1390 in such a way that Emacs must be stopped (perhaps this
1391 is the same problem).
1393 If TIOCREMOTE is turned off, then there is a bug in
1394 hp-ux which sometimes loses data. Apparently the
1395 code which blocks the master process when the internal
1396 buffer fills up does not work. Other than this,
1397 though, everything else seems to work fine.
1399 Since the latter lossage is more benign, we may as well
1400 lose that way. -- cph */
1402 #if defined (UNIX98_PTYS)
1405 ioctl (fd
, FIONBIO
, &on
);
1410 #endif /* HAVE_PTYS */
1413 init_system_name (void)
1415 char *hostname_alloc
= NULL
;
1417 #ifndef HAVE_GETHOSTNAME
1420 hostname
= uts
.nodename
;
1421 #else /* HAVE_GETHOSTNAME */
1422 char hostname_buf
[256];
1423 ptrdiff_t hostname_size
= sizeof hostname_buf
;
1424 hostname
= hostname_buf
;
1426 /* Try to get the host name; if the buffer is too short, try
1427 again. Apparently, the only indication gethostname gives of
1428 whether the buffer was large enough is the presence or absence
1429 of a '\0' in the string. Eech. */
1432 gethostname (hostname
, hostname_size
- 1);
1433 hostname
[hostname_size
- 1] = '\0';
1435 /* Was the buffer large enough for the '\0'? */
1436 if (strlen (hostname
) < hostname_size
- 1)
1439 hostname
= hostname_alloc
= xpalloc (hostname_alloc
, &hostname_size
, 1,
1440 min (PTRDIFF_MAX
, SIZE_MAX
), 1);
1442 #endif /* HAVE_GETHOSTNAME */
1444 for (p
= hostname
; *p
; p
++)
1445 if (*p
== ' ' || *p
== '\t')
1447 if (! (STRINGP (Vsystem_name
) && SBYTES (Vsystem_name
) == p
- hostname
1448 && strcmp (SSDATA (Vsystem_name
), hostname
) == 0))
1449 Vsystem_name
= build_string (hostname
);
1450 xfree (hostname_alloc
);
1453 sigset_t empty_mask
;
1455 static struct sigaction process_fatal_action
;
1458 emacs_sigaction_flags (void)
1461 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1462 'select') to reset their timeout on some platforms (e.g.,
1463 HP-UX 11), which is not what we want. Also, when Emacs is
1464 interactive, we don't want SA_RESTART because we need to poll
1465 for pending input so we need long-running syscalls to be interrupted
1466 after a signal that sets pending_signals.
1468 Non-interactive keyboard input goes through stdio, where we
1469 always want restartable system calls. */
1476 /* Store into *ACTION a signal action suitable for Emacs, with handler
1479 emacs_sigaction_init (struct sigaction
*action
, signal_handler_t handler
)
1481 sigemptyset (&action
->sa_mask
);
1483 /* When handling a signal, block nonfatal system signals that are caught
1484 by Emacs. This makes race conditions less likely. */
1485 sigaddset (&action
->sa_mask
, SIGALRM
);
1487 sigaddset (&action
->sa_mask
, SIGCHLD
);
1490 sigaddset (&action
->sa_mask
, SIGDANGER
);
1492 #ifdef PROFILER_CPU_SUPPORT
1493 sigaddset (&action
->sa_mask
, SIGPROF
);
1496 sigaddset (&action
->sa_mask
, SIGWINCH
);
1498 if (! noninteractive
)
1500 sigaddset (&action
->sa_mask
, SIGINT
);
1501 sigaddset (&action
->sa_mask
, SIGQUIT
);
1503 sigaddset (&action
->sa_mask
, SIGIO
);
1507 action
->sa_handler
= handler
;
1508 action
->sa_flags
= emacs_sigaction_flags ();
1511 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1512 static pthread_t main_thread
;
1515 /* SIG has arrived at the current process. Deliver it to the main
1516 thread, which should handle it with HANDLER.
1518 If we are on the main thread, handle the signal SIG with HANDLER.
1519 Otherwise, redirect the signal to the main thread, blocking it from
1520 this thread. POSIX says any thread can receive a signal that is
1521 associated with a process, process group, or asynchronous event.
1522 On GNU/Linux that is not true, but for other systems (FreeBSD at
1525 deliver_process_signal (int sig
, signal_handler_t handler
)
1527 /* Preserve errno, to avoid race conditions with signal handlers that
1528 might change errno. Races can occur even in single-threaded hosts. */
1529 int old_errno
= errno
;
1531 bool on_main_thread
= true;
1532 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1533 if (! pthread_equal (pthread_self (), main_thread
))
1536 sigemptyset (&blocked
);
1537 sigaddset (&blocked
, sig
);
1538 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1539 pthread_kill (main_thread
, sig
);
1540 on_main_thread
= false;
1549 /* Static location to save a fatal backtrace in a thread.
1550 FIXME: If two subsidiary threads fail simultaneously, the resulting
1551 backtrace may be garbage. */
1552 enum { BACKTRACE_LIMIT_MAX
= 500 };
1553 static void *thread_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
1554 static int thread_backtrace_npointers
;
1556 /* SIG has arrived at the current thread.
1557 If we are on the main thread, handle the signal SIG with HANDLER.
1558 Otherwise, this is a fatal error in the handling thread. */
1560 deliver_thread_signal (int sig
, signal_handler_t handler
)
1562 int old_errno
= errno
;
1564 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1565 if (! pthread_equal (pthread_self (), main_thread
))
1567 thread_backtrace_npointers
1568 = backtrace (thread_backtrace_buffer
, BACKTRACE_LIMIT_MAX
);
1569 sigaction (sig
, &process_fatal_action
, 0);
1570 pthread_kill (main_thread
, sig
);
1572 /* Avoid further damage while the main thread is exiting. */
1574 sigsuspend (&empty_mask
);
1582 #if !HAVE_DECL_SYS_SIGLIST
1584 # ifdef _sys_siglist
1585 # define sys_siglist _sys_siglist
1586 # elif HAVE_DECL___SYS_SIGLIST
1587 # define sys_siglist __sys_siglist
1589 # define sys_siglist my_sys_siglist
1590 static char const *sys_siglist
[NSIG
];
1595 # define sys_siglist_entries _sys_nsig
1597 # define sys_siglist_entries NSIG
1600 /* Handle bus errors, invalid instruction, etc. */
1602 handle_fatal_signal (int sig
)
1604 terminate_due_to_signal (sig
, 40);
1608 deliver_fatal_signal (int sig
)
1610 deliver_process_signal (sig
, handle_fatal_signal
);
1614 deliver_fatal_thread_signal (int sig
)
1616 deliver_thread_signal (sig
, handle_fatal_signal
);
1619 static _Noreturn
void
1620 handle_arith_signal (int sig
)
1622 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1623 xsignal0 (Qarith_error
);
1626 #ifdef HAVE_STACK_OVERFLOW_HANDLING
1628 /* -1 if stack grows down as expected on most OS/ABI variants, 1 otherwise. */
1630 static int stack_direction
;
1632 /* Alternate stack used by SIGSEGV handler below. */
1634 static unsigned char sigsegv_stack
[SIGSTKSZ
];
1636 /* Attempt to recover from SIGSEGV caused by C stack overflow. */
1639 handle_sigsegv (int sig
, siginfo_t
*siginfo
, void *arg
)
1641 /* Hard GC error may lead to stack overflow caused by
1642 too nested calls to mark_object. No way to survive. */
1643 if (!gc_in_progress
)
1647 if (!getrlimit (RLIMIT_STACK
, &rlim
))
1649 /* STACK_DANGER_ZONE has to be bigger than 16K on Cygwin, for
1650 reasons explained in
1651 https://www.cygwin.com/ml/cygwin/2015-06/msg00381.html. */
1653 enum { STACK_DANGER_ZONE
= 32 * 1024 };
1655 enum { STACK_DANGER_ZONE
= 16 * 1024 };
1657 char *beg
, *end
, *addr
;
1660 end
= stack_bottom
+ stack_direction
* rlim
.rlim_cur
;
1662 addr
= beg
, beg
= end
, end
= addr
;
1663 addr
= (char *) siginfo
->si_addr
;
1664 /* If we're somewhere on stack and too close to
1665 one of its boundaries, most likely this is it. */
1666 if (beg
< addr
&& addr
< end
1667 && (addr
- beg
< STACK_DANGER_ZONE
1668 || end
- addr
< STACK_DANGER_ZONE
))
1669 siglongjmp (return_to_command_loop
, 1);
1673 /* Otherwise we can't do anything with this. */
1674 deliver_fatal_thread_signal (sig
);
1677 /* Return true if we have successfully set up SIGSEGV handler on alternate
1678 stack. Otherwise we just treat SIGSEGV among the rest of fatal signals. */
1683 struct sigaction sa
;
1686 stack_direction
= ((char *) &ss
< stack_bottom
) ? -1 : 1;
1688 ss
.ss_sp
= sigsegv_stack
;
1689 ss
.ss_size
= sizeof (sigsegv_stack
);
1691 if (sigaltstack (&ss
, NULL
) < 0)
1694 sigfillset (&sa
.sa_mask
);
1695 sa
.sa_sigaction
= handle_sigsegv
;
1696 sa
.sa_flags
= SA_SIGINFO
| SA_ONSTACK
| emacs_sigaction_flags ();
1697 return sigaction (SIGSEGV
, &sa
, NULL
) < 0 ? 0 : 1;
1700 #else /* not HAVE_STACK_OVERFLOW_HANDLING */
1708 #endif /* HAVE_STACK_OVERFLOW_HANDLING */
1711 deliver_arith_signal (int sig
)
1713 deliver_thread_signal (sig
, handle_arith_signal
);
1718 /* Handler for SIGDANGER. */
1720 handle_danger_signal (int sig
)
1722 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1724 /* It might be unsafe to call do_auto_save now. */
1725 force_auto_save_soon ();
1729 deliver_danger_signal (int sig
)
1731 deliver_process_signal (sig
, handle_danger_signal
);
1735 /* Treat SIG as a terminating signal, unless it is already ignored and
1736 we are in --batch mode. Among other things, this makes nohup work. */
1738 maybe_fatal_sig (int sig
)
1740 bool catch_sig
= !noninteractive
;
1743 struct sigaction old_action
;
1744 sigaction (sig
, 0, &old_action
);
1745 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1748 sigaction (sig
, &process_fatal_action
, 0);
1752 init_signals (bool dumping
)
1754 struct sigaction thread_fatal_action
;
1755 struct sigaction action
;
1757 sigemptyset (&empty_mask
);
1759 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1760 main_thread
= pthread_self ();
1763 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1766 sys_siglist
[SIGABRT
] = "Aborted";
1768 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1770 sys_siglist
[SIGALRM
] = "Alarm clock";
1772 sys_siglist
[SIGBUS
] = "Bus error";
1775 sys_siglist
[SIGCHLD
] = "Child status changed";
1778 sys_siglist
[SIGCONT
] = "Continued";
1781 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1784 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1787 sys_siglist
[SIGEMT
] = "Emulation trap";
1789 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1791 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1794 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1796 sys_siglist
[SIGHUP
] = "Hangup";
1797 sys_siglist
[SIGILL
] = "Illegal instruction";
1798 sys_siglist
[SIGINT
] = "Interrupt";
1800 sys_siglist
[SIGIO
] = "I/O possible";
1803 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1806 sys_siglist
[SIGIOT
] = "IOT trap";
1808 sys_siglist
[SIGKILL
] = "Killed";
1810 sys_siglist
[SIGLOST
] = "Resource lost";
1813 sys_siglist
[SIGLWP
] = "SIGLWP";
1816 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1819 sys_siglist
[SIGWIND
] = "SIGPHONE";
1821 sys_siglist
[SIGPIPE
] = "Broken pipe";
1823 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1826 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1829 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1832 sys_siglist
[SIGPWR
] = "Power-fail restart";
1834 sys_siglist
[SIGQUIT
] = "Quit";
1836 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1839 sys_siglist
[SIGSAK
] = "Secure attention";
1841 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1843 sys_siglist
[SIGSOUND
] = "Sound completed";
1846 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1849 sys_siglist
[SIGSTP
] = "Stopped (user)";
1852 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1854 sys_siglist
[SIGTERM
] = "Terminated";
1856 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1859 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1862 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1865 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1868 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1871 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1874 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1877 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1880 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1883 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1886 sys_siglist
[SIGWINCH
] = "Window size changed";
1889 sys_siglist
[SIGWIND
] = "SIGWIND";
1892 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1895 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1898 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1900 /* Don't alter signal handlers if dumping. On some machines,
1901 changing signal handlers sets static data that would make signals
1902 fail to work right when the dumped Emacs is run. */
1906 sigfillset (&process_fatal_action
.sa_mask
);
1907 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1908 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1910 sigfillset (&thread_fatal_action
.sa_mask
);
1911 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1912 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1914 /* SIGINT may need special treatment on MS-Windows. See
1915 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1916 Please update the doc of kill-emacs, kill-emacs-hook, and
1917 NEWS if you change this. */
1919 maybe_fatal_sig (SIGHUP
);
1920 maybe_fatal_sig (SIGINT
);
1921 maybe_fatal_sig (SIGTERM
);
1923 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1924 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1925 to behave more like typical batch applications do. */
1926 if (! noninteractive
)
1927 signal (SIGPIPE
, SIG_IGN
);
1929 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1930 sigaction (SIGILL
, &thread_fatal_action
, 0);
1931 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1933 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1934 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1935 interpreter's floating point operations, so treat SIGFPE as an
1936 arith-error if it arises in the main thread. */
1937 if (IEEE_FLOATING_POINT
)
1938 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1941 emacs_sigaction_init (&action
, deliver_arith_signal
);
1942 sigaction (SIGFPE
, &action
, 0);
1946 add_user_signal (SIGUSR1
, "sigusr1");
1949 add_user_signal (SIGUSR2
, "sigusr2");
1951 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1953 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1956 sigaction (SIGORE
, &thread_fatal_action
, 0);
1959 sigaction (SIGUME
, &thread_fatal_action
, 0);
1962 sigaction (SIGDLK
, &process_fatal_action
, 0);
1965 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1968 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1971 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1974 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1976 if (!init_sigsegv ())
1977 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
1979 sigaction (SIGSYS
, &thread_fatal_action
, 0);
1981 sigaction (SIGTERM
, &process_fatal_action
, 0);
1983 signal (SIGPROF
, SIG_IGN
);
1986 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
1989 sigaction (SIGXCPU
, &process_fatal_action
, 0);
1992 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
1996 /* This just means available memory is getting low. */
1997 emacs_sigaction_init (&action
, deliver_danger_signal
);
1998 sigaction (SIGDANGER
, &action
, 0);
2001 /* AIX-specific signals. */
2003 sigaction (SIGGRANT
, &process_fatal_action
, 0);
2006 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
2009 sigaction (SIGMSG
, &process_fatal_action
, 0);
2012 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
2015 sigaction (SIGSAK
, &process_fatal_action
, 0);
2018 sigaction (SIGSOUND
, &process_fatal_action
, 0);
2021 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
2031 /* Figure out how many bits the system's random number generator uses.
2032 `random' and `lrand48' are assumed to return 31 usable bits.
2033 BSD `rand' returns a 31 bit value but the low order bits are unusable;
2034 so we'll shift it and treat it like the 15-bit USG `rand'. */
2038 # define RAND_BITS 31
2039 # else /* !HAVE_RANDOM */
2040 # ifdef HAVE_LRAND48
2041 # define RAND_BITS 31
2042 # define random lrand48
2043 # else /* !HAVE_LRAND48 */
2044 # define RAND_BITS 15
2045 # if RAND_MAX == 32767
2046 # define random rand
2047 # else /* RAND_MAX != 32767 */
2048 # if RAND_MAX == 2147483647
2049 # define random() (rand () >> 16)
2050 # else /* RAND_MAX != 2147483647 */
2052 # define random rand
2054 # define random() (rand () >> 16)
2056 # endif /* RAND_MAX != 2147483647 */
2057 # endif /* RAND_MAX != 32767 */
2058 # endif /* !HAVE_LRAND48 */
2059 # endif /* !HAVE_RANDOM */
2060 #endif /* !RAND_BITS */
2063 seed_random (void *seed
, ptrdiff_t seed_size
)
2065 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
2066 unsigned int arg
= 0;
2070 unsigned char *argp
= (unsigned char *) &arg
;
2071 unsigned char *seedp
= seed
;
2073 for (i
= 0; i
< seed_size
; i
++)
2074 argp
[i
% sizeof arg
] ^= seedp
[i
];
2078 # ifdef HAVE_LRAND48
2089 struct timespec t
= current_timespec ();
2090 uintmax_t v
= getpid () ^ t
.tv_sec
^ t
.tv_nsec
;
2091 seed_random (&v
, sizeof v
);
2095 * Return a nonnegative random integer out of whatever we've got.
2096 * It contains enough bits to make a random (signed) Emacs fixnum.
2097 * This suffices even for a 64-bit architecture with a 15-bit rand.
2104 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2105 val
= (random () ^ (val
<< RAND_BITS
)
2106 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2107 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2108 return val
& INTMASK
;
2111 #ifndef HAVE_SNPRINTF
2112 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2114 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2116 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2117 ptrdiff_t nbytes
= size
- 1;
2122 va_start (ap
, format
);
2123 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2127 if (nbytes
== size
- 1)
2129 /* Calculate the length of the string that would have been created
2130 had the buffer been large enough. */
2131 char stackbuf
[4000];
2133 ptrdiff_t bsize
= sizeof stackbuf
;
2134 va_start (ap
, format
);
2135 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2141 if (INT_MAX
< nbytes
)
2154 /* If a backtrace is available, output the top lines of it to stderr.
2155 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2156 This function may be called from a signal handler, so it should
2157 not invoke async-unsafe functions like malloc.
2159 If BACKTRACE_LIMIT is -1, initialize tables that 'backtrace' uses
2160 but do not output anything. This avoids some problems that can
2161 otherwise occur if the malloc arena is corrupted before 'backtrace'
2162 is called, since 'backtrace' may call malloc if the tables are not
2165 If the static variable THREAD_BACKTRACE_NPOINTERS is nonzero, a
2166 fatal error has occurred in some other thread; generate a thread
2167 backtrace instead, ignoring BACKTRACE_LIMIT. */
2169 emacs_backtrace (int backtrace_limit
)
2171 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2172 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2176 if (thread_backtrace_npointers
)
2178 buffer
= thread_backtrace_buffer
;
2179 npointers
= thread_backtrace_npointers
;
2183 buffer
= main_backtrace_buffer
;
2185 /* Work around 'backtrace' bug; see Bug#19959 and glibc bug#18084. */
2186 if (bounded_limit
< 0)
2188 backtrace (buffer
, 1);
2192 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2197 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2198 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2199 if (bounded_limit
< npointers
)
2200 emacs_write (STDERR_FILENO
, "...\n", 4);
2208 terminate_due_to_signal (SIGABRT
, 40);
2212 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2213 Use binary I/O on systems that care about text vs binary I/O.
2214 Arrange for subprograms to not inherit the file descriptor.
2215 Prefer a method that is multithread-safe, if available.
2216 Do not fail merely because the open was interrupted by a signal.
2217 Allow the user to quit. */
2220 emacs_open (const char *file
, int oflags
, int mode
)
2223 if (! (oflags
& O_TEXT
))
2225 oflags
|= O_CLOEXEC
;
2226 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2228 if (! O_CLOEXEC
&& 0 <= fd
)
2229 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2233 /* Open FILE as a stream for Emacs use, with mode MODE.
2234 Act like emacs_open with respect to threads, signals, and quits. */
2237 emacs_fopen (char const *file
, char const *mode
)
2239 int fd
, omode
, oflags
;
2241 char const *m
= mode
;
2245 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2246 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2247 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2248 default: emacs_abort ();
2254 case '+': omode
= O_RDWR
; break;
2255 case 'b': bflag
= O_BINARY
; break;
2256 case 't': bflag
= O_TEXT
; break;
2257 default: /* Ignore. */ break;
2260 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2261 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2264 /* Create a pipe for Emacs use. */
2267 emacs_pipe (int fd
[2])
2272 int result
= pipe2 (fd
, O_BINARY
| O_CLOEXEC
);
2273 if (! O_CLOEXEC
&& result
== 0)
2275 fcntl (fd
[0], F_SETFD
, FD_CLOEXEC
);
2276 fcntl (fd
[1], F_SETFD
, FD_CLOEXEC
);
2282 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2283 For the background behind this mess, please see Austin Group defect 529
2284 <http://austingroupbugs.net/view.php?id=529>. */
2286 #ifndef POSIX_CLOSE_RESTART
2287 # define POSIX_CLOSE_RESTART 1
2289 posix_close (int fd
, int flag
)
2291 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2292 eassert (flag
== POSIX_CLOSE_RESTART
);
2294 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2295 on a system that does not define POSIX_CLOSE_RESTART.
2297 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2298 closed, and retrying the close could inadvertently close a file
2299 descriptor allocated by some other thread. In other systems
2300 (e.g., HP/UX) FD is not closed. And in still other systems
2301 (e.g., OS X, Solaris), maybe FD is closed, maybe not, and in a
2302 multithreaded program there can be no way to tell.
2304 So, in this case, pretend that the close succeeded. This works
2305 well on systems like GNU/Linux that close FD. Although it may
2306 leak a file descriptor on other systems, the leak is unlikely and
2307 it's better to leak than to close a random victim. */
2308 return close (fd
) == 0 || errno
== EINTR
? 0 : -1;
2312 /* Close FD, retrying if interrupted. If successful, return 0;
2313 otherwise, return -1 and set errno to a non-EINTR value. Consider
2314 an EINPROGRESS error to be successful, as that's merely a signal
2315 arriving. FD is always closed when this function returns, even
2318 Do not call this function if FD is nonnegative and might already be closed,
2319 as that might close an innocent victim opened by some other thread. */
2322 emacs_close (int fd
)
2326 int r
= posix_close (fd
, POSIX_CLOSE_RESTART
);
2329 if (!POSIX_CLOSE_RESTART
|| errno
!= EINTR
)
2331 eassert (errno
!= EBADF
|| fd
< 0);
2332 return errno
== EINPROGRESS
? 0 : r
;
2337 /* Maximum number of bytes to read or write in a single system call.
2338 This works around a serious bug in Linux kernels before 2.6.16; see
2339 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2340 It's likely to work around similar bugs in other operating systems, so do it
2341 on all platforms. Round INT_MAX down to a page size, with the conservative
2342 assumption that page sizes are at most 2**18 bytes (any kernel with a
2343 page size larger than that shouldn't have the bug). */
2344 #ifndef MAX_RW_COUNT
2345 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2348 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2349 Return the number of bytes read, which might be less than NBYTE.
2350 On error, set errno and return -1. */
2352 emacs_read (int fildes
, void *buf
, ptrdiff_t nbyte
)
2356 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2357 passes a size that large to emacs_read. */
2359 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2360 && (errno
== EINTR
))
2365 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2366 or if a partial write occurs. If interrupted, process pending
2367 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2368 errno if this is less than NBYTE. */
2370 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2371 bool process_signals
)
2373 ptrdiff_t bytes_written
= 0;
2377 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2383 /* I originally used `QUIT' but that might cause files to
2384 be truncated if you hit C-g in the middle of it. --Stef */
2385 if (process_signals
&& pending_signals
)
2386 process_pending_signals ();
2398 return bytes_written
;
2401 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2402 interrupted or if a partial write occurs. Return the number of
2403 bytes written, setting errno if this is less than NBYTE. */
2405 emacs_write (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2407 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2410 /* Like emacs_write, but also process pending signals if interrupted. */
2412 emacs_write_sig (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2414 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2417 /* Write a diagnostic to standard error that contains MESSAGE and a
2418 string derived from errno. Preserve errno. Do not buffer stderr.
2419 Do not process pending signals if interrupted. */
2421 emacs_perror (char const *message
)
2424 char const *error_string
= strerror (err
);
2425 char const *command
= (initial_argv
&& initial_argv
[0]
2426 ? initial_argv
[0] : "emacs");
2427 /* Write it out all at once, if it's short; this is less likely to
2428 be interleaved with other output. */
2430 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2431 command
, message
, error_string
);
2432 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2433 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2436 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2437 emacs_write (STDERR_FILENO
, ": ", 2);
2438 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2439 emacs_write (STDERR_FILENO
, ": ", 2);
2440 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2441 emacs_write (STDERR_FILENO
, "\n", 1);
2446 /* Return a struct timeval that is roughly equivalent to T.
2447 Use the least timeval not less than T.
2448 Return an extremal value if the result would overflow. */
2450 make_timeval (struct timespec t
)
2453 tv
.tv_sec
= t
.tv_sec
;
2454 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2456 if (t
.tv_nsec
% 1000 != 0)
2458 if (tv
.tv_usec
< 999999)
2460 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2470 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2471 ATIME and MTIME, respectively.
2472 FD must be either negative -- in which case it is ignored --
2473 or a file descriptor that is open on FILE.
2474 If FD is nonnegative, then FILE can be NULL. */
2476 set_file_times (int fd
, const char *filename
,
2477 struct timespec atime
, struct timespec mtime
)
2479 struct timespec timespec
[2];
2480 timespec
[0] = atime
;
2481 timespec
[1] = mtime
;
2482 return fdutimens (fd
, filename
, timespec
);
2485 /* Like strsignal, except async-signal-safe, and this function typically
2486 returns a string in the C locale rather than the current locale. */
2488 safe_strsignal (int code
)
2490 char const *signame
= 0;
2492 if (0 <= code
&& code
< sys_siglist_entries
)
2493 signame
= sys_siglist
[code
];
2495 signame
= "Unknown signal";
2501 /* For make-serial-process */
2503 serial_open (Lisp_Object port
)
2505 int fd
= emacs_open (SSDATA (port
), O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2507 report_file_error ("Opening serial port", port
);
2509 ioctl (fd
, TIOCEXCL
, (char *) 0);
2515 #if !defined (HAVE_CFMAKERAW)
2516 /* Workaround for targets which are missing cfmakeraw. */
2517 /* Pasted from man page. */
2519 cfmakeraw (struct termios
*termios_p
)
2521 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2522 termios_p
->c_oflag
&= ~OPOST
;
2523 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2524 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2525 termios_p
->c_cflag
|= CS8
;
2527 #endif /* !defined (HAVE_CFMAKERAW */
2529 #if !defined (HAVE_CFSETSPEED)
2530 /* Workaround for targets which are missing cfsetspeed. */
2532 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2534 return (cfsetispeed (termios_p
, vitesse
)
2535 + cfsetospeed (termios_p
, vitesse
));
2539 /* For serial-process-configure */
2541 serial_configure (struct Lisp_Process
*p
,
2542 Lisp_Object contact
)
2544 Lisp_Object childp2
= Qnil
;
2545 Lisp_Object tem
= Qnil
;
2546 struct termios attr
;
2548 char summary
[4] = "???"; /* This usually becomes "8N1". */
2550 childp2
= Fcopy_sequence (p
->childp
);
2552 /* Read port attributes and prepare default configuration. */
2553 err
= tcgetattr (p
->outfd
, &attr
);
2555 report_file_error ("Failed tcgetattr", Qnil
);
2557 #if defined (CLOCAL)
2558 attr
.c_cflag
|= CLOCAL
;
2561 attr
.c_cflag
|= CREAD
;
2564 /* Configure speed. */
2565 if (!NILP (Fplist_member (contact
, QCspeed
)))
2566 tem
= Fplist_get (contact
, QCspeed
);
2568 tem
= Fplist_get (p
->childp
, QCspeed
);
2570 err
= cfsetspeed (&attr
, XINT (tem
));
2572 report_file_error ("Failed cfsetspeed", tem
);
2573 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2575 /* Configure bytesize. */
2576 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2577 tem
= Fplist_get (contact
, QCbytesize
);
2579 tem
= Fplist_get (p
->childp
, QCbytesize
);
2581 tem
= make_number (8);
2583 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2584 error (":bytesize must be nil (8), 7, or 8");
2585 summary
[0] = XINT (tem
) + '0';
2586 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2587 attr
.c_cflag
&= ~CSIZE
;
2588 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2590 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2591 if (XINT (tem
) != 8)
2592 error ("Bytesize cannot be changed");
2594 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2596 /* Configure parity. */
2597 if (!NILP (Fplist_member (contact
, QCparity
)))
2598 tem
= Fplist_get (contact
, QCparity
);
2600 tem
= Fplist_get (p
->childp
, QCparity
);
2601 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2602 error (":parity must be nil (no parity), `even', or `odd'");
2603 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2604 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2605 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2610 else if (EQ (tem
, Qeven
))
2613 attr
.c_cflag
|= PARENB
;
2614 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2616 else if (EQ (tem
, Qodd
))
2619 attr
.c_cflag
|= (PARENB
| PARODD
);
2620 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2623 /* Don't error on no parity, which should be set by cfmakeraw. */
2625 error ("Parity cannot be configured");
2627 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2629 /* Configure stopbits. */
2630 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2631 tem
= Fplist_get (contact
, QCstopbits
);
2633 tem
= Fplist_get (p
->childp
, QCstopbits
);
2635 tem
= make_number (1);
2637 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2638 error (":stopbits must be nil (1 stopbit), 1, or 2");
2639 summary
[2] = XINT (tem
) + '0';
2640 #if defined (CSTOPB)
2641 attr
.c_cflag
&= ~CSTOPB
;
2642 if (XINT (tem
) == 2)
2643 attr
.c_cflag
|= CSTOPB
;
2645 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2646 if (XINT (tem
) != 1)
2647 error ("Stopbits cannot be configured");
2649 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2651 /* Configure flowcontrol. */
2652 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2653 tem
= Fplist_get (contact
, QCflowcontrol
);
2655 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2656 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2657 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2658 #if defined (CRTSCTS)
2659 attr
.c_cflag
&= ~CRTSCTS
;
2661 #if defined (CNEW_RTSCTS)
2662 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2664 #if defined (IXON) && defined (IXOFF)
2665 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2669 /* Already configured. */
2671 else if (EQ (tem
, Qhw
))
2673 #if defined (CRTSCTS)
2674 attr
.c_cflag
|= CRTSCTS
;
2675 #elif defined (CNEW_RTSCTS)
2676 attr
.c_cflag
|= CNEW_RTSCTS
;
2678 error ("Hardware flowcontrol (RTS/CTS) not supported");
2681 else if (EQ (tem
, Qsw
))
2683 #if defined (IXON) && defined (IXOFF)
2684 attr
.c_iflag
|= (IXON
| IXOFF
);
2686 error ("Software flowcontrol (XON/XOFF) not supported");
2689 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2691 /* Activate configuration. */
2692 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2694 report_file_error ("Failed tcsetattr", Qnil
);
2696 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2697 pset_childp (p
, childp2
);
2699 #endif /* not DOS_NT */
2701 /* System depended enumeration of and access to system processes a-la ps(1). */
2705 /* Process enumeration and access via /proc. */
2708 list_system_processes (void)
2710 Lisp_Object procdir
, match
, proclist
, next
;
2711 struct gcpro gcpro1
, gcpro2
;
2712 register Lisp_Object tail
;
2714 GCPRO2 (procdir
, match
);
2715 /* For every process on the system, there's a directory in the
2716 "/proc" pseudo-directory whose name is the numeric ID of that
2718 procdir
= build_string ("/proc");
2719 match
= build_string ("[0-9]+");
2720 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2722 /* `proclist' gives process IDs as strings. Destructively convert
2723 each string into a number. */
2724 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2727 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2731 /* directory_files_internal returns the files in reverse order; undo
2733 proclist
= Fnreverse (proclist
);
2737 #elif defined DARWIN_OS || defined __FreeBSD__
2740 list_system_processes (void)
2743 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2745 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2748 struct kinfo_proc
*procs
;
2751 struct gcpro gcpro1
;
2752 Lisp_Object proclist
= Qnil
;
2754 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2757 procs
= xmalloc (len
);
2758 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2765 len
/= sizeof (struct kinfo_proc
);
2766 for (i
= 0; i
< len
; i
++)
2769 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2771 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2781 /* The WINDOWSNT implementation is in w32.c.
2782 The MSDOS implementation is in dosfns.c. */
2783 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2786 list_system_processes (void)
2791 #endif /* !defined (WINDOWSNT) */
2793 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2794 static struct timespec
2795 time_from_jiffies (unsigned long long tval
, long hz
)
2797 unsigned long long s
= tval
/ hz
;
2798 unsigned long long frac
= tval
% hz
;
2801 if (TYPE_MAXIMUM (time_t) < s
)
2803 if (LONG_MAX
- 1 <= ULLONG_MAX
/ TIMESPEC_RESOLUTION
2804 || frac
<= ULLONG_MAX
/ TIMESPEC_RESOLUTION
)
2805 ns
= frac
* TIMESPEC_RESOLUTION
/ hz
;
2808 /* This is reachable only in the unlikely case that HZ * HZ
2809 exceeds ULLONG_MAX. It calculates an approximation that is
2810 guaranteed to be in range. */
2811 long hz_per_ns
= (hz
/ TIMESPEC_RESOLUTION
2812 + (hz
% TIMESPEC_RESOLUTION
!= 0));
2813 ns
= frac
/ hz_per_ns
;
2816 return make_timespec (s
, ns
);
2820 ltime_from_jiffies (unsigned long long tval
, long hz
)
2822 struct timespec t
= time_from_jiffies (tval
, hz
);
2823 return make_lisp_time (t
);
2826 static struct timespec
2830 struct timespec up
= make_timespec (0, 0);
2833 fup
= emacs_fopen ("/proc/uptime", "r");
2837 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2838 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2840 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2841 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2842 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2845 if (TYPE_MAXIMUM (time_t) < upsec
)
2847 upsec
= TYPE_MAXIMUM (time_t);
2848 upfrac
= TIMESPEC_RESOLUTION
- 1;
2852 int upfraclen
= upfrac_end
- upfrac_start
;
2853 for (; upfraclen
< LOG10_TIMESPEC_RESOLUTION
; upfraclen
++)
2855 for (; LOG10_TIMESPEC_RESOLUTION
< upfraclen
; upfraclen
--)
2857 upfrac
= min (upfrac
, TIMESPEC_RESOLUTION
- 1);
2859 up
= make_timespec (upsec
, upfrac
);
2868 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2869 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2872 procfs_ttyname (int rdev
)
2875 char name
[PATH_MAX
];
2878 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2884 unsigned long minor_beg
, minor_end
;
2885 char minor
[25]; /* 2 32-bit numbers + dash */
2888 for (; !feof (fdev
) && !ferror (fdev
); name
[0] = 0)
2890 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2891 && major
== MAJOR (rdev
))
2893 minor_beg
= strtoul (minor
, &endp
, 0);
2895 minor_end
= minor_beg
;
2896 else if (*endp
== '-')
2897 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2901 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2903 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2911 return build_string (name
);
2915 procfs_get_total_memory (void)
2918 uintmax_t retval
= 2 * 1024 * 1024; /* default: 2 GiB */
2922 fmem
= emacs_fopen ("/proc/meminfo", "r");
2926 uintmax_t entry_value
;
2930 switch (fscanf (fmem
, "MemTotal: %"SCNuMAX
, &entry_value
))
2933 retval
= entry_value
;
2938 while ((c
= getc (fmem
)) != EOF
&& c
!= '\n')
2956 system_process_attributes (Lisp_Object pid
)
2958 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
2962 long clocks_per_sec
;
2964 char procbuf
[1025], *p
, *q
;
2967 static char const default_cmd
[] = "???";
2968 const char *cmd
= default_cmd
;
2969 int cmdsize
= sizeof default_cmd
- 1;
2970 char *cmdline
= NULL
;
2971 ptrdiff_t cmdline_size
;
2974 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
2977 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
2978 long priority
, niceness
, rss
;
2979 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
2980 struct timespec tnow
, tstart
, tboot
, telapsed
, us_time
;
2982 Lisp_Object attrs
= Qnil
;
2983 Lisp_Object cmd_str
, decoded_cmd
;
2985 struct gcpro gcpro1
, gcpro2
;
2987 CHECK_NUMBER_OR_FLOAT (pid
);
2988 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
2989 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
2990 if (stat (procfn
, &st
) < 0)
2993 GCPRO2 (attrs
, decoded_cmd
);
2997 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
2999 pw
= getpwuid (uid
);
3002 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3005 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3007 gr
= getgrgid (gid
);
3010 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3012 count
= SPECPDL_INDEX ();
3013 strcpy (fn
, procfn
);
3014 procfn_end
= fn
+ strlen (fn
);
3015 strcpy (procfn_end
, "/stat");
3016 fd
= emacs_open (fn
, O_RDONLY
, 0);
3021 record_unwind_protect_int (close_file_unwind
, fd
);
3022 nread
= emacs_read (fd
, procbuf
, sizeof procbuf
- 1);
3026 procbuf
[nread
] = '\0';
3029 p
= strchr (p
, '(');
3032 q
= strrchr (p
+ 1, ')');
3042 /* Command name is encoded in locale-coding-system; decode it. */
3043 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
3044 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3045 Vlocale_coding_system
, 0);
3046 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3048 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
3049 utime stime cutime cstime priority nice thcount . start vsize rss */
3051 && (sscanf (q
+ 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
3052 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
3053 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
3054 &minflt
, &cminflt
, &majflt
, &cmajflt
,
3055 &u_time
, &s_time
, &cutime
, &cstime
,
3056 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
)
3061 state_str
[1] = '\0';
3062 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3063 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid
)), attrs
);
3064 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp
)), attrs
);
3065 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess
)), attrs
);
3066 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
3067 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid
)), attrs
);
3068 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
3069 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
3070 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)),
3072 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)),
3074 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
3075 if (clocks_per_sec
< 0)
3076 clocks_per_sec
= 100;
3077 attrs
= Fcons (Fcons (Qutime
,
3078 ltime_from_jiffies (u_time
, clocks_per_sec
)),
3080 attrs
= Fcons (Fcons (Qstime
,
3081 ltime_from_jiffies (s_time
, clocks_per_sec
)),
3083 attrs
= Fcons (Fcons (Qtime
,
3084 ltime_from_jiffies (s_time
+ u_time
,
3087 attrs
= Fcons (Fcons (Qcutime
,
3088 ltime_from_jiffies (cutime
, clocks_per_sec
)),
3090 attrs
= Fcons (Fcons (Qcstime
,
3091 ltime_from_jiffies (cstime
, clocks_per_sec
)),
3093 attrs
= Fcons (Fcons (Qctime
,
3094 ltime_from_jiffies (cstime
+ cutime
,
3097 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
3098 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
3099 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount
)),
3101 tnow
= current_timespec ();
3102 telapsed
= get_up_time ();
3103 tboot
= timespec_sub (tnow
, telapsed
);
3104 tstart
= time_from_jiffies (start
, clocks_per_sec
);
3105 tstart
= timespec_add (tboot
, tstart
);
3106 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
3107 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/ 1024)),
3109 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4 * rss
)), attrs
);
3110 telapsed
= timespec_sub (tnow
, tstart
);
3111 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
3112 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
3113 pcpu
= timespectod (us_time
) / timespectod (telapsed
);
3116 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
3117 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
3120 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
3123 unbind_to (count
, Qnil
);
3126 strcpy (procfn_end
, "/cmdline");
3127 fd
= emacs_open (fn
, O_RDONLY
, 0);
3130 ptrdiff_t readsize
, nread_incr
;
3131 record_unwind_protect_int (close_file_unwind
, fd
);
3132 record_unwind_protect_nothing ();
3133 nread
= cmdline_size
= 0;
3137 cmdline
= xpalloc (cmdline
, &cmdline_size
, 2, STRING_BYTES_BOUND
, 1);
3138 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3140 /* Leave room even if every byte needs escaping below. */
3141 readsize
= (cmdline_size
>> 1) - nread
;
3143 nread_incr
= emacs_read (fd
, cmdline
+ nread
, readsize
);
3144 nread
+= max (0, nread_incr
);
3146 while (nread_incr
== readsize
);
3150 /* We don't want trailing null characters. */
3151 for (p
= cmdline
+ nread
; cmdline
< p
&& !p
[-1]; p
--)
3154 /* Escape-quote whitespace and backslashes. */
3155 q
= cmdline
+ cmdline_size
;
3160 if (c_isspace (c
) || c
== '\\')
3164 nread
= cmdline
+ cmdline_size
- q
;
3169 nread
= cmdsize
+ 2;
3170 cmdline_size
= nread
+ 1;
3171 q
= cmdline
= xrealloc (cmdline
, cmdline_size
);
3172 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3173 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3175 /* Command line is encoded in locale-coding-system; decode it. */
3176 cmd_str
= make_unibyte_string (q
, nread
);
3177 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3178 Vlocale_coding_system
, 0);
3179 unbind_to (count
, Qnil
);
3180 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3187 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3189 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3190 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3191 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3192 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3193 #undef _FILE_OFFSET_BITS
3195 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3200 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3201 #define _FILE_OFFSET_BITS 64
3202 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3204 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3207 system_process_attributes (Lisp_Object pid
)
3209 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3214 struct psinfo pinfo
;
3220 Lisp_Object attrs
= Qnil
;
3221 Lisp_Object decoded_cmd
;
3222 struct gcpro gcpro1
, gcpro2
;
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)
3231 GCPRO2 (attrs
, decoded_cmd
);
3235 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3237 pw
= getpwuid (uid
);
3240 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3243 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3245 gr
= getgrgid (gid
);
3248 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3250 count
= SPECPDL_INDEX ();
3251 strcpy (fn
, procfn
);
3252 procfn_end
= fn
+ strlen (fn
);
3253 strcpy (procfn_end
, "/psinfo");
3254 fd
= emacs_open (fn
, O_RDONLY
, 0);
3259 record_unwind_protect (close_file_unwind
, fd
);
3260 nread
= emacs_read (fd
, &pinfo
, sizeof pinfo
);
3263 if (nread
== sizeof pinfo
)
3265 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3266 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3267 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3271 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3272 state_str
[1] = '\0';
3273 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3276 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3277 need to get a string from it. */
3279 /* FIXME: missing: Qtpgid */
3291 Are they available? */
3293 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3294 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3295 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3296 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3297 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)),
3300 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3301 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)),
3303 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)),
3306 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3307 range 0 .. 2**15, representing 0.0 .. 1.0. */
3308 attrs
= Fcons (Fcons (Qpcpu
,
3309 make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)),
3311 attrs
= Fcons (Fcons (Qpmem
,
3312 make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)),
3315 decoded_cmd
= (code_convert_string_norecord
3316 (build_unibyte_string (pinfo
.pr_fname
),
3317 Vlocale_coding_system
, 0));
3318 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3319 decoded_cmd
= (code_convert_string_norecord
3320 (build_unibyte_string (pinfo
.pr_psargs
),
3321 Vlocale_coding_system
, 0));
3322 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3324 unbind_to (count
, Qnil
);
3329 #elif defined __FreeBSD__
3331 static struct timespec
3332 timeval_to_timespec (struct timeval t
)
3334 return make_timespec (t
.tv_sec
, t
.tv_usec
* 1000);
3338 make_lisp_timeval (struct timeval t
)
3340 return make_lisp_time (timeval_to_timespec (t
));
3344 system_process_attributes (Lisp_Object pid
)
3347 int pagesize
= getpagesize ();
3348 unsigned long npages
;
3354 char args
[MAXPATHLEN
];
3355 struct timespec t
, now
;
3357 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3358 struct kinfo_proc proc
;
3359 size_t proclen
= sizeof proc
;
3361 struct gcpro gcpro1
, gcpro2
;
3362 Lisp_Object attrs
= Qnil
;
3363 Lisp_Object decoded_comm
;
3365 CHECK_NUMBER_OR_FLOAT (pid
);
3366 CONS_TO_INTEGER (pid
, int, proc_id
);
3369 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3372 GCPRO2 (attrs
, decoded_comm
);
3374 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3377 pw
= getpwuid (proc
.ki_uid
);
3380 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3382 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3385 gr
= getgrgid (proc
.ki_svgid
);
3388 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3390 decoded_comm
= (code_convert_string_norecord
3391 (build_unibyte_string (proc
.ki_comm
),
3392 Vlocale_coding_system
, 0));
3394 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3396 char state
[2] = {'\0', '\0'};
3397 switch (proc
.ki_stat
)
3419 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3422 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3423 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3424 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3427 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3430 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3432 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3433 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3434 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3435 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3436 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3438 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3440 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3442 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage
.ru_utime
),
3443 timeval_to_timespec (proc
.ki_rusage
.ru_stime
));
3444 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3446 attrs
= Fcons (Fcons (Qcutime
,
3447 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3449 attrs
= Fcons (Fcons (Qcstime
,
3450 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3452 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage_ch
.ru_utime
),
3453 timeval_to_timespec (proc
.ki_rusage_ch
.ru_stime
));
3454 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3456 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3458 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3459 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3460 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3461 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3462 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3465 now
= current_timespec ();
3466 t
= timespec_sub (now
, timeval_to_timespec (proc
.ki_start
));
3467 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3469 len
= sizeof fscale
;
3470 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3475 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3477 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3478 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3479 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3483 len
= sizeof npages
;
3484 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3486 double pmem
= (proc
.ki_flag
& P_INMEM
3487 ? 100.0 * proc
.ki_rssize
/ npages
3489 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3492 mib
[2] = KERN_PROC_ARGS
;
3494 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3497 for (i
= 0; i
< len
; i
++)
3499 if (! args
[i
] && i
< len
- 1)
3504 (code_convert_string_norecord
3505 (build_unibyte_string (args
),
3506 Vlocale_coding_system
, 0));
3508 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3515 /* The WINDOWSNT implementation is in w32.c.
3516 The MSDOS implementation is in dosfns.c. */
3517 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3520 system_process_attributes (Lisp_Object pid
)
3525 #endif /* !defined (WINDOWSNT) */
3527 /* Wide character string collation. */
3529 #ifdef __STDC_ISO_10646__
3531 # include <wctype.h>
3533 # if defined HAVE_NEWLOCALE || defined HAVE_SETLOCALE
3534 # include <locale.h>
3537 # define LC_COLLATE 0
3539 # ifndef LC_COLLATE_MASK
3540 # define LC_COLLATE_MASK 0
3545 # ifndef LC_CTYPE_MASK
3546 # define LC_CTYPE_MASK 0
3549 # ifndef HAVE_NEWLOCALE
3555 # define freelocale emacs_freelocale
3556 # define locale_t emacs_locale_t
3557 # define newlocale emacs_newlocale
3558 # define wcscoll_l emacs_wcscoll_l
3559 # define towlower_l emacs_towlower_l
3561 typedef char const *locale_t
;
3564 newlocale (int category_mask
, char const *locale
, locale_t loc
)
3570 freelocale (locale_t loc
)
3575 emacs_setlocale (int category
, char const *locale
)
3577 # ifdef HAVE_SETLOCALE
3579 char *loc
= setlocale (category
, locale
);
3590 wcscoll_l (wchar_t const *a
, wchar_t const *b
, locale_t loc
)
3593 char *oldloc
= emacs_setlocale (LC_COLLATE
, NULL
);
3601 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3602 strcpy (oldcopy
, oldloc
);
3603 if (! emacs_setlocale (LC_COLLATE
, loc
))
3608 result
= wcscoll (a
, b
);
3610 if (! emacs_setlocale (LC_COLLATE
, oldcopy
))
3621 towlower_l (wint_t wc
, locale_t loc
)
3624 char *oldloc
= emacs_setlocale (LC_CTYPE
, NULL
);
3629 char *oldcopy
= SAFE_ALLOCA (strlen (oldloc
) + 1);
3630 strcpy (oldcopy
, oldloc
);
3631 if (emacs_setlocale (LC_CTYPE
, loc
))
3633 result
= towlower (wc
);
3634 emacs_setlocale (LC_COLLATE
, oldcopy
);
3644 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3645 Lisp_Object locale
, Lisp_Object ignore_case
)
3648 ptrdiff_t len
, i
, i_byte
;
3653 /* Convert byte stream to code points. */
3654 len
= SCHARS (s1
); i
= i_byte
= 0;
3655 SAFE_NALLOCA (p1
, 1, len
+ 1);
3657 FETCH_STRING_CHAR_ADVANCE (*(p1
+i
-1), s1
, i
, i_byte
);
3660 len
= SCHARS (s2
); i
= i_byte
= 0;
3661 SAFE_NALLOCA (p2
, 1, len
+ 1);
3663 FETCH_STRING_CHAR_ADVANCE (*(p2
+i
-1), s2
, i
, i_byte
);
3666 if (STRINGP (locale
))
3668 locale_t loc
= newlocale (LC_COLLATE_MASK
| LC_CTYPE_MASK
,
3669 SSDATA (locale
), 0);
3671 error ("Invalid locale %s: %s", SSDATA (locale
), strerror (errno
));
3673 if (! NILP (ignore_case
))
3674 for (int i
= 1; i
< 3; i
++)
3676 wchar_t *p
= (i
== 1) ? p1
: p2
;
3678 *p
= towlower_l (*p
, loc
);
3682 res
= wcscoll_l (p1
, p2
, loc
);
3688 if (! NILP (ignore_case
))
3689 for (int i
= 1; i
< 3; i
++)
3691 wchar_t *p
= (i
== 1) ? p1
: p2
;
3697 res
= wcscoll (p1
, p2
);
3700 # ifndef HAVE_NEWLOCALE
3702 error ("Invalid locale or string for collation: %s", strerror (err
));
3705 error ("Invalid string for collation: %s", strerror (err
));
3711 #endif /* __STDC_ISO_10646__ */
3715 str_collate (Lisp_Object s1
, Lisp_Object s2
,
3716 Lisp_Object locale
, Lisp_Object ignore_case
)
3719 char *loc
= STRINGP (locale
) ? SSDATA (locale
) : NULL
;
3720 int res
, err
= errno
;
3723 res
= w32_compare_strings (SDATA (s1
), SDATA (s2
), loc
, !NILP (ignore_case
));
3725 error ("Invalid string for collation: %s", strerror (errno
));
3730 #endif /* WINDOWSNT */