1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2014 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/>. */
27 #endif /* HAVE_PWD_H */
35 #include "sysselect.h"
36 #include "blockinput.h"
38 #if defined DARWIN_OS || defined __FreeBSD__
39 # include <sys/sysctl.h>
43 /* Sparc/ARM machine/frame.h has 'struct frame' which conflicts with Emacs's
44 'struct frame', so rename it. */
45 # define frame freebsd_frame
46 # include <sys/user.h>
49 # include <sys/resource.h>
55 #define write sys_write
57 #define STDERR_FILENO fileno(GetStdHandle(STD_ERROR_HANDLE))
60 #endif /* not WINDOWSNT */
62 #include <sys/types.h>
66 /* Get SI_SRPC_DOMAIN, if it is available. */
67 #ifdef HAVE_SYS_SYSTEMINFO_H
68 #include <sys/systeminfo.h>
71 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
75 #include <sys/param.h>
82 #ifdef HAVE_SYS_UTSNAME_H
83 #include <sys/utsname.h>
85 #endif /* HAVE_SYS_UTSNAME_H */
90 #include "termhooks.h"
93 #include "dispextern.h"
95 #include "cm.h" /* for reset_sys_modes */
99 /* In process.h which conflicts with the local copy. */
101 int _cdecl
_spawnlp (int, const char *, const char *, ...);
102 int _cdecl
_getpid (void);
105 #include "syssignal.h"
108 static void emacs_get_tty (int, struct emacs_tty
*);
109 static int emacs_set_tty (int, struct emacs_tty
*, bool);
111 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
113 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
116 /* Declare here, including term.h is problematic on some systems. */
117 extern void tputs (const char *, int, int (*)(int));
119 static const int baud_convert
[] =
121 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
122 1800, 2400, 4800, 9600, 19200, 38400
126 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
128 /* Return the current working directory. Returns NULL on errors.
129 Any other returned value must be freed with free. This is used
130 only when get_current_dir_name is not defined on the system. */
132 get_current_dir_name (void)
135 char *pwd
= getenv ("PWD");
136 struct stat dotstat
, pwdstat
;
137 /* If PWD is accurate, use it instead of calling getcwd. PWD is
138 sometimes a nicer name, and using it may avoid a fatal error if a
139 parent directory is searchable but not readable. */
141 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
142 && stat (pwd
, &pwdstat
) == 0
143 && stat (".", &dotstat
) == 0
144 && dotstat
.st_ino
== pwdstat
.st_ino
145 && dotstat
.st_dev
== pwdstat
.st_dev
147 && strlen (pwd
) < MAXPATHLEN
151 buf
= malloc (strlen (pwd
) + 1);
158 size_t buf_size
= 1024;
159 buf
= malloc (buf_size
);
164 if (getcwd (buf
, buf_size
) == buf
)
168 int tmp_errno
= errno
;
174 buf
= realloc (buf
, buf_size
);
184 /* Discard pending input on all input descriptors. */
187 discard_tty_input (void)
190 struct emacs_tty buf
;
195 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
196 while (dos_keyread () != -1)
198 #else /* not MSDOS */
200 struct tty_display_info
*tty
;
201 for (tty
= tty_list
; tty
; tty
= tty
->next
)
203 if (tty
->input
) /* Is the device suspended? */
205 emacs_get_tty (fileno (tty
->input
), &buf
);
206 emacs_set_tty (fileno (tty
->input
), &buf
, 0);
210 #endif /* not MSDOS */
211 #endif /* not WINDOWSNT */
217 /* Arrange for character C to be read as the next input from
219 XXX What if we have multiple ttys?
225 if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
228 /* Should perhaps error if in batch mode */
230 ioctl (fileno (CURTTY()->input
), TIOCSTI
, &c
);
231 #else /* no TIOCSTI */
232 error ("Cannot stuff terminal input characters in this version of Unix");
233 #endif /* no TIOCSTI */
239 init_baud_rate (int fd
)
249 #else /* not DOS_NT */
254 emacs_ospeed
= cfgetospeed (&sg
);
255 #endif /* not DOS_NT */
258 baud_rate
= (emacs_ospeed
< ARRAYELTS (baud_convert
)
259 ? baud_convert
[emacs_ospeed
] : 9600);
268 /* Wait for the subprocess with process id CHILD to terminate or change status.
269 CHILD must be a child process that has not been reaped.
270 If STATUS is non-null, store the waitpid-style exit status into *STATUS
271 and tell wait_reading_process_output that it needs to look around.
272 Use waitpid-style OPTIONS when waiting.
273 If INTERRUPTIBLE, this function is interruptible by a signal.
275 Return CHILD if successful, 0 if no status is available;
276 the latter is possible only when options & NOHANG. */
278 get_child_status (pid_t child
, int *status
, int options
, bool interruptible
)
282 /* Invoke waitpid only with a known process ID; do not invoke
283 waitpid with a nonpositive argument. Otherwise, Emacs might
284 reap an unwanted process by mistake. For example, invoking
285 waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
286 so that another thread running glib won't find them. */
289 while ((pid
= waitpid (child
, status
, options
)) < 0)
291 /* Check that CHILD is a child process that has not been reaped,
292 and that STATUS and OPTIONS are valid. Otherwise abort,
293 as continuing after this internal error could cause Emacs to
294 become confused and kill innocent-victim processes. */
298 /* Note: the MS-Windows emulation of waitpid calls QUIT
304 /* If successful and status is requested, tell wait_reading_process_output
305 that it needs to wake up and look around. */
306 if (pid
&& status
&& input_available_clear_time
)
307 *input_available_clear_time
= make_timespec (0, 0);
312 /* Wait for the subprocess with process id CHILD to terminate.
313 CHILD must be a child process that has not been reaped.
314 If STATUS is non-null, store the waitpid-style exit status into *STATUS
315 and tell wait_reading_process_output that it needs to look around.
316 If INTERRUPTIBLE, this function is interruptible by a signal. */
318 wait_for_termination (pid_t child
, int *status
, bool interruptible
)
320 get_child_status (child
, status
, 0, interruptible
);
323 /* Report whether the subprocess with process id CHILD has changed status.
324 Termination counts as a change of status.
325 CHILD must be a child process that has not been reaped.
326 If STATUS is non-null, store the waitpid-style exit status into *STATUS
327 and tell wait_reading_process_output that it needs to look around.
328 Use waitpid-style OPTIONS to check status, but do not wait.
330 Return CHILD if successful, 0 if no status is available because
331 the process's state has not changed. */
333 child_status_changed (pid_t child
, int *status
, int options
)
335 return get_child_status (child
, status
, WNOHANG
| options
, 0);
339 /* Set up the terminal at the other end of a pseudo-terminal that
340 we will be controlling an inferior through.
341 It should not echo or do line-editing, since that is done
342 in Emacs. No padding needed for insertion into an Emacs buffer. */
345 child_setup_tty (int out
)
350 emacs_get_tty (out
, &s
);
351 s
.main
.c_oflag
|= OPOST
; /* Enable output postprocessing */
352 s
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL on output */
354 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
355 Some versions of GNU Hurd do not have FFDLY? */
357 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
|FFDLY
);
358 /* No output delays */
360 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
);
361 /* No output delays */
364 s
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
365 s
.main
.c_lflag
|= ISIG
; /* Enable signals */
367 s
.main
.c_iflag
&= ~IUCLC
; /* Disable downcasing on input. */
370 s
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
373 s
.main
.c_oflag
&= ~OLCUC
; /* Disable upcasing on output. */
375 s
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
376 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CSIZE
) | CS8
; /* Don't strip 8th bit */
377 s
.main
.c_cc
[VERASE
] = CDISABLE
; /* disable erase processing */
378 s
.main
.c_cc
[VKILL
] = CDISABLE
; /* disable kill processing */
381 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
384 #ifdef SIGNALS_VIA_CHARACTERS
385 /* the QUIT and INTR character are used in process_send_signal
386 so set them here to something useful. */
387 if (s
.main
.c_cc
[VQUIT
] == CDISABLE
)
388 s
.main
.c_cc
[VQUIT
] = '\\'&037; /* Control-\ */
389 if (s
.main
.c_cc
[VINTR
] == CDISABLE
)
390 s
.main
.c_cc
[VINTR
] = 'C'&037; /* Control-C */
391 #endif /* not SIGNALS_VIA_CHARACTERS */
394 /* Also, PTY overloads NUL and BREAK.
395 don't ignore break, but don't signal either, so it looks like NUL. */
396 s
.main
.c_iflag
&= ~IGNBRK
;
397 s
.main
.c_iflag
&= ~BRKINT
;
398 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
399 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
400 would force it to 0377. That looks like duplicated code. */
401 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
404 /* We originally enabled ICANON (and set VEOF to 04), and then had
405 process.c send additional EOF chars to flush the output when faced
406 with long lines, but this leads to weird effects when the
407 subprocess has disabled ICANON and ends up seeing those spurious
408 extra EOFs. So we don't send EOFs any more in
409 process.c:send_process. First we tried to disable ICANON by
410 default, so if a subsprocess sets up ICANON, it's his problem (or
411 the Elisp package that talks to it) to deal with lines that are
412 too long. But this disables some features, such as the ability
413 to send EOF signals. So we re-enabled ICANON but there is no
414 more "send eof to flush" going on (which is wrong and unportable
415 in itself). The correct way to handle too much output is to
416 buffer what could not be written and then write it again when
417 select returns ok for writing. This has it own set of
418 problems. Write is now asynchronous, is that a problem? How much
419 do we buffer, and what do we do when that limit is reached? */
421 s
.main
.c_lflag
|= ICANON
; /* Enable line editing and eof processing */
422 s
.main
.c_cc
[VEOF
] = 'D'&037; /* Control-D */
423 #if 0 /* These settings only apply to non-ICANON mode. */
424 s
.main
.c_cc
[VMIN
] = 1;
425 s
.main
.c_cc
[VTIME
] = 0;
428 emacs_set_tty (out
, &s
, 0);
429 #endif /* not WINDOWSNT */
431 #endif /* not MSDOS */
434 /* Record a signal code and the action for it. */
438 struct sigaction action
;
441 static void save_signal_handlers (struct save_signal
*);
442 static void restore_signal_handlers (struct save_signal
*);
444 /* Suspend the Emacs process; give terminal to its superior. */
452 /* On a system where suspending is not implemented,
453 instead fork a subshell and let it talk directly to the terminal
460 /* Fork a subshell. */
465 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
468 char oldwd
[MAXPATHLEN
+1]; /* Fixed length is safe on MSDOS. */
470 char oldwd
[MAX_UTF8_PATH
];
475 struct save_signal saved_handlers
[5];
476 char *str
= SSDATA (encode_current_directory ());
482 char *volatile str_volatile
= str
;
489 error ("Can't spawn subshell");
491 saved_handlers
[0].code
= SIGINT
;
492 saved_handlers
[1].code
= SIGQUIT
;
493 saved_handlers
[2].code
= SIGTERM
;
495 saved_handlers
[3].code
= SIGIO
;
496 saved_handlers
[4].code
= 0;
498 saved_handlers
[3].code
= 0;
502 save_signal_handlers (saved_handlers
);
509 #ifdef DOS_NT /* MW, Aug 1993 */
510 getcwd (oldwd
, sizeof oldwd
);
512 sh
= egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
515 sh
= egetenv ("SHELL");
519 /* Use our buffer's default directory for the subshell. */
520 if (chdir (str
) != 0)
524 _exit (EXIT_CANCELED
);
528 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
530 char *epwd
= getenv ("PWD");
531 char old_pwd
[MAXPATHLEN
+1+4];
533 /* If PWD is set, pass it with corrected value. */
536 strcpy (old_pwd
, epwd
);
537 setenv ("PWD", str
, 1);
540 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
542 putenv (old_pwd
); /* restore previous value */
544 #else /* not MSDOS */
546 /* Waits for process completion */
547 pid
= _spawnlp (_P_WAIT
, sh
, sh
, NULL
);
548 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
550 write (1, "Can't execute subshell", 22);
551 #else /* not WINDOWSNT */
552 execlp (sh
, sh
, (char *) 0);
554 _exit (errno
== ENOENT
? EXIT_ENOENT
: EXIT_CANNOT_INVOKE
);
555 #endif /* not WINDOWSNT */
556 #endif /* not MSDOS */
559 /* Do this now if we did not do it before. */
561 save_signal_handlers (saved_handlers
);
565 wait_for_termination (pid
, &status
, 0);
567 restore_signal_handlers (saved_handlers
);
571 save_signal_handlers (struct save_signal
*saved_handlers
)
573 while (saved_handlers
->code
)
575 struct sigaction action
;
576 emacs_sigaction_init (&action
, SIG_IGN
);
577 sigaction (saved_handlers
->code
, &action
, &saved_handlers
->action
);
583 restore_signal_handlers (struct save_signal
*saved_handlers
)
585 while (saved_handlers
->code
)
587 sigaction (saved_handlers
->code
, &saved_handlers
->action
, 0);
593 static int old_fcntl_flags
[FD_SETSIZE
];
600 old_fcntl_flags
[fd
] = fcntl (fd
, F_GETFL
, 0) & ~FASYNC
;
601 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
] | FASYNC
);
602 interrupts_deferred
= 0;
611 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
]);
625 sigemptyset (&unblocked
);
627 sigaddset (&unblocked
, SIGWINCH
);
629 sigaddset (&unblocked
, SIGIO
);
630 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
632 interrupts_deferred
= 0;
637 unrequest_sigio (void)
645 sigemptyset (&blocked
);
647 sigaddset (&blocked
, SIGWINCH
);
649 sigaddset (&blocked
, SIGIO
);
650 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
651 interrupts_deferred
= 1;
659 signal (SIGIO
, SIG_IGN
);
664 /* Saving and restoring the process group of Emacs's terminal. */
666 /* The process group of which Emacs was a member when it initially
669 If Emacs was in its own process group (i.e. inherited_pgroup ==
670 getpid ()), then we know we're running under a shell with job
671 control (Emacs would never be run as part of a pipeline).
674 If Emacs was not in its own process group, then we know we're
675 running under a shell (or a caller) that doesn't know how to
676 separate itself from Emacs (like sh). Emacs must be in its own
677 process group in order to receive SIGIO correctly. In this
678 situation, we put ourselves in our own pgroup, forcibly set the
679 tty's pgroup to our pgroup, and make sure to restore and reinstate
680 the tty's pgroup just like any other terminal setting. If
681 inherited_group was not the tty's pgroup, then we'll get a
682 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
683 it goes foreground in the future, which is what should happen. */
685 static pid_t inherited_pgroup
;
688 init_foreground_group (void)
690 pid_t pgrp
= getpgrp ();
691 inherited_pgroup
= getpid () == pgrp
? 0 : pgrp
;
694 /* Block and unblock SIGTTOU. */
697 block_tty_out_signal (sigset_t
*oldset
)
701 sigemptyset (&blocked
);
702 sigaddset (&blocked
, SIGTTOU
);
703 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
708 unblock_tty_out_signal (sigset_t
const *oldset
)
711 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
715 /* Safely set a controlling terminal FD's process group to PGID.
716 If we are not in the foreground already, POSIX requires tcsetpgrp
717 to deliver a SIGTTOU signal, which would stop us. This is an
718 annoyance, so temporarily ignore the signal.
720 In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
721 skip all this unless SIGTTOU is defined. */
723 tcsetpgrp_without_stopping (int fd
, pid_t pgid
)
728 block_tty_out_signal (&oldset
);
729 tcsetpgrp (fd
, pgid
);
730 unblock_tty_out_signal (&oldset
);
735 /* Split off the foreground process group to Emacs alone. When we are
736 in the foreground, but not started in our own process group,
737 redirect the tty device handle FD to point to our own process
738 group. FD must be the file descriptor of the controlling tty. */
740 narrow_foreground_group (int fd
)
742 if (inherited_pgroup
&& setpgid (0, 0) == 0)
743 tcsetpgrp_without_stopping (fd
, getpid ());
746 /* Set the tty to our original foreground group. */
748 widen_foreground_group (int fd
)
750 if (inherited_pgroup
&& setpgid (0, inherited_pgroup
) == 0)
751 tcsetpgrp_without_stopping (fd
, inherited_pgroup
);
754 /* Getting and setting emacs_tty structures. */
756 /* Set *TC to the parameters associated with the terminal FD,
757 or clear it if the parameters are not available. */
759 emacs_get_tty (int fd
, struct emacs_tty
*settings
)
761 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
763 /* We have those nifty POSIX tcmumbleattr functions. */
764 memset (&settings
->main
, 0, sizeof (settings
->main
));
765 tcgetattr (fd
, &settings
->main
);
770 /* Set the parameters of the tty on FD according to the contents of
771 *SETTINGS. If FLUSHP, discard input.
772 Return 0 if all went well, and -1 (setting errno) if anything failed. */
775 emacs_set_tty (int fd
, struct emacs_tty
*settings
, bool flushp
)
777 /* Set the primary parameters - baud rate, character size, etcetera. */
780 /* We have those nifty POSIX tcmumbleattr functions.
781 William J. Smith <wjs@wiis.wang.com> writes:
782 "POSIX 1003.1 defines tcsetattr to return success if it was
783 able to perform any of the requested actions, even if some
784 of the requested actions could not be performed.
785 We must read settings back to ensure tty setup properly.
786 AIX requires this to keep tty from hanging occasionally." */
787 /* This make sure that we don't loop indefinitely in here. */
788 for (i
= 0 ; i
< 10 ; i
++)
789 if (tcsetattr (fd
, flushp
? TCSAFLUSH
: TCSADRAIN
, &settings
->main
) < 0)
800 memset (&new, 0, sizeof (new));
801 /* Get the current settings, and see if they're what we asked for. */
802 tcgetattr (fd
, &new);
803 /* We cannot use memcmp on the whole structure here because under
804 * aix386 the termios structure has some reserved field that may
807 if ( new.c_iflag
== settings
->main
.c_iflag
808 && new.c_oflag
== settings
->main
.c_oflag
809 && new.c_cflag
== settings
->main
.c_cflag
810 && new.c_lflag
== settings
->main
.c_lflag
811 && memcmp (new.c_cc
, settings
->main
.c_cc
, NCCS
) == 0)
818 /* We have survived the tempest. */
825 static int old_fcntl_owner
[FD_SETSIZE
];
826 #endif /* F_SETOWN */
828 /* This may also be defined in stdio,
829 but if so, this does no harm,
830 and using the same name avoids wasting the other one's space. */
833 unsigned char _sobuf
[BUFSIZ
+8];
838 /* Initialize the terminal mode on all tty devices that are currently
842 init_all_sys_modes (void)
844 struct tty_display_info
*tty
;
845 for (tty
= tty_list
; tty
; tty
= tty
->next
)
846 init_sys_modes (tty
);
849 /* Initialize the terminal mode on the given tty device. */
852 init_sys_modes (struct tty_display_info
*tty_out
)
854 struct emacs_tty tty
;
855 Lisp_Object terminal
;
857 Vtty_erase_char
= Qnil
;
862 if (!tty_out
->output
)
863 return; /* The tty is suspended. */
865 narrow_foreground_group (fileno (tty_out
->input
));
867 if (! tty_out
->old_tty
)
868 tty_out
->old_tty
= xmalloc (sizeof *tty_out
->old_tty
);
870 emacs_get_tty (fileno (tty_out
->input
), tty_out
->old_tty
);
872 tty
= *tty_out
->old_tty
;
874 #if !defined (DOS_NT)
875 XSETINT (Vtty_erase_char
, tty
.main
.c_cc
[VERASE
]);
877 tty
.main
.c_iflag
|= (IGNBRK
); /* Ignore break condition */
878 tty
.main
.c_iflag
&= ~ICRNL
; /* Disable map of CR to NL on input */
879 #ifdef INLCR /* I'm just being cautious,
880 since I can't check how widespread INLCR is--rms. */
881 tty
.main
.c_iflag
&= ~INLCR
; /* Disable map of NL to CR on input */
884 tty
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
886 tty
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
887 tty
.main
.c_lflag
&= ~ICANON
; /* Disable erase/kill processing */
889 tty
.main
.c_lflag
&= ~IEXTEN
; /* Disable other editing characters. */
891 tty
.main
.c_lflag
|= ISIG
; /* Enable signals */
892 if (tty_out
->flow_control
)
894 tty
.main
.c_iflag
|= IXON
; /* Enable start/stop output control */
896 tty
.main
.c_iflag
&= ~IXANY
;
900 tty
.main
.c_iflag
&= ~IXON
; /* Disable start/stop output control */
901 tty
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL
903 tty
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
905 if (tty_out
->meta_key
)
907 tty
.main
.c_cflag
|= CS8
; /* allow 8th bit on input */
908 tty
.main
.c_cflag
&= ~PARENB
;/* Don't check parity */
912 XSETTERMINAL(terminal
, tty_out
->terminal
);
913 if (!NILP (Fcontrolling_tty_p (terminal
)))
915 tty
.main
.c_cc
[VINTR
] = quit_char
; /* C-g (usually) gives SIGINT */
916 /* Set up C-g for both SIGQUIT and SIGINT.
917 We don't know which we will get, but we handle both alike
918 so which one it really gives us does not matter. */
919 tty
.main
.c_cc
[VQUIT
] = quit_char
;
923 /* We normally don't get interrupt or quit signals from tty
924 devices other than our controlling terminal; therefore,
925 we must handle C-g as normal input. Unfortunately, this
926 means that the interrupt and quit feature must be
927 disabled on secondary ttys, or we would not even see the
930 Note that even though emacsclient could have special code
931 to pass SIGINT to Emacs, we should _not_ enable
932 interrupt/quit keys for emacsclient frames. This means
933 that we can't break out of loops in C code from a
934 secondary tty frame, but we can always decide what
935 display the C-g came from, which is more important from a
936 usability point of view. (Consider the case when two
937 people work together using the same Emacs instance.) */
938 tty
.main
.c_cc
[VINTR
] = CDISABLE
;
939 tty
.main
.c_cc
[VQUIT
] = CDISABLE
;
941 tty
.main
.c_cc
[VMIN
] = 1; /* Input should wait for at least 1 char */
942 tty
.main
.c_cc
[VTIME
] = 0; /* no matter how long that takes. */
944 tty
.main
.c_cc
[VSWTCH
] = CDISABLE
; /* Turn off shell layering use
949 tty
.main
.c_cc
[VSUSP
] = CDISABLE
; /* Turn off handling of C-z. */
952 tty
.main
.c_cc
[V_DSUSP
] = CDISABLE
; /* Turn off handling of C-y. */
954 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
955 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
958 tty
.main
.c_cc
[VLNEXT
] = CDISABLE
;
961 tty
.main
.c_cc
[VREPRINT
] = CDISABLE
;
962 #endif /* VREPRINT */
964 tty
.main
.c_cc
[VWERASE
] = CDISABLE
;
967 tty
.main
.c_cc
[VDISCARD
] = CDISABLE
;
968 #endif /* VDISCARD */
970 if (tty_out
->flow_control
)
973 tty
.main
.c_cc
[VSTART
] = '\021';
976 tty
.main
.c_cc
[VSTOP
] = '\023';
982 tty
.main
.c_cc
[VSTART
] = CDISABLE
;
985 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
990 tty
.main
.c_cc
[VSTRT
] = CDISABLE
;
991 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
992 tty
.main
.c_cc
[VSUSP
] = CDISABLE
;
993 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
994 if (tty_out
->flow_control
)
997 tty
.main
.c_cc
[VSTART
] = '\021';
1000 tty
.main
.c_cc
[VSTOP
] = '\023';
1003 /* Also, PTY overloads NUL and BREAK.
1004 don't ignore break, but don't signal either, so it looks like NUL.
1005 This really serves a purpose only if running in an XTERM window
1006 or via TELNET or the like, but does no harm elsewhere. */
1007 tty
.main
.c_iflag
&= ~IGNBRK
;
1008 tty
.main
.c_iflag
&= ~BRKINT
;
1010 #endif /* not DOS_NT */
1012 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1013 if (!tty_out
->term_initted
)
1014 internal_terminal_init ();
1015 dos_ttraw (tty_out
);
1018 emacs_set_tty (fileno (tty_out
->input
), &tty
, 0);
1020 /* This code added to insure that, if flow-control is not to be used,
1021 we have an unlocked terminal at the start. */
1024 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TCXONC
, 1);
1027 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TIOCSTART
, 0);
1030 #if !defined (DOS_NT)
1032 if (!tty_out
->flow_control
) tcflow (fileno (tty_out
->input
), TCOON
);
1037 if (interrupt_input
)
1039 old_fcntl_owner
[fileno (tty_out
->input
)] =
1040 fcntl (fileno (tty_out
->input
), F_GETOWN
, 0);
1041 fcntl (fileno (tty_out
->input
), F_SETOWN
, getpid ());
1042 init_sigio (fileno (tty_out
->input
));
1044 if (gpm_tty
== tty_out
)
1046 /* Arrange for mouse events to give us SIGIO signals. */
1047 fcntl (gpm_fd
, F_SETOWN
, getpid ());
1048 fcntl (gpm_fd
, F_SETFL
, fcntl (gpm_fd
, F_GETFL
, 0) | O_NONBLOCK
);
1049 init_sigio (gpm_fd
);
1051 #endif /* HAVE_GPM */
1053 #endif /* F_GETOWN */
1056 /* This symbol is defined on recent USG systems.
1057 Someone says without this call USG won't really buffer the file
1058 even with a call to setbuf. */
1059 setvbuf (tty_out
->output
, (char *) _sobuf
, _IOFBF
, sizeof _sobuf
);
1061 setbuf (tty_out
->output
, (char *) _sobuf
);
1064 if (tty_out
->terminal
->set_terminal_modes_hook
)
1065 tty_out
->terminal
->set_terminal_modes_hook (tty_out
->terminal
);
1067 if (!tty_out
->term_initted
)
1069 Lisp_Object tail
, frame
;
1070 FOR_EACH_FRAME (tail
, frame
)
1072 /* XXX This needs to be revised. */
1073 if (FRAME_TERMCAP_P (XFRAME (frame
))
1074 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1075 init_frame_faces (XFRAME (frame
));
1079 if (tty_out
->term_initted
&& no_redraw_on_reenter
)
1081 /* We used to call "direct_output_forward_char(0)" here,
1082 but it's not clear why, since it may not do anything anyway. */
1086 Lisp_Object tail
, frame
;
1088 FOR_EACH_FRAME (tail
, frame
)
1090 if ((FRAME_TERMCAP_P (XFRAME (frame
))
1091 || FRAME_MSDOS_P (XFRAME (frame
)))
1092 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1093 FRAME_GARBAGED_P (XFRAME (frame
)) = 1;
1097 tty_out
->term_initted
= 1;
1100 /* Return true if safe to use tabs in output.
1101 At the time this is called, init_sys_modes has not been done yet. */
1104 tabs_safe_p (int fd
)
1106 struct emacs_tty etty
;
1108 emacs_get_tty (fd
, &etty
);
1111 return ((etty
.main
.c_oflag
& TABDLY
) != TAB3
);
1112 #else /* not TABDLY */
1114 #endif /* not TABDLY */
1120 /* Get terminal size from system.
1121 Store number of lines into *HEIGHTP and width into *WIDTHP.
1122 We store 0 if there's no valid information. */
1125 get_tty_size (int fd
, int *widthp
, int *heightp
)
1127 #if defined TIOCGWINSZ
1130 struct winsize size
;
1132 if (ioctl (fd
, TIOCGWINSZ
, &size
) == -1)
1133 *widthp
= *heightp
= 0;
1136 *widthp
= size
.ws_col
;
1137 *heightp
= size
.ws_row
;
1140 #elif defined TIOCGSIZE
1142 /* SunOS - style. */
1143 struct ttysize size
;
1145 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1146 *widthp
= *heightp
= 0;
1149 *widthp
= size
.ts_cols
;
1150 *heightp
= size
.ts_lines
;
1153 #elif defined WINDOWSNT
1155 CONSOLE_SCREEN_BUFFER_INFO info
;
1156 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE
), &info
))
1158 *widthp
= info
.srWindow
.Right
- info
.srWindow
.Left
+ 1;
1159 *heightp
= info
.srWindow
.Bottom
- info
.srWindow
.Top
+ 1;
1162 *widthp
= *heightp
= 0;
1166 *widthp
= ScreenCols ();
1167 *heightp
= ScreenRows ();
1169 #else /* system doesn't know size */
1177 /* Set the logical window size associated with descriptor FD
1178 to HEIGHT and WIDTH. This is used mainly with ptys.
1179 Return a negative value on failure. */
1182 set_window_size (int fd
, int height
, int width
)
1187 struct winsize size
;
1188 size
.ws_row
= height
;
1189 size
.ws_col
= width
;
1191 return ioctl (fd
, TIOCSWINSZ
, &size
);
1196 /* SunOS - style. */
1197 struct ttysize size
;
1198 size
.ts_lines
= height
;
1199 size
.ts_cols
= width
;
1201 return ioctl (fd
, TIOCGSIZE
, &size
);
1204 #endif /* not SunOS-style */
1205 #endif /* not BSD-style */
1210 /* Prepare all terminal devices for exiting Emacs. */
1213 reset_all_sys_modes (void)
1215 struct tty_display_info
*tty
;
1216 for (tty
= tty_list
; tty
; tty
= tty
->next
)
1217 reset_sys_modes (tty
);
1220 /* Prepare the terminal for closing it; move the cursor to the
1221 bottom of the frame, turn off interrupt-driven I/O, etc. */
1224 reset_sys_modes (struct tty_display_info
*tty_out
)
1231 if (!tty_out
->term_initted
)
1234 if (!tty_out
->output
)
1235 return; /* The tty is suspended. */
1237 /* Go to and clear the last line of the terminal. */
1239 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1241 /* Code adapted from tty_clear_end_of_line. */
1242 if (tty_out
->TS_clr_line
)
1244 emacs_tputs (tty_out
, tty_out
->TS_clr_line
, 1, cmputc
);
1247 { /* have to do it the hard way */
1249 tty_turn_off_insert (tty_out
);
1251 for (i
= curX (tty_out
); i
< FrameCols (tty_out
) - 1; i
++)
1253 fputc (' ', tty_out
->output
);
1257 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1258 fflush (tty_out
->output
);
1260 if (tty_out
->terminal
->reset_terminal_modes_hook
)
1261 tty_out
->terminal
->reset_terminal_modes_hook (tty_out
->terminal
);
1263 /* Avoid possible loss of output when changing terminal modes. */
1264 while (fdatasync (fileno (tty_out
->output
)) != 0 && errno
== EINTR
)
1269 if (interrupt_input
)
1271 reset_sigio (fileno (tty_out
->input
));
1272 fcntl (fileno (tty_out
->input
), F_SETOWN
,
1273 old_fcntl_owner
[fileno (tty_out
->input
)]);
1275 #endif /* F_SETOWN */
1276 fcntl (fileno (tty_out
->input
), F_SETFL
,
1277 fcntl (fileno (tty_out
->input
), F_GETFL
, 0) & ~O_NONBLOCK
);
1280 if (tty_out
->old_tty
)
1281 while (emacs_set_tty (fileno (tty_out
->input
),
1282 tty_out
->old_tty
, 0) < 0 && errno
== EINTR
)
1285 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1289 widen_foreground_group (fileno (tty_out
->input
));
1294 /* Set up the proper status flags for use of a pty. */
1299 /* I'm told that TOICREMOTE does not mean control chars
1300 "can't be sent" but rather that they don't have
1301 input-editing or signaling effects.
1302 That should be good, because we have other ways
1303 to do those things in Emacs.
1304 However, telnet mode seems not to work on 4.2.
1305 So TIOCREMOTE is turned off now. */
1307 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1308 will hang. In particular, the "timeout" feature (which
1309 causes a read to return if there is no data available)
1310 does this. Also it is known that telnet mode will hang
1311 in such a way that Emacs must be stopped (perhaps this
1312 is the same problem).
1314 If TIOCREMOTE is turned off, then there is a bug in
1315 hp-ux which sometimes loses data. Apparently the
1316 code which blocks the master process when the internal
1317 buffer fills up does not work. Other than this,
1318 though, everything else seems to work fine.
1320 Since the latter lossage is more benign, we may as well
1321 lose that way. -- cph */
1323 #if defined (UNIX98_PTYS)
1326 ioctl (fd
, FIONBIO
, &on
);
1331 #endif /* HAVE_PTYS */
1334 #include <sys/socket.h>
1336 #endif /* HAVE_SOCKETS */
1339 #ifndef HAVE_H_ERRNO
1342 #endif /* TRY_AGAIN */
1345 init_system_name (void)
1347 #ifndef HAVE_GETHOSTNAME
1350 Vsystem_name
= build_string (uts
.nodename
);
1351 #else /* HAVE_GETHOSTNAME */
1352 char *hostname_alloc
= NULL
;
1353 char hostname_buf
[256];
1354 ptrdiff_t hostname_size
= sizeof hostname_buf
;
1355 char *hostname
= hostname_buf
;
1357 /* Try to get the host name; if the buffer is too short, try
1358 again. Apparently, the only indication gethostname gives of
1359 whether the buffer was large enough is the presence or absence
1360 of a '\0' in the string. Eech. */
1363 gethostname (hostname
, hostname_size
- 1);
1364 hostname
[hostname_size
- 1] = '\0';
1366 /* Was the buffer large enough for the '\0'? */
1367 if (strlen (hostname
) < hostname_size
- 1)
1370 hostname
= hostname_alloc
= xpalloc (hostname_alloc
, &hostname_size
, 1,
1371 min (PTRDIFF_MAX
, SIZE_MAX
), 1);
1374 /* Turn the hostname into the official, fully-qualified hostname.
1375 Don't do this if we're going to dump; this can confuse system
1376 libraries on some machines and make the dumped emacs core dump. */
1379 #endif /* not CANNOT_DUMP */
1380 if (! strchr (hostname
, '.'))
1383 #ifdef HAVE_GETADDRINFO
1384 struct addrinfo
*res
;
1385 struct addrinfo hints
;
1388 memset (&hints
, 0, sizeof (hints
));
1389 hints
.ai_socktype
= SOCK_STREAM
;
1390 hints
.ai_flags
= AI_CANONNAME
;
1392 for (count
= 0;; count
++)
1394 if ((ret
= getaddrinfo (hostname
, NULL
, &hints
, &res
)) == 0
1395 || ret
!= EAI_AGAIN
)
1400 Fsleep_for (make_number (1), Qnil
);
1405 struct addrinfo
*it
= res
;
1408 char *fqdn
= it
->ai_canonname
;
1409 if (fqdn
&& strchr (fqdn
, '.')
1410 && strcmp (fqdn
, "localhost.localdomain") != 0)
1416 ptrdiff_t len
= strlen (it
->ai_canonname
);
1417 if (hostname_size
<= len
)
1419 hostname_size
= len
+ 1;
1420 hostname
= hostname_alloc
= xrealloc (hostname_alloc
,
1423 strcpy (hostname
, it
->ai_canonname
);
1427 #else /* !HAVE_GETADDRINFO */
1429 for (count
= 0;; count
++)
1435 hp
= gethostbyname (hostname
);
1437 if (! (hp
== 0 && h_errno
== TRY_AGAIN
))
1444 Fsleep_for (make_number (1), Qnil
);
1449 char *fqdn
= (char *) hp
->h_name
;
1451 if (!strchr (fqdn
, '.'))
1453 /* We still don't have a fully qualified domain name.
1454 Try to find one in the list of alternate names */
1455 char **alias
= hp
->h_aliases
;
1457 && (!strchr (*alias
, '.')
1458 || !strcmp (*alias
, "localhost.localdomain")))
1465 #endif /* !HAVE_GETADDRINFO */
1467 #endif /* HAVE_SOCKETS */
1468 Vsystem_name
= build_string (hostname
);
1469 xfree (hostname_alloc
);
1470 #endif /* HAVE_GETHOSTNAME */
1473 for (p
= SSDATA (Vsystem_name
); *p
; p
++)
1474 if (*p
== ' ' || *p
== '\t')
1479 sigset_t empty_mask
;
1481 static struct sigaction process_fatal_action
;
1484 emacs_sigaction_flags (void)
1487 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1488 'select') to reset their timeout on some platforms (e.g.,
1489 HP-UX 11), which is not what we want. Also, when Emacs is
1490 interactive, we don't want SA_RESTART because we need to poll
1491 for pending input so we need long-running syscalls to be interrupted
1492 after a signal that sets pending_signals.
1494 Non-interactive keyboard input goes through stdio, where we
1495 always want restartable system calls. */
1502 /* Store into *ACTION a signal action suitable for Emacs, with handler
1505 emacs_sigaction_init (struct sigaction
*action
, signal_handler_t handler
)
1507 sigemptyset (&action
->sa_mask
);
1509 /* When handling a signal, block nonfatal system signals that are caught
1510 by Emacs. This makes race conditions less likely. */
1511 sigaddset (&action
->sa_mask
, SIGALRM
);
1513 sigaddset (&action
->sa_mask
, SIGCHLD
);
1516 sigaddset (&action
->sa_mask
, SIGDANGER
);
1518 #ifdef PROFILER_CPU_SUPPORT
1519 sigaddset (&action
->sa_mask
, SIGPROF
);
1522 sigaddset (&action
->sa_mask
, SIGWINCH
);
1524 if (! noninteractive
)
1526 sigaddset (&action
->sa_mask
, SIGINT
);
1527 sigaddset (&action
->sa_mask
, SIGQUIT
);
1529 sigaddset (&action
->sa_mask
, SIGIO
);
1533 action
->sa_handler
= handler
;
1534 action
->sa_flags
= emacs_sigaction_flags ();
1537 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1538 static pthread_t main_thread
;
1541 /* SIG has arrived at the current process. Deliver it to the main
1542 thread, which should handle it with HANDLER.
1544 If we are on the main thread, handle the signal SIG with HANDLER.
1545 Otherwise, redirect the signal to the main thread, blocking it from
1546 this thread. POSIX says any thread can receive a signal that is
1547 associated with a process, process group, or asynchronous event.
1548 On GNU/Linux that is not true, but for other systems (FreeBSD at
1551 deliver_process_signal (int sig
, signal_handler_t handler
)
1553 /* Preserve errno, to avoid race conditions with signal handlers that
1554 might change errno. Races can occur even in single-threaded hosts. */
1555 int old_errno
= errno
;
1557 bool on_main_thread
= true;
1558 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1559 if (! pthread_equal (pthread_self (), main_thread
))
1562 sigemptyset (&blocked
);
1563 sigaddset (&blocked
, sig
);
1564 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1565 pthread_kill (main_thread
, sig
);
1566 on_main_thread
= false;
1575 /* Static location to save a fatal backtrace in a thread.
1576 FIXME: If two subsidiary threads fail simultaneously, the resulting
1577 backtrace may be garbage. */
1578 enum { BACKTRACE_LIMIT_MAX
= 500 };
1579 static void *thread_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
1580 static int thread_backtrace_npointers
;
1582 /* SIG has arrived at the current thread.
1583 If we are on the main thread, handle the signal SIG with HANDLER.
1584 Otherwise, this is a fatal error in the handling thread. */
1586 deliver_thread_signal (int sig
, signal_handler_t handler
)
1588 int old_errno
= errno
;
1590 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1591 if (! pthread_equal (pthread_self (), main_thread
))
1593 thread_backtrace_npointers
1594 = backtrace (thread_backtrace_buffer
, BACKTRACE_LIMIT_MAX
);
1595 sigaction (sig
, &process_fatal_action
, 0);
1596 pthread_kill (main_thread
, sig
);
1598 /* Avoid further damage while the main thread is exiting. */
1600 sigsuspend (&empty_mask
);
1608 #if !HAVE_DECL_SYS_SIGLIST
1610 # ifdef _sys_siglist
1611 # define sys_siglist _sys_siglist
1612 # elif HAVE_DECL___SYS_SIGLIST
1613 # define sys_siglist __sys_siglist
1615 # define sys_siglist my_sys_siglist
1616 static char const *sys_siglist
[NSIG
];
1621 # define sys_siglist_entries _sys_nsig
1623 # define sys_siglist_entries NSIG
1626 /* Handle bus errors, invalid instruction, etc. */
1628 handle_fatal_signal (int sig
)
1630 terminate_due_to_signal (sig
, 40);
1634 deliver_fatal_signal (int sig
)
1636 deliver_process_signal (sig
, handle_fatal_signal
);
1640 deliver_fatal_thread_signal (int sig
)
1642 deliver_thread_signal (sig
, handle_fatal_signal
);
1645 static _Noreturn
void
1646 handle_arith_signal (int sig
)
1649 sigemptyset (&blocked
);
1650 sigaddset (&blocked
, sig
);
1651 pthread_sigmask (SIG_UNBLOCK
, &blocked
, 0);
1652 xsignal0 (Qarith_error
);
1656 deliver_arith_signal (int sig
)
1658 deliver_thread_signal (sig
, handle_arith_signal
);
1663 /* Handler for SIGDANGER. */
1665 handle_danger_signal (int sig
)
1667 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1669 /* It might be unsafe to call do_auto_save now. */
1670 force_auto_save_soon ();
1674 deliver_danger_signal (int sig
)
1676 deliver_process_signal (sig
, handle_danger_signal
);
1680 /* Treat SIG as a terminating signal, unless it is already ignored and
1681 we are in --batch mode. Among other things, this makes nohup work. */
1683 maybe_fatal_sig (int sig
)
1685 bool catch_sig
= !noninteractive
;
1688 struct sigaction old_action
;
1689 sigaction (sig
, 0, &old_action
);
1690 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1693 sigaction (sig
, &process_fatal_action
, 0);
1697 init_signals (bool dumping
)
1699 struct sigaction thread_fatal_action
;
1700 struct sigaction action
;
1702 sigemptyset (&empty_mask
);
1704 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1705 main_thread
= pthread_self ();
1708 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1711 sys_siglist
[SIGABRT
] = "Aborted";
1713 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1715 sys_siglist
[SIGALRM
] = "Alarm clock";
1717 sys_siglist
[SIGBUS
] = "Bus error";
1720 sys_siglist
[SIGCHLD
] = "Child status changed";
1723 sys_siglist
[SIGCONT
] = "Continued";
1726 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1729 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1732 sys_siglist
[SIGEMT
] = "Emulation trap";
1734 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1736 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1739 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1741 sys_siglist
[SIGHUP
] = "Hangup";
1742 sys_siglist
[SIGILL
] = "Illegal instruction";
1743 sys_siglist
[SIGINT
] = "Interrupt";
1745 sys_siglist
[SIGIO
] = "I/O possible";
1748 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1751 sys_siglist
[SIGIOT
] = "IOT trap";
1753 sys_siglist
[SIGKILL
] = "Killed";
1755 sys_siglist
[SIGLOST
] = "Resource lost";
1758 sys_siglist
[SIGLWP
] = "SIGLWP";
1761 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1764 sys_siglist
[SIGWIND
] = "SIGPHONE";
1766 sys_siglist
[SIGPIPE
] = "Broken pipe";
1768 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1771 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1774 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1777 sys_siglist
[SIGPWR
] = "Power-fail restart";
1779 sys_siglist
[SIGQUIT
] = "Quit";
1781 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1784 sys_siglist
[SIGSAK
] = "Secure attention";
1786 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1788 sys_siglist
[SIGSOUND
] = "Sound completed";
1791 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1794 sys_siglist
[SIGSTP
] = "Stopped (user)";
1797 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1799 sys_siglist
[SIGTERM
] = "Terminated";
1801 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1804 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1807 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1810 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1813 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1816 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1819 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1822 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1825 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1828 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1831 sys_siglist
[SIGWINCH
] = "Window size changed";
1834 sys_siglist
[SIGWIND
] = "SIGWIND";
1837 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1840 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1843 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1845 /* Don't alter signal handlers if dumping. On some machines,
1846 changing signal handlers sets static data that would make signals
1847 fail to work right when the dumped Emacs is run. */
1851 sigfillset (&process_fatal_action
.sa_mask
);
1852 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1853 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1855 sigfillset (&thread_fatal_action
.sa_mask
);
1856 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1857 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1859 /* SIGINT may need special treatment on MS-Windows. See
1860 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1861 Please update the doc of kill-emacs, kill-emacs-hook, and
1862 NEWS if you change this. */
1864 maybe_fatal_sig (SIGHUP
);
1865 maybe_fatal_sig (SIGINT
);
1866 maybe_fatal_sig (SIGTERM
);
1868 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1869 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1870 to behave more like typical batch applications do. */
1871 if (! noninteractive
)
1872 signal (SIGPIPE
, SIG_IGN
);
1874 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1875 sigaction (SIGILL
, &thread_fatal_action
, 0);
1876 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1878 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1879 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1880 interpreter's floating point operations, so treat SIGFPE as an
1881 arith-error if it arises in the main thread. */
1882 if (IEEE_FLOATING_POINT
)
1883 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1886 emacs_sigaction_init (&action
, deliver_arith_signal
);
1887 sigaction (SIGFPE
, &action
, 0);
1891 add_user_signal (SIGUSR1
, "sigusr1");
1894 add_user_signal (SIGUSR2
, "sigusr2");
1896 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1898 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1901 sigaction (SIGORE
, &thread_fatal_action
, 0);
1904 sigaction (SIGUME
, &thread_fatal_action
, 0);
1907 sigaction (SIGDLK
, &process_fatal_action
, 0);
1910 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1913 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1916 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1919 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1921 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
1923 sigaction (SIGSYS
, &thread_fatal_action
, 0);
1925 sigaction (SIGTERM
, &process_fatal_action
, 0);
1927 signal (SIGPROF
, SIG_IGN
);
1930 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
1933 sigaction (SIGXCPU
, &process_fatal_action
, 0);
1936 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
1940 /* This just means available memory is getting low. */
1941 emacs_sigaction_init (&action
, deliver_danger_signal
);
1942 sigaction (SIGDANGER
, &action
, 0);
1945 /* AIX-specific signals. */
1947 sigaction (SIGGRANT
, &process_fatal_action
, 0);
1950 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
1953 sigaction (SIGMSG
, &process_fatal_action
, 0);
1956 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
1959 sigaction (SIGSAK
, &process_fatal_action
, 0);
1962 sigaction (SIGSOUND
, &process_fatal_action
, 0);
1965 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
1975 /* Figure out how many bits the system's random number generator uses.
1976 `random' and `lrand48' are assumed to return 31 usable bits.
1977 BSD `rand' returns a 31 bit value but the low order bits are unusable;
1978 so we'll shift it and treat it like the 15-bit USG `rand'. */
1982 # define RAND_BITS 31
1983 # else /* !HAVE_RANDOM */
1984 # ifdef HAVE_LRAND48
1985 # define RAND_BITS 31
1986 # define random lrand48
1987 # else /* !HAVE_LRAND48 */
1988 # define RAND_BITS 15
1989 # if RAND_MAX == 32767
1990 # define random rand
1991 # else /* RAND_MAX != 32767 */
1992 # if RAND_MAX == 2147483647
1993 # define random() (rand () >> 16)
1994 # else /* RAND_MAX != 2147483647 */
1996 # define random rand
1998 # define random() (rand () >> 16)
2000 # endif /* RAND_MAX != 2147483647 */
2001 # endif /* RAND_MAX != 32767 */
2002 # endif /* !HAVE_LRAND48 */
2003 # endif /* !HAVE_RANDOM */
2004 #endif /* !RAND_BITS */
2007 seed_random (void *seed
, ptrdiff_t seed_size
)
2009 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
2010 unsigned int arg
= 0;
2014 unsigned char *argp
= (unsigned char *) &arg
;
2015 unsigned char *seedp
= seed
;
2017 for (i
= 0; i
< seed_size
; i
++)
2018 argp
[i
% sizeof arg
] ^= seedp
[i
];
2022 # ifdef HAVE_LRAND48
2033 struct timespec t
= current_timespec ();
2034 uintmax_t v
= getpid () ^ t
.tv_sec
^ t
.tv_nsec
;
2035 seed_random (&v
, sizeof v
);
2039 * Return a nonnegative random integer out of whatever we've got.
2040 * It contains enough bits to make a random (signed) Emacs fixnum.
2041 * This suffices even for a 64-bit architecture with a 15-bit rand.
2048 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2049 val
= (random () ^ (val
<< RAND_BITS
)
2050 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2051 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2052 return val
& INTMASK
;
2055 #ifndef HAVE_SNPRINTF
2056 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2058 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2060 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2061 ptrdiff_t nbytes
= size
- 1;
2066 va_start (ap
, format
);
2067 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2071 if (nbytes
== size
- 1)
2073 /* Calculate the length of the string that would have been created
2074 had the buffer been large enough. */
2075 char stackbuf
[4000];
2077 ptrdiff_t bsize
= sizeof stackbuf
;
2078 va_start (ap
, format
);
2079 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2085 if (INT_MAX
< nbytes
)
2098 /* If a backtrace is available, output the top lines of it to stderr.
2099 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2100 This function may be called from a signal handler, so it should
2101 not invoke async-unsafe functions like malloc. */
2103 emacs_backtrace (int backtrace_limit
)
2105 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2106 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2110 if (thread_backtrace_npointers
)
2112 buffer
= thread_backtrace_buffer
;
2113 npointers
= thread_backtrace_npointers
;
2117 buffer
= main_backtrace_buffer
;
2118 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2123 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2124 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2125 if (bounded_limit
< npointers
)
2126 emacs_write (STDERR_FILENO
, "...\n", 4);
2134 terminate_due_to_signal (SIGABRT
, 40);
2138 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2139 Arrange for subprograms to not inherit the file descriptor.
2140 Prefer a method that is multithread-safe, if available.
2141 Do not fail merely because the open was interrupted by a signal.
2142 Allow the user to quit. */
2145 emacs_open (const char *file
, int oflags
, int mode
)
2148 oflags
|= O_CLOEXEC
;
2149 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2151 if (! O_CLOEXEC
&& 0 <= fd
)
2152 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2156 /* Open FILE as a stream for Emacs use, with mode MODE.
2157 Act like emacs_open with respect to threads, signals, and quits. */
2160 emacs_fopen (char const *file
, char const *mode
)
2162 int fd
, omode
, oflags
;
2164 char const *m
= mode
;
2168 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2169 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2170 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2171 default: emacs_abort ();
2177 case '+': omode
= O_RDWR
; break;
2178 case 'b': bflag
= O_BINARY
; break;
2179 case 't': bflag
= O_TEXT
; break;
2180 default: /* Ignore. */ break;
2183 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2184 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2187 /* Create a pipe for Emacs use. */
2190 emacs_pipe (int fd
[2])
2195 int result
= pipe2 (fd
, O_CLOEXEC
);
2196 if (! O_CLOEXEC
&& result
== 0)
2198 fcntl (fd
[0], F_SETFD
, FD_CLOEXEC
);
2199 fcntl (fd
[1], F_SETFD
, FD_CLOEXEC
);
2205 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2206 For the background behind this mess, please see Austin Group defect 529
2207 <http://austingroupbugs.net/view.php?id=529>. */
2209 #ifndef POSIX_CLOSE_RESTART
2210 # define POSIX_CLOSE_RESTART 1
2212 posix_close (int fd
, int flag
)
2214 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2215 eassert (flag
== POSIX_CLOSE_RESTART
);
2217 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2218 on a system that does not define POSIX_CLOSE_RESTART.
2220 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2221 closed, and retrying the close could inadvertently close a file
2222 descriptor allocated by some other thread. In other systems
2223 (e.g., HP/UX) FD is not closed. And in still other systems
2224 (e.g., OS X, Solaris), maybe FD is closed, maybe not, and in a
2225 multithreaded program there can be no way to tell.
2227 So, in this case, pretend that the close succeeded. This works
2228 well on systems like GNU/Linux that close FD. Although it may
2229 leak a file descriptor on other systems, the leak is unlikely and
2230 it's better to leak than to close a random victim. */
2231 return close (fd
) == 0 || errno
== EINTR
? 0 : -1;
2235 /* Close FD, retrying if interrupted. If successful, return 0;
2236 otherwise, return -1 and set errno to a non-EINTR value. Consider
2237 an EINPROGRESS error to be successful, as that's merely a signal
2238 arriving. FD is always closed when this function returns, even
2241 Do not call this function if FD is nonnegative and might already be closed,
2242 as that might close an innocent victim opened by some other thread. */
2245 emacs_close (int fd
)
2249 int r
= posix_close (fd
, POSIX_CLOSE_RESTART
);
2252 if (!POSIX_CLOSE_RESTART
|| errno
!= EINTR
)
2254 eassert (errno
!= EBADF
|| fd
< 0);
2255 return errno
== EINPROGRESS
? 0 : r
;
2260 /* Maximum number of bytes to read or write in a single system call.
2261 This works around a serious bug in Linux kernels before 2.6.16; see
2262 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2263 It's likely to work around similar bugs in other operating systems, so do it
2264 on all platforms. Round INT_MAX down to a page size, with the conservative
2265 assumption that page sizes are at most 2**18 bytes (any kernel with a
2266 page size larger than that shouldn't have the bug). */
2267 #ifndef MAX_RW_COUNT
2268 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2271 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2272 Return the number of bytes read, which might be less than NBYTE.
2273 On error, set errno and return -1. */
2275 emacs_read (int fildes
, void *buf
, ptrdiff_t nbyte
)
2279 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2280 passes a size that large to emacs_read. */
2282 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2283 && (errno
== EINTR
))
2288 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2289 or if a partial write occurs. If interrupted, process pending
2290 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2291 errno if this is less than NBYTE. */
2293 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2294 bool process_signals
)
2296 ptrdiff_t bytes_written
= 0;
2300 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2306 /* I originally used `QUIT' but that might causes files to
2307 be truncated if you hit C-g in the middle of it. --Stef */
2308 if (process_signals
&& pending_signals
)
2309 process_pending_signals ();
2321 return bytes_written
;
2324 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2325 interrupted or if a partial write occurs. Return the number of
2326 bytes written, setting errno if this is less than NBYTE. */
2328 emacs_write (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2330 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2333 /* Like emacs_write, but also process pending signals if interrupted. */
2335 emacs_write_sig (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2337 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2340 /* Write a diagnostic to standard error that contains MESSAGE and a
2341 string derived from errno. Preserve errno. Do not buffer stderr.
2342 Do not process pending signals if interrupted. */
2344 emacs_perror (char const *message
)
2347 char const *error_string
= strerror (err
);
2348 char const *command
= (initial_argv
&& initial_argv
[0]
2349 ? initial_argv
[0] : "emacs");
2350 /* Write it out all at once, if it's short; this is less likely to
2351 be interleaved with other output. */
2353 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2354 command
, message
, error_string
);
2355 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2356 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2359 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2360 emacs_write (STDERR_FILENO
, ": ", 2);
2361 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2362 emacs_write (STDERR_FILENO
, ": ", 2);
2363 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2364 emacs_write (STDERR_FILENO
, "\n", 1);
2369 /* Return a struct timeval that is roughly equivalent to T.
2370 Use the least timeval not less than T.
2371 Return an extremal value if the result would overflow. */
2373 make_timeval (struct timespec t
)
2376 tv
.tv_sec
= t
.tv_sec
;
2377 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2379 if (t
.tv_nsec
% 1000 != 0)
2381 if (tv
.tv_usec
< 999999)
2383 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2393 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2394 ATIME and MTIME, respectively.
2395 FD must be either negative -- in which case it is ignored --
2396 or a file descriptor that is open on FILE.
2397 If FD is nonnegative, then FILE can be NULL. */
2399 set_file_times (int fd
, const char *filename
,
2400 struct timespec atime
, struct timespec mtime
)
2402 struct timespec timespec
[2];
2403 timespec
[0] = atime
;
2404 timespec
[1] = mtime
;
2405 return fdutimens (fd
, filename
, timespec
);
2408 /* Like strsignal, except async-signal-safe, and this function typically
2409 returns a string in the C locale rather than the current locale. */
2411 safe_strsignal (int code
)
2413 char const *signame
= 0;
2415 if (0 <= code
&& code
< sys_siglist_entries
)
2416 signame
= sys_siglist
[code
];
2418 signame
= "Unknown signal";
2424 /* For make-serial-process */
2426 serial_open (Lisp_Object port
)
2428 int fd
= emacs_open (SSDATA (port
), O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2430 report_file_error ("Opening serial port", port
);
2432 ioctl (fd
, TIOCEXCL
, (char *) 0);
2438 #if !defined (HAVE_CFMAKERAW)
2439 /* Workaround for targets which are missing cfmakeraw. */
2440 /* Pasted from man page. */
2442 cfmakeraw (struct termios
*termios_p
)
2444 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2445 termios_p
->c_oflag
&= ~OPOST
;
2446 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2447 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2448 termios_p
->c_cflag
|= CS8
;
2450 #endif /* !defined (HAVE_CFMAKERAW */
2452 #if !defined (HAVE_CFSETSPEED)
2453 /* Workaround for targets which are missing cfsetspeed. */
2455 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2457 return (cfsetispeed (termios_p
, vitesse
)
2458 + cfsetospeed (termios_p
, vitesse
));
2462 /* For serial-process-configure */
2464 serial_configure (struct Lisp_Process
*p
,
2465 Lisp_Object contact
)
2467 Lisp_Object childp2
= Qnil
;
2468 Lisp_Object tem
= Qnil
;
2469 struct termios attr
;
2471 char summary
[4] = "???"; /* This usually becomes "8N1". */
2473 childp2
= Fcopy_sequence (p
->childp
);
2475 /* Read port attributes and prepare default configuration. */
2476 err
= tcgetattr (p
->outfd
, &attr
);
2478 report_file_error ("Failed tcgetattr", Qnil
);
2480 #if defined (CLOCAL)
2481 attr
.c_cflag
|= CLOCAL
;
2484 attr
.c_cflag
|= CREAD
;
2487 /* Configure speed. */
2488 if (!NILP (Fplist_member (contact
, QCspeed
)))
2489 tem
= Fplist_get (contact
, QCspeed
);
2491 tem
= Fplist_get (p
->childp
, QCspeed
);
2493 err
= cfsetspeed (&attr
, XINT (tem
));
2495 report_file_error ("Failed cfsetspeed", tem
);
2496 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2498 /* Configure bytesize. */
2499 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2500 tem
= Fplist_get (contact
, QCbytesize
);
2502 tem
= Fplist_get (p
->childp
, QCbytesize
);
2504 tem
= make_number (8);
2506 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2507 error (":bytesize must be nil (8), 7, or 8");
2508 summary
[0] = XINT (tem
) + '0';
2509 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2510 attr
.c_cflag
&= ~CSIZE
;
2511 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2513 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2514 if (XINT (tem
) != 8)
2515 error ("Bytesize cannot be changed");
2517 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2519 /* Configure parity. */
2520 if (!NILP (Fplist_member (contact
, QCparity
)))
2521 tem
= Fplist_get (contact
, QCparity
);
2523 tem
= Fplist_get (p
->childp
, QCparity
);
2524 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2525 error (":parity must be nil (no parity), `even', or `odd'");
2526 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2527 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2528 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2533 else if (EQ (tem
, Qeven
))
2536 attr
.c_cflag
|= PARENB
;
2537 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2539 else if (EQ (tem
, Qodd
))
2542 attr
.c_cflag
|= (PARENB
| PARODD
);
2543 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2546 /* Don't error on no parity, which should be set by cfmakeraw. */
2548 error ("Parity cannot be configured");
2550 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2552 /* Configure stopbits. */
2553 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2554 tem
= Fplist_get (contact
, QCstopbits
);
2556 tem
= Fplist_get (p
->childp
, QCstopbits
);
2558 tem
= make_number (1);
2560 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2561 error (":stopbits must be nil (1 stopbit), 1, or 2");
2562 summary
[2] = XINT (tem
) + '0';
2563 #if defined (CSTOPB)
2564 attr
.c_cflag
&= ~CSTOPB
;
2565 if (XINT (tem
) == 2)
2566 attr
.c_cflag
|= CSTOPB
;
2568 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2569 if (XINT (tem
) != 1)
2570 error ("Stopbits cannot be configured");
2572 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2574 /* Configure flowcontrol. */
2575 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2576 tem
= Fplist_get (contact
, QCflowcontrol
);
2578 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2579 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2580 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2581 #if defined (CRTSCTS)
2582 attr
.c_cflag
&= ~CRTSCTS
;
2584 #if defined (CNEW_RTSCTS)
2585 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2587 #if defined (IXON) && defined (IXOFF)
2588 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2592 /* Already configured. */
2594 else if (EQ (tem
, Qhw
))
2596 #if defined (CRTSCTS)
2597 attr
.c_cflag
|= CRTSCTS
;
2598 #elif defined (CNEW_RTSCTS)
2599 attr
.c_cflag
|= CNEW_RTSCTS
;
2601 error ("Hardware flowcontrol (RTS/CTS) not supported");
2604 else if (EQ (tem
, Qsw
))
2606 #if defined (IXON) && defined (IXOFF)
2607 attr
.c_iflag
|= (IXON
| IXOFF
);
2609 error ("Software flowcontrol (XON/XOFF) not supported");
2612 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2614 /* Activate configuration. */
2615 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2617 report_file_error ("Failed tcsetattr", Qnil
);
2619 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2620 pset_childp (p
, childp2
);
2622 #endif /* not DOS_NT */
2624 /* System depended enumeration of and access to system processes a-la ps(1). */
2628 /* Process enumeration and access via /proc. */
2631 list_system_processes (void)
2633 Lisp_Object procdir
, match
, proclist
, next
;
2634 struct gcpro gcpro1
, gcpro2
;
2635 register Lisp_Object tail
;
2637 GCPRO2 (procdir
, match
);
2638 /* For every process on the system, there's a directory in the
2639 "/proc" pseudo-directory whose name is the numeric ID of that
2641 procdir
= build_string ("/proc");
2642 match
= build_string ("[0-9]+");
2643 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2645 /* `proclist' gives process IDs as strings. Destructively convert
2646 each string into a number. */
2647 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2650 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2654 /* directory_files_internal returns the files in reverse order; undo
2656 proclist
= Fnreverse (proclist
);
2660 #elif defined DARWIN_OS || defined __FreeBSD__
2663 list_system_processes (void)
2666 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2668 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2671 struct kinfo_proc
*procs
;
2674 struct gcpro gcpro1
;
2675 Lisp_Object proclist
= Qnil
;
2677 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2680 procs
= xmalloc (len
);
2681 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2688 len
/= sizeof (struct kinfo_proc
);
2689 for (i
= 0; i
< len
; i
++)
2692 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2694 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2704 /* The WINDOWSNT implementation is in w32.c.
2705 The MSDOS implementation is in dosfns.c. */
2706 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2709 list_system_processes (void)
2714 #endif /* !defined (WINDOWSNT) */
2716 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2717 static struct timespec
2718 time_from_jiffies (unsigned long long tval
, long hz
)
2720 unsigned long long s
= tval
/ hz
;
2721 unsigned long long frac
= tval
% hz
;
2724 if (TYPE_MAXIMUM (time_t) < s
)
2726 if (LONG_MAX
- 1 <= ULLONG_MAX
/ TIMESPEC_RESOLUTION
2727 || frac
<= ULLONG_MAX
/ TIMESPEC_RESOLUTION
)
2728 ns
= frac
* TIMESPEC_RESOLUTION
/ hz
;
2731 /* This is reachable only in the unlikely case that HZ * HZ
2732 exceeds ULLONG_MAX. It calculates an approximation that is
2733 guaranteed to be in range. */
2734 long hz_per_ns
= (hz
/ TIMESPEC_RESOLUTION
2735 + (hz
% TIMESPEC_RESOLUTION
!= 0));
2736 ns
= frac
/ hz_per_ns
;
2739 return make_timespec (s
, ns
);
2743 ltime_from_jiffies (unsigned long long tval
, long hz
)
2745 struct timespec t
= time_from_jiffies (tval
, hz
);
2746 return make_lisp_time (t
);
2749 static struct timespec
2753 struct timespec up
= make_timespec (0, 0);
2756 fup
= emacs_fopen ("/proc/uptime", "r");
2760 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2761 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2763 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2764 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2765 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2768 if (TYPE_MAXIMUM (time_t) < upsec
)
2770 upsec
= TYPE_MAXIMUM (time_t);
2771 upfrac
= TIMESPEC_RESOLUTION
- 1;
2775 int upfraclen
= upfrac_end
- upfrac_start
;
2776 for (; upfraclen
< LOG10_TIMESPEC_RESOLUTION
; upfraclen
++)
2778 for (; LOG10_TIMESPEC_RESOLUTION
< upfraclen
; upfraclen
--)
2780 upfrac
= min (upfrac
, TIMESPEC_RESOLUTION
- 1);
2782 up
= make_timespec (upsec
, upfrac
);
2791 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2792 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2795 procfs_ttyname (int rdev
)
2798 char name
[PATH_MAX
];
2801 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2807 unsigned long minor_beg
, minor_end
;
2808 char minor
[25]; /* 2 32-bit numbers + dash */
2811 for (; !feof (fdev
) && !ferror (fdev
); name
[0] = 0)
2813 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2814 && major
== MAJOR (rdev
))
2816 minor_beg
= strtoul (minor
, &endp
, 0);
2818 minor_end
= minor_beg
;
2819 else if (*endp
== '-')
2820 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2824 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2826 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2834 return build_string (name
);
2838 procfs_get_total_memory (void)
2841 uintmax_t retval
= 2 * 1024 * 1024; /* default: 2 GiB */
2845 fmem
= emacs_fopen ("/proc/meminfo", "r");
2849 uintmax_t entry_value
;
2853 switch (fscanf (fmem
, "MemTotal: %"SCNuMAX
, &entry_value
))
2856 retval
= entry_value
;
2861 while ((c
= getc (fmem
)) != EOF
&& c
!= '\n')
2879 system_process_attributes (Lisp_Object pid
)
2881 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
2885 long clocks_per_sec
;
2887 char procbuf
[1025], *p
, *q
;
2890 static char const default_cmd
[] = "???";
2891 const char *cmd
= default_cmd
;
2892 int cmdsize
= sizeof default_cmd
- 1;
2893 char *cmdline
= NULL
;
2894 ptrdiff_t cmdline_size
;
2897 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
2900 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
2901 long priority
, niceness
, rss
;
2902 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
2903 struct timespec tnow
, tstart
, tboot
, telapsed
, us_time
;
2905 Lisp_Object attrs
= Qnil
;
2906 Lisp_Object cmd_str
, decoded_cmd
;
2908 struct gcpro gcpro1
, gcpro2
;
2910 CHECK_NUMBER_OR_FLOAT (pid
);
2911 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
2912 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
2913 if (stat (procfn
, &st
) < 0)
2916 GCPRO2 (attrs
, decoded_cmd
);
2920 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
2922 pw
= getpwuid (uid
);
2925 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
2928 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
2930 gr
= getgrgid (gid
);
2933 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
2935 count
= SPECPDL_INDEX ();
2936 strcpy (fn
, procfn
);
2937 procfn_end
= fn
+ strlen (fn
);
2938 strcpy (procfn_end
, "/stat");
2939 fd
= emacs_open (fn
, O_RDONLY
, 0);
2944 record_unwind_protect_int (close_file_unwind
, fd
);
2945 nread
= emacs_read (fd
, procbuf
, sizeof procbuf
- 1);
2949 procbuf
[nread
] = '\0';
2952 p
= strchr (p
, '(');
2955 q
= strrchr (p
+ 1, ')');
2965 /* Command name is encoded in locale-coding-system; decode it. */
2966 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
2967 decoded_cmd
= code_convert_string_norecord (cmd_str
,
2968 Vlocale_coding_system
, 0);
2969 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
2971 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
2972 utime stime cutime cstime priority nice thcount . start vsize rss */
2974 && (sscanf (q
+ 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
2975 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
2976 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
2977 &minflt
, &cminflt
, &majflt
, &cmajflt
,
2978 &u_time
, &s_time
, &cutime
, &cstime
,
2979 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
)
2984 state_str
[1] = '\0';
2985 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
2986 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid
)), attrs
);
2987 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp
)), attrs
);
2988 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess
)), attrs
);
2989 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
2990 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid
)), attrs
);
2991 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
2992 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
2993 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)),
2995 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)),
2997 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
2998 if (clocks_per_sec
< 0)
2999 clocks_per_sec
= 100;
3000 attrs
= Fcons (Fcons (Qutime
,
3001 ltime_from_jiffies (u_time
, clocks_per_sec
)),
3003 attrs
= Fcons (Fcons (Qstime
,
3004 ltime_from_jiffies (s_time
, clocks_per_sec
)),
3006 attrs
= Fcons (Fcons (Qtime
,
3007 ltime_from_jiffies (s_time
+ u_time
,
3010 attrs
= Fcons (Fcons (Qcutime
,
3011 ltime_from_jiffies (cutime
, clocks_per_sec
)),
3013 attrs
= Fcons (Fcons (Qcstime
,
3014 ltime_from_jiffies (cstime
, clocks_per_sec
)),
3016 attrs
= Fcons (Fcons (Qctime
,
3017 ltime_from_jiffies (cstime
+ cutime
,
3020 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
3021 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
3022 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount
)),
3024 tnow
= current_timespec ();
3025 telapsed
= get_up_time ();
3026 tboot
= timespec_sub (tnow
, telapsed
);
3027 tstart
= time_from_jiffies (start
, clocks_per_sec
);
3028 tstart
= timespec_add (tboot
, tstart
);
3029 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
3030 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/ 1024)),
3032 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4 * rss
)), attrs
);
3033 telapsed
= timespec_sub (tnow
, tstart
);
3034 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
3035 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
3036 pcpu
= timespectod (us_time
) / timespectod (telapsed
);
3039 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
3040 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
3043 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
3046 unbind_to (count
, Qnil
);
3049 strcpy (procfn_end
, "/cmdline");
3050 fd
= emacs_open (fn
, O_RDONLY
, 0);
3053 ptrdiff_t readsize
, nread_incr
;
3054 record_unwind_protect_int (close_file_unwind
, fd
);
3055 record_unwind_protect_nothing ();
3056 nread
= cmdline_size
= 0;
3060 cmdline
= xpalloc (cmdline
, &cmdline_size
, 2, STRING_BYTES_BOUND
, 1);
3061 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3063 /* Leave room even if every byte needs escaping below. */
3064 readsize
= (cmdline_size
>> 1) - nread
;
3066 nread_incr
= emacs_read (fd
, cmdline
+ nread
, readsize
);
3067 nread
+= max (0, nread_incr
);
3069 while (nread_incr
== readsize
);
3073 /* We don't want trailing null characters. */
3074 for (p
= cmdline
+ nread
; cmdline
< p
&& !p
[-1]; p
--)
3077 /* Escape-quote whitespace and backslashes. */
3078 q
= cmdline
+ cmdline_size
;
3083 if (c_isspace (c
) || c
== '\\')
3087 nread
= cmdline
+ cmdline_size
- q
;
3092 nread
= cmdsize
+ 2;
3093 cmdline_size
= nread
+ 1;
3094 q
= cmdline
= xrealloc (cmdline
, cmdline_size
);
3095 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3096 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3098 /* Command line is encoded in locale-coding-system; decode it. */
3099 cmd_str
= make_unibyte_string (q
, nread
);
3100 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3101 Vlocale_coding_system
, 0);
3102 unbind_to (count
, Qnil
);
3103 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3110 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3112 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3113 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3114 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3115 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3116 #undef _FILE_OFFSET_BITS
3118 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3123 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3124 #define _FILE_OFFSET_BITS 64
3125 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3127 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3130 system_process_attributes (Lisp_Object pid
)
3132 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3137 struct psinfo pinfo
;
3143 Lisp_Object attrs
= Qnil
;
3144 Lisp_Object decoded_cmd
;
3145 struct gcpro gcpro1
, gcpro2
;
3148 CHECK_NUMBER_OR_FLOAT (pid
);
3149 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3150 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3151 if (stat (procfn
, &st
) < 0)
3154 GCPRO2 (attrs
, decoded_cmd
);
3158 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3160 pw
= getpwuid (uid
);
3163 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3166 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3168 gr
= getgrgid (gid
);
3171 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3173 count
= SPECPDL_INDEX ();
3174 strcpy (fn
, procfn
);
3175 procfn_end
= fn
+ strlen (fn
);
3176 strcpy (procfn_end
, "/psinfo");
3177 fd
= emacs_open (fn
, O_RDONLY
, 0);
3182 record_unwind_protect (close_file_unwind
, fd
);
3183 nread
= emacs_read (fd
, &pinfo
, sizeof pinfo
);
3186 if (nread
== sizeof pinfo
)
3188 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3189 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3190 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3194 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3195 state_str
[1] = '\0';
3196 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3199 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3200 need to get a string from it. */
3202 /* FIXME: missing: Qtpgid */
3214 Are they available? */
3216 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3217 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3218 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3219 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3220 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)),
3223 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3224 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)),
3226 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)),
3229 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3230 range 0 .. 2**15, representing 0.0 .. 1.0. */
3231 attrs
= Fcons (Fcons (Qpcpu
,
3232 make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)),
3234 attrs
= Fcons (Fcons (Qpmem
,
3235 make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)),
3238 decoded_cmd
= (code_convert_string_norecord
3239 (build_unibyte_string (pinfo
.pr_fname
),
3240 Vlocale_coding_system
, 0));
3241 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3242 decoded_cmd
= (code_convert_string_norecord
3243 (build_unibyte_string (pinfo
.pr_psargs
),
3244 Vlocale_coding_system
, 0));
3245 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3247 unbind_to (count
, Qnil
);
3252 #elif defined __FreeBSD__
3254 static struct timespec
3255 timeval_to_timespec (struct timeval t
)
3257 return make_timespec (t
.tv_sec
, t
.tv_usec
* 1000);
3261 make_lisp_timeval (struct timeval t
)
3263 return make_lisp_time (timeval_to_timespec (t
));
3267 system_process_attributes (Lisp_Object pid
)
3270 int pagesize
= getpagesize ();
3271 unsigned long npages
;
3277 char args
[MAXPATHLEN
];
3278 struct timespec t
, now
;
3280 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3281 struct kinfo_proc proc
;
3282 size_t proclen
= sizeof proc
;
3284 struct gcpro gcpro1
, gcpro2
;
3285 Lisp_Object attrs
= Qnil
;
3286 Lisp_Object decoded_comm
;
3288 CHECK_NUMBER_OR_FLOAT (pid
);
3289 CONS_TO_INTEGER (pid
, int, proc_id
);
3292 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3295 GCPRO2 (attrs
, decoded_comm
);
3297 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3300 pw
= getpwuid (proc
.ki_uid
);
3303 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3305 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3308 gr
= getgrgid (proc
.ki_svgid
);
3311 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3313 decoded_comm
= (code_convert_string_norecord
3314 (build_unibyte_string (proc
.ki_comm
),
3315 Vlocale_coding_system
, 0));
3317 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3319 char state
[2] = {'\0', '\0'};
3320 switch (proc
.ki_stat
)
3342 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3345 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3346 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3347 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3350 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3353 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3355 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3356 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3357 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3358 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3359 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3361 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3363 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3365 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage
.ru_utime
),
3366 timeval_to_timespec (proc
.ki_rusage
.ru_stime
));
3367 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3369 attrs
= Fcons (Fcons (Qcutime
,
3370 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3372 attrs
= Fcons (Fcons (Qcstime
,
3373 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3375 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage_ch
.ru_utime
),
3376 timeval_to_timespec (proc
.ki_rusage_ch
.ru_stime
));
3377 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3379 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3381 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3382 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3383 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3384 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3385 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3388 now
= current_timespec ();
3389 t
= timespec_sub (now
, timeval_to_timespec (proc
.ki_start
));
3390 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3392 len
= sizeof fscale
;
3393 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3398 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3400 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3401 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3402 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3406 len
= sizeof npages
;
3407 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3409 double pmem
= (proc
.ki_flag
& P_INMEM
3410 ? 100.0 * proc
.ki_rssize
/ npages
3412 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3415 mib
[2] = KERN_PROC_ARGS
;
3417 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3420 for (i
= 0; i
< len
; i
++)
3422 if (! args
[i
] && i
< len
- 1)
3427 (code_convert_string_norecord
3428 (build_unibyte_string (args
),
3429 Vlocale_coding_system
, 0));
3431 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3438 /* The WINDOWSNT implementation is in w32.c.
3439 The MSDOS implementation is in dosfns.c. */
3440 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3443 system_process_attributes (Lisp_Object pid
)
3448 #endif /* !defined (WINDOWSNT) */