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
);
1512 sigaddset (&action
->sa_mask
, SIGCHLD
);
1514 sigaddset (&action
->sa_mask
, SIGDANGER
);
1516 #ifdef PROFILER_CPU_SUPPORT
1517 sigaddset (&action
->sa_mask
, SIGPROF
);
1520 sigaddset (&action
->sa_mask
, SIGWINCH
);
1522 if (! noninteractive
)
1524 sigaddset (&action
->sa_mask
, SIGINT
);
1525 sigaddset (&action
->sa_mask
, SIGQUIT
);
1527 sigaddset (&action
->sa_mask
, SIGIO
);
1531 action
->sa_handler
= handler
;
1532 action
->sa_flags
= emacs_sigaction_flags ();
1535 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1536 static pthread_t main_thread
;
1539 /* SIG has arrived at the current process. Deliver it to the main
1540 thread, which should handle it with HANDLER.
1542 If we are on the main thread, handle the signal SIG with HANDLER.
1543 Otherwise, redirect the signal to the main thread, blocking it from
1544 this thread. POSIX says any thread can receive a signal that is
1545 associated with a process, process group, or asynchronous event.
1546 On GNU/Linux that is not true, but for other systems (FreeBSD at
1549 deliver_process_signal (int sig
, signal_handler_t handler
)
1551 /* Preserve errno, to avoid race conditions with signal handlers that
1552 might change errno. Races can occur even in single-threaded hosts. */
1553 int old_errno
= errno
;
1555 bool on_main_thread
= true;
1556 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1557 if (! pthread_equal (pthread_self (), main_thread
))
1560 sigemptyset (&blocked
);
1561 sigaddset (&blocked
, sig
);
1562 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1563 pthread_kill (main_thread
, sig
);
1564 on_main_thread
= false;
1573 /* Static location to save a fatal backtrace in a thread.
1574 FIXME: If two subsidiary threads fail simultaneously, the resulting
1575 backtrace may be garbage. */
1576 enum { BACKTRACE_LIMIT_MAX
= 500 };
1577 static void *thread_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
1578 static int thread_backtrace_npointers
;
1580 /* SIG has arrived at the current thread.
1581 If we are on the main thread, handle the signal SIG with HANDLER.
1582 Otherwise, this is a fatal error in the handling thread. */
1584 deliver_thread_signal (int sig
, signal_handler_t handler
)
1586 int old_errno
= errno
;
1588 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1589 if (! pthread_equal (pthread_self (), main_thread
))
1591 thread_backtrace_npointers
1592 = backtrace (thread_backtrace_buffer
, BACKTRACE_LIMIT_MAX
);
1593 sigaction (sig
, &process_fatal_action
, 0);
1594 pthread_kill (main_thread
, sig
);
1596 /* Avoid further damage while the main thread is exiting. */
1598 sigsuspend (&empty_mask
);
1606 #if !HAVE_DECL_SYS_SIGLIST
1608 # ifdef _sys_siglist
1609 # define sys_siglist _sys_siglist
1610 # elif HAVE_DECL___SYS_SIGLIST
1611 # define sys_siglist __sys_siglist
1613 # define sys_siglist my_sys_siglist
1614 static char const *sys_siglist
[NSIG
];
1619 # define sys_siglist_entries _sys_nsig
1621 # define sys_siglist_entries NSIG
1624 /* Handle bus errors, invalid instruction, etc. */
1626 handle_fatal_signal (int sig
)
1628 terminate_due_to_signal (sig
, 40);
1632 deliver_fatal_signal (int sig
)
1634 deliver_process_signal (sig
, handle_fatal_signal
);
1638 deliver_fatal_thread_signal (int sig
)
1640 deliver_thread_signal (sig
, handle_fatal_signal
);
1643 static _Noreturn
void
1644 handle_arith_signal (int sig
)
1647 sigemptyset (&blocked
);
1648 sigaddset (&blocked
, sig
);
1649 pthread_sigmask (SIG_UNBLOCK
, &blocked
, 0);
1650 xsignal0 (Qarith_error
);
1654 deliver_arith_signal (int sig
)
1656 deliver_thread_signal (sig
, handle_arith_signal
);
1661 /* Handler for SIGDANGER. */
1663 handle_danger_signal (int sig
)
1665 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1667 /* It might be unsafe to call do_auto_save now. */
1668 force_auto_save_soon ();
1672 deliver_danger_signal (int sig
)
1674 deliver_process_signal (sig
, handle_danger_signal
);
1678 /* Treat SIG as a terminating signal, unless it is already ignored and
1679 we are in --batch mode. Among other things, this makes nohup work. */
1681 maybe_fatal_sig (int sig
)
1683 bool catch_sig
= !noninteractive
;
1686 struct sigaction old_action
;
1687 sigaction (sig
, 0, &old_action
);
1688 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1691 sigaction (sig
, &process_fatal_action
, 0);
1695 init_signals (bool dumping
)
1697 struct sigaction thread_fatal_action
;
1698 struct sigaction action
;
1700 sigemptyset (&empty_mask
);
1702 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1703 main_thread
= pthread_self ();
1706 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1709 sys_siglist
[SIGABRT
] = "Aborted";
1711 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1713 sys_siglist
[SIGALRM
] = "Alarm clock";
1715 sys_siglist
[SIGBUS
] = "Bus error";
1717 sys_siglist
[SIGCHLD
] = "Child status changed";
1719 sys_siglist
[SIGCONT
] = "Continued";
1722 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1725 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1728 sys_siglist
[SIGEMT
] = "Emulation trap";
1730 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1732 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1735 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1737 sys_siglist
[SIGHUP
] = "Hangup";
1738 sys_siglist
[SIGILL
] = "Illegal instruction";
1739 sys_siglist
[SIGINT
] = "Interrupt";
1741 sys_siglist
[SIGIO
] = "I/O possible";
1744 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1747 sys_siglist
[SIGIOT
] = "IOT trap";
1749 sys_siglist
[SIGKILL
] = "Killed";
1751 sys_siglist
[SIGLOST
] = "Resource lost";
1754 sys_siglist
[SIGLWP
] = "SIGLWP";
1757 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1760 sys_siglist
[SIGWIND
] = "SIGPHONE";
1762 sys_siglist
[SIGPIPE
] = "Broken pipe";
1764 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1767 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1770 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1773 sys_siglist
[SIGPWR
] = "Power-fail restart";
1775 sys_siglist
[SIGQUIT
] = "Quit";
1777 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1780 sys_siglist
[SIGSAK
] = "Secure attention";
1782 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1784 sys_siglist
[SIGSOUND
] = "Sound completed";
1787 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1790 sys_siglist
[SIGSTP
] = "Stopped (user)";
1793 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1795 sys_siglist
[SIGTERM
] = "Terminated";
1797 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1800 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1803 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1806 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1809 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1812 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1815 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1818 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1821 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1824 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1827 sys_siglist
[SIGWINCH
] = "Window size changed";
1830 sys_siglist
[SIGWIND
] = "SIGWIND";
1833 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1836 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1839 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1841 /* Don't alter signal handlers if dumping. On some machines,
1842 changing signal handlers sets static data that would make signals
1843 fail to work right when the dumped Emacs is run. */
1847 sigfillset (&process_fatal_action
.sa_mask
);
1848 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1849 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1851 sigfillset (&thread_fatal_action
.sa_mask
);
1852 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1853 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1855 /* SIGINT may need special treatment on MS-Windows. See
1856 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1857 Please update the doc of kill-emacs, kill-emacs-hook, and
1858 NEWS if you change this. */
1860 maybe_fatal_sig (SIGHUP
);
1861 maybe_fatal_sig (SIGINT
);
1862 maybe_fatal_sig (SIGTERM
);
1864 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1865 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1866 to behave more like typical batch applications do. */
1867 if (! noninteractive
)
1868 signal (SIGPIPE
, SIG_IGN
);
1870 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1871 sigaction (SIGILL
, &thread_fatal_action
, 0);
1872 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1874 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1875 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1876 interpreter's floating point operations, so treat SIGFPE as an
1877 arith-error if it arises in the main thread. */
1878 if (IEEE_FLOATING_POINT
)
1879 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1882 emacs_sigaction_init (&action
, deliver_arith_signal
);
1883 sigaction (SIGFPE
, &action
, 0);
1887 add_user_signal (SIGUSR1
, "sigusr1");
1890 add_user_signal (SIGUSR2
, "sigusr2");
1892 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1894 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1897 sigaction (SIGORE
, &thread_fatal_action
, 0);
1900 sigaction (SIGUME
, &thread_fatal_action
, 0);
1903 sigaction (SIGDLK
, &process_fatal_action
, 0);
1906 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1909 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1912 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1915 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1917 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
1919 sigaction (SIGSYS
, &thread_fatal_action
, 0);
1921 sigaction (SIGTERM
, &process_fatal_action
, 0);
1923 signal (SIGPROF
, SIG_IGN
);
1926 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
1929 sigaction (SIGXCPU
, &process_fatal_action
, 0);
1932 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
1936 /* This just means available memory is getting low. */
1937 emacs_sigaction_init (&action
, deliver_danger_signal
);
1938 sigaction (SIGDANGER
, &action
, 0);
1941 /* AIX-specific signals. */
1943 sigaction (SIGGRANT
, &process_fatal_action
, 0);
1946 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
1949 sigaction (SIGMSG
, &process_fatal_action
, 0);
1952 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
1955 sigaction (SIGSAK
, &process_fatal_action
, 0);
1958 sigaction (SIGSOUND
, &process_fatal_action
, 0);
1961 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
1971 /* Figure out how many bits the system's random number generator uses.
1972 `random' and `lrand48' are assumed to return 31 usable bits.
1973 BSD `rand' returns a 31 bit value but the low order bits are unusable;
1974 so we'll shift it and treat it like the 15-bit USG `rand'. */
1978 # define RAND_BITS 31
1979 # else /* !HAVE_RANDOM */
1980 # ifdef HAVE_LRAND48
1981 # define RAND_BITS 31
1982 # define random lrand48
1983 # else /* !HAVE_LRAND48 */
1984 # define RAND_BITS 15
1985 # if RAND_MAX == 32767
1986 # define random rand
1987 # else /* RAND_MAX != 32767 */
1988 # if RAND_MAX == 2147483647
1989 # define random() (rand () >> 16)
1990 # else /* RAND_MAX != 2147483647 */
1992 # define random rand
1994 # define random() (rand () >> 16)
1996 # endif /* RAND_MAX != 2147483647 */
1997 # endif /* RAND_MAX != 32767 */
1998 # endif /* !HAVE_LRAND48 */
1999 # endif /* !HAVE_RANDOM */
2000 #endif /* !RAND_BITS */
2003 seed_random (void *seed
, ptrdiff_t seed_size
)
2005 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
2006 unsigned int arg
= 0;
2010 unsigned char *argp
= (unsigned char *) &arg
;
2011 unsigned char *seedp
= seed
;
2013 for (i
= 0; i
< seed_size
; i
++)
2014 argp
[i
% sizeof arg
] ^= seedp
[i
];
2018 # ifdef HAVE_LRAND48
2029 struct timespec t
= current_timespec ();
2030 uintmax_t v
= getpid () ^ t
.tv_sec
^ t
.tv_nsec
;
2031 seed_random (&v
, sizeof v
);
2035 * Return a nonnegative random integer out of whatever we've got.
2036 * It contains enough bits to make a random (signed) Emacs fixnum.
2037 * This suffices even for a 64-bit architecture with a 15-bit rand.
2044 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2045 val
= (random () ^ (val
<< RAND_BITS
)
2046 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2047 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2048 return val
& INTMASK
;
2051 #ifndef HAVE_SNPRINTF
2052 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2054 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2056 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2057 ptrdiff_t nbytes
= size
- 1;
2062 va_start (ap
, format
);
2063 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2067 if (nbytes
== size
- 1)
2069 /* Calculate the length of the string that would have been created
2070 had the buffer been large enough. */
2071 char stackbuf
[4000];
2073 ptrdiff_t bsize
= sizeof stackbuf
;
2074 va_start (ap
, format
);
2075 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2081 if (INT_MAX
< nbytes
)
2094 /* If a backtrace is available, output the top lines of it to stderr.
2095 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2096 This function may be called from a signal handler, so it should
2097 not invoke async-unsafe functions like malloc. */
2099 emacs_backtrace (int backtrace_limit
)
2101 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2102 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2106 if (thread_backtrace_npointers
)
2108 buffer
= thread_backtrace_buffer
;
2109 npointers
= thread_backtrace_npointers
;
2113 buffer
= main_backtrace_buffer
;
2114 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2119 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2120 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2121 if (bounded_limit
< npointers
)
2122 emacs_write (STDERR_FILENO
, "...\n", 4);
2130 terminate_due_to_signal (SIGABRT
, 40);
2134 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2135 Arrange for subprograms to not inherit the file descriptor.
2136 Prefer a method that is multithread-safe, if available.
2137 Do not fail merely because the open was interrupted by a signal.
2138 Allow the user to quit. */
2141 emacs_open (const char *file
, int oflags
, int mode
)
2144 oflags
|= O_CLOEXEC
;
2145 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2147 if (! O_CLOEXEC
&& 0 <= fd
)
2148 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2152 /* Open FILE as a stream for Emacs use, with mode MODE.
2153 Act like emacs_open with respect to threads, signals, and quits. */
2156 emacs_fopen (char const *file
, char const *mode
)
2158 int fd
, omode
, oflags
;
2160 char const *m
= mode
;
2164 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2165 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2166 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2167 default: emacs_abort ();
2173 case '+': omode
= O_RDWR
; break;
2174 case 'b': bflag
= O_BINARY
; break;
2175 case 't': bflag
= O_TEXT
; break;
2176 default: /* Ignore. */ break;
2179 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2180 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2183 /* Create a pipe for Emacs use. */
2186 emacs_pipe (int fd
[2])
2188 int result
= pipe2 (fd
, O_CLOEXEC
);
2189 if (! O_CLOEXEC
&& result
== 0)
2191 fcntl (fd
[0], F_SETFD
, FD_CLOEXEC
);
2192 fcntl (fd
[1], F_SETFD
, FD_CLOEXEC
);
2197 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2198 For the background behind this mess, please see Austin Group defect 529
2199 <http://austingroupbugs.net/view.php?id=529>. */
2201 #ifndef POSIX_CLOSE_RESTART
2202 # define POSIX_CLOSE_RESTART 1
2204 posix_close (int fd
, int flag
)
2206 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2207 eassert (flag
== POSIX_CLOSE_RESTART
);
2209 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2210 on a system that does not define POSIX_CLOSE_RESTART.
2212 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2213 closed, and retrying the close could inadvertently close a file
2214 descriptor allocated by some other thread. In other systems
2215 (e.g., HP/UX) FD is not closed. And in still other systems
2216 (e.g., OS X, Solaris), maybe FD is closed, maybe not, and in a
2217 multithreaded program there can be no way to tell.
2219 So, in this case, pretend that the close succeeded. This works
2220 well on systems like GNU/Linux that close FD. Although it may
2221 leak a file descriptor on other systems, the leak is unlikely and
2222 it's better to leak than to close a random victim. */
2223 return close (fd
) == 0 || errno
== EINTR
? 0 : -1;
2227 /* Close FD, retrying if interrupted. If successful, return 0;
2228 otherwise, return -1 and set errno to a non-EINTR value. Consider
2229 an EINPROGRESS error to be successful, as that's merely a signal
2230 arriving. FD is always closed when this function returns, even
2233 Do not call this function if FD is nonnegative and might already be closed,
2234 as that might close an innocent victim opened by some other thread. */
2237 emacs_close (int fd
)
2241 int r
= posix_close (fd
, POSIX_CLOSE_RESTART
);
2244 if (!POSIX_CLOSE_RESTART
|| errno
!= EINTR
)
2246 eassert (errno
!= EBADF
|| fd
< 0);
2247 return errno
== EINPROGRESS
? 0 : r
;
2252 /* Maximum number of bytes to read or write in a single system call.
2253 This works around a serious bug in Linux kernels before 2.6.16; see
2254 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2255 It's likely to work around similar bugs in other operating systems, so do it
2256 on all platforms. Round INT_MAX down to a page size, with the conservative
2257 assumption that page sizes are at most 2**18 bytes (any kernel with a
2258 page size larger than that shouldn't have the bug). */
2259 #ifndef MAX_RW_COUNT
2260 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2263 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2264 Return the number of bytes read, which might be less than NBYTE.
2265 On error, set errno and return -1. */
2267 emacs_read (int fildes
, void *buf
, ptrdiff_t nbyte
)
2271 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2272 passes a size that large to emacs_read. */
2274 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2275 && (errno
== EINTR
))
2280 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2281 or if a partial write occurs. If interrupted, process pending
2282 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2283 errno if this is less than NBYTE. */
2285 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2286 bool process_signals
)
2288 ptrdiff_t bytes_written
= 0;
2292 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2298 /* I originally used `QUIT' but that might causes files to
2299 be truncated if you hit C-g in the middle of it. --Stef */
2300 if (process_signals
&& pending_signals
)
2301 process_pending_signals ();
2313 return bytes_written
;
2316 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2317 interrupted or if a partial write occurs. Return the number of
2318 bytes written, setting errno if this is less than NBYTE. */
2320 emacs_write (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2322 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2325 /* Like emacs_write, but also process pending signals if interrupted. */
2327 emacs_write_sig (int fildes
, void const *buf
, ptrdiff_t nbyte
)
2329 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2332 /* Write a diagnostic to standard error that contains MESSAGE and a
2333 string derived from errno. Preserve errno. Do not buffer stderr.
2334 Do not process pending signals if interrupted. */
2336 emacs_perror (char const *message
)
2339 char const *error_string
= strerror (err
);
2340 char const *command
= (initial_argv
&& initial_argv
[0]
2341 ? initial_argv
[0] : "emacs");
2342 /* Write it out all at once, if it's short; this is less likely to
2343 be interleaved with other output. */
2345 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2346 command
, message
, error_string
);
2347 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2348 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2351 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2352 emacs_write (STDERR_FILENO
, ": ", 2);
2353 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2354 emacs_write (STDERR_FILENO
, ": ", 2);
2355 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2356 emacs_write (STDERR_FILENO
, "\n", 1);
2361 /* Return a struct timeval that is roughly equivalent to T.
2362 Use the least timeval not less than T.
2363 Return an extremal value if the result would overflow. */
2365 make_timeval (struct timespec t
)
2368 tv
.tv_sec
= t
.tv_sec
;
2369 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2371 if (t
.tv_nsec
% 1000 != 0)
2373 if (tv
.tv_usec
< 999999)
2375 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2385 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2386 ATIME and MTIME, respectively.
2387 FD must be either negative -- in which case it is ignored --
2388 or a file descriptor that is open on FILE.
2389 If FD is nonnegative, then FILE can be NULL. */
2391 set_file_times (int fd
, const char *filename
,
2392 struct timespec atime
, struct timespec mtime
)
2394 struct timespec timespec
[2];
2395 timespec
[0] = atime
;
2396 timespec
[1] = mtime
;
2397 return fdutimens (fd
, filename
, timespec
);
2400 /* Like strsignal, except async-signal-safe, and this function typically
2401 returns a string in the C locale rather than the current locale. */
2403 safe_strsignal (int code
)
2405 char const *signame
= 0;
2407 if (0 <= code
&& code
< sys_siglist_entries
)
2408 signame
= sys_siglist
[code
];
2410 signame
= "Unknown signal";
2416 /* For make-serial-process */
2418 serial_open (Lisp_Object port
)
2420 int fd
= emacs_open (SSDATA (port
), O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2422 report_file_error ("Opening serial port", port
);
2424 ioctl (fd
, TIOCEXCL
, (char *) 0);
2430 #if !defined (HAVE_CFMAKERAW)
2431 /* Workaround for targets which are missing cfmakeraw. */
2432 /* Pasted from man page. */
2434 cfmakeraw (struct termios
*termios_p
)
2436 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2437 termios_p
->c_oflag
&= ~OPOST
;
2438 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2439 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2440 termios_p
->c_cflag
|= CS8
;
2442 #endif /* !defined (HAVE_CFMAKERAW */
2444 #if !defined (HAVE_CFSETSPEED)
2445 /* Workaround for targets which are missing cfsetspeed. */
2447 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2449 return (cfsetispeed (termios_p
, vitesse
)
2450 + cfsetospeed (termios_p
, vitesse
));
2454 /* For serial-process-configure */
2456 serial_configure (struct Lisp_Process
*p
,
2457 Lisp_Object contact
)
2459 Lisp_Object childp2
= Qnil
;
2460 Lisp_Object tem
= Qnil
;
2461 struct termios attr
;
2463 char summary
[4] = "???"; /* This usually becomes "8N1". */
2465 childp2
= Fcopy_sequence (p
->childp
);
2467 /* Read port attributes and prepare default configuration. */
2468 err
= tcgetattr (p
->outfd
, &attr
);
2470 report_file_error ("Failed tcgetattr", Qnil
);
2472 #if defined (CLOCAL)
2473 attr
.c_cflag
|= CLOCAL
;
2476 attr
.c_cflag
|= CREAD
;
2479 /* Configure speed. */
2480 if (!NILP (Fplist_member (contact
, QCspeed
)))
2481 tem
= Fplist_get (contact
, QCspeed
);
2483 tem
= Fplist_get (p
->childp
, QCspeed
);
2485 err
= cfsetspeed (&attr
, XINT (tem
));
2487 report_file_error ("Failed cfsetspeed", tem
);
2488 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2490 /* Configure bytesize. */
2491 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2492 tem
= Fplist_get (contact
, QCbytesize
);
2494 tem
= Fplist_get (p
->childp
, QCbytesize
);
2496 tem
= make_number (8);
2498 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2499 error (":bytesize must be nil (8), 7, or 8");
2500 summary
[0] = XINT (tem
) + '0';
2501 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2502 attr
.c_cflag
&= ~CSIZE
;
2503 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2505 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2506 if (XINT (tem
) != 8)
2507 error ("Bytesize cannot be changed");
2509 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2511 /* Configure parity. */
2512 if (!NILP (Fplist_member (contact
, QCparity
)))
2513 tem
= Fplist_get (contact
, QCparity
);
2515 tem
= Fplist_get (p
->childp
, QCparity
);
2516 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2517 error (":parity must be nil (no parity), `even', or `odd'");
2518 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2519 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2520 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2525 else if (EQ (tem
, Qeven
))
2528 attr
.c_cflag
|= PARENB
;
2529 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2531 else if (EQ (tem
, Qodd
))
2534 attr
.c_cflag
|= (PARENB
| PARODD
);
2535 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2538 /* Don't error on no parity, which should be set by cfmakeraw. */
2540 error ("Parity cannot be configured");
2542 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2544 /* Configure stopbits. */
2545 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2546 tem
= Fplist_get (contact
, QCstopbits
);
2548 tem
= Fplist_get (p
->childp
, QCstopbits
);
2550 tem
= make_number (1);
2552 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2553 error (":stopbits must be nil (1 stopbit), 1, or 2");
2554 summary
[2] = XINT (tem
) + '0';
2555 #if defined (CSTOPB)
2556 attr
.c_cflag
&= ~CSTOPB
;
2557 if (XINT (tem
) == 2)
2558 attr
.c_cflag
|= CSTOPB
;
2560 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2561 if (XINT (tem
) != 1)
2562 error ("Stopbits cannot be configured");
2564 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2566 /* Configure flowcontrol. */
2567 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2568 tem
= Fplist_get (contact
, QCflowcontrol
);
2570 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2571 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2572 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2573 #if defined (CRTSCTS)
2574 attr
.c_cflag
&= ~CRTSCTS
;
2576 #if defined (CNEW_RTSCTS)
2577 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2579 #if defined (IXON) && defined (IXOFF)
2580 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2584 /* Already configured. */
2586 else if (EQ (tem
, Qhw
))
2588 #if defined (CRTSCTS)
2589 attr
.c_cflag
|= CRTSCTS
;
2590 #elif defined (CNEW_RTSCTS)
2591 attr
.c_cflag
|= CNEW_RTSCTS
;
2593 error ("Hardware flowcontrol (RTS/CTS) not supported");
2596 else if (EQ (tem
, Qsw
))
2598 #if defined (IXON) && defined (IXOFF)
2599 attr
.c_iflag
|= (IXON
| IXOFF
);
2601 error ("Software flowcontrol (XON/XOFF) not supported");
2604 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2606 /* Activate configuration. */
2607 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2609 report_file_error ("Failed tcsetattr", Qnil
);
2611 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2612 pset_childp (p
, childp2
);
2614 #endif /* not DOS_NT */
2616 /* System depended enumeration of and access to system processes a-la ps(1). */
2620 /* Process enumeration and access via /proc. */
2623 list_system_processes (void)
2625 Lisp_Object procdir
, match
, proclist
, next
;
2626 struct gcpro gcpro1
, gcpro2
;
2627 register Lisp_Object tail
;
2629 GCPRO2 (procdir
, match
);
2630 /* For every process on the system, there's a directory in the
2631 "/proc" pseudo-directory whose name is the numeric ID of that
2633 procdir
= build_string ("/proc");
2634 match
= build_string ("[0-9]+");
2635 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2637 /* `proclist' gives process IDs as strings. Destructively convert
2638 each string into a number. */
2639 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2642 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2646 /* directory_files_internal returns the files in reverse order; undo
2648 proclist
= Fnreverse (proclist
);
2652 #elif defined DARWIN_OS || defined __FreeBSD__
2655 list_system_processes (void)
2658 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2660 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2663 struct kinfo_proc
*procs
;
2666 struct gcpro gcpro1
;
2667 Lisp_Object proclist
= Qnil
;
2669 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2672 procs
= xmalloc (len
);
2673 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2680 len
/= sizeof (struct kinfo_proc
);
2681 for (i
= 0; i
< len
; i
++)
2684 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2686 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2696 /* The WINDOWSNT implementation is in w32.c.
2697 The MSDOS implementation is in dosfns.c. */
2698 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2701 list_system_processes (void)
2706 #endif /* !defined (WINDOWSNT) */
2708 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2709 static struct timespec
2710 time_from_jiffies (unsigned long long tval
, long hz
)
2712 unsigned long long s
= tval
/ hz
;
2713 unsigned long long frac
= tval
% hz
;
2716 if (TYPE_MAXIMUM (time_t) < s
)
2718 if (LONG_MAX
- 1 <= ULLONG_MAX
/ TIMESPEC_RESOLUTION
2719 || frac
<= ULLONG_MAX
/ TIMESPEC_RESOLUTION
)
2720 ns
= frac
* TIMESPEC_RESOLUTION
/ hz
;
2723 /* This is reachable only in the unlikely case that HZ * HZ
2724 exceeds ULLONG_MAX. It calculates an approximation that is
2725 guaranteed to be in range. */
2726 long hz_per_ns
= (hz
/ TIMESPEC_RESOLUTION
2727 + (hz
% TIMESPEC_RESOLUTION
!= 0));
2728 ns
= frac
/ hz_per_ns
;
2731 return make_timespec (s
, ns
);
2735 ltime_from_jiffies (unsigned long long tval
, long hz
)
2737 struct timespec t
= time_from_jiffies (tval
, hz
);
2738 return make_lisp_time (t
);
2741 static struct timespec
2745 struct timespec up
= make_timespec (0, 0);
2748 fup
= emacs_fopen ("/proc/uptime", "r");
2752 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2753 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2755 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2756 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2757 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2760 if (TYPE_MAXIMUM (time_t) < upsec
)
2762 upsec
= TYPE_MAXIMUM (time_t);
2763 upfrac
= TIMESPEC_RESOLUTION
- 1;
2767 int upfraclen
= upfrac_end
- upfrac_start
;
2768 for (; upfraclen
< LOG10_TIMESPEC_RESOLUTION
; upfraclen
++)
2770 for (; LOG10_TIMESPEC_RESOLUTION
< upfraclen
; upfraclen
--)
2772 upfrac
= min (upfrac
, TIMESPEC_RESOLUTION
- 1);
2774 up
= make_timespec (upsec
, upfrac
);
2783 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2784 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2787 procfs_ttyname (int rdev
)
2790 char name
[PATH_MAX
];
2793 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2799 unsigned long minor_beg
, minor_end
;
2800 char minor
[25]; /* 2 32-bit numbers + dash */
2803 for (; !feof (fdev
) && !ferror (fdev
); name
[0] = 0)
2805 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2806 && major
== MAJOR (rdev
))
2808 minor_beg
= strtoul (minor
, &endp
, 0);
2810 minor_end
= minor_beg
;
2811 else if (*endp
== '-')
2812 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2816 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2818 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2826 return build_string (name
);
2830 procfs_get_total_memory (void)
2833 uintmax_t retval
= 2 * 1024 * 1024; /* default: 2 GiB */
2837 fmem
= emacs_fopen ("/proc/meminfo", "r");
2841 uintmax_t entry_value
;
2845 switch (fscanf (fmem
, "MemTotal: %"SCNuMAX
, &entry_value
))
2848 retval
= entry_value
;
2853 while ((c
= getc (fmem
)) != EOF
&& c
!= '\n')
2871 system_process_attributes (Lisp_Object pid
)
2873 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
2877 long clocks_per_sec
;
2879 char procbuf
[1025], *p
, *q
;
2882 static char const default_cmd
[] = "???";
2883 const char *cmd
= default_cmd
;
2884 int cmdsize
= sizeof default_cmd
- 1;
2885 char *cmdline
= NULL
;
2886 ptrdiff_t cmdline_size
;
2889 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
2892 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
2893 long priority
, niceness
, rss
;
2894 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
2895 struct timespec tnow
, tstart
, tboot
, telapsed
, us_time
;
2897 Lisp_Object attrs
= Qnil
;
2898 Lisp_Object cmd_str
, decoded_cmd
;
2900 struct gcpro gcpro1
, gcpro2
;
2902 CHECK_NUMBER_OR_FLOAT (pid
);
2903 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
2904 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
2905 if (stat (procfn
, &st
) < 0)
2908 GCPRO2 (attrs
, decoded_cmd
);
2912 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
2914 pw
= getpwuid (uid
);
2917 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
2920 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
2922 gr
= getgrgid (gid
);
2925 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
2927 count
= SPECPDL_INDEX ();
2928 strcpy (fn
, procfn
);
2929 procfn_end
= fn
+ strlen (fn
);
2930 strcpy (procfn_end
, "/stat");
2931 fd
= emacs_open (fn
, O_RDONLY
, 0);
2936 record_unwind_protect_int (close_file_unwind
, fd
);
2937 nread
= emacs_read (fd
, procbuf
, sizeof procbuf
- 1);
2941 procbuf
[nread
] = '\0';
2944 p
= strchr (p
, '(');
2947 q
= strrchr (p
+ 1, ')');
2957 /* Command name is encoded in locale-coding-system; decode it. */
2958 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
2959 decoded_cmd
= code_convert_string_norecord (cmd_str
,
2960 Vlocale_coding_system
, 0);
2961 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
2963 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
2964 utime stime cutime cstime priority nice thcount . start vsize rss */
2966 && (sscanf (q
+ 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
2967 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
2968 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
2969 &minflt
, &cminflt
, &majflt
, &cmajflt
,
2970 &u_time
, &s_time
, &cutime
, &cstime
,
2971 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
)
2976 state_str
[1] = '\0';
2977 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
2978 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid
)), attrs
);
2979 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp
)), attrs
);
2980 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess
)), attrs
);
2981 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
2982 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid
)), attrs
);
2983 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
2984 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
2985 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)),
2987 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)),
2989 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
2990 if (clocks_per_sec
< 0)
2991 clocks_per_sec
= 100;
2992 attrs
= Fcons (Fcons (Qutime
,
2993 ltime_from_jiffies (u_time
, clocks_per_sec
)),
2995 attrs
= Fcons (Fcons (Qstime
,
2996 ltime_from_jiffies (s_time
, clocks_per_sec
)),
2998 attrs
= Fcons (Fcons (Qtime
,
2999 ltime_from_jiffies (s_time
+ u_time
,
3002 attrs
= Fcons (Fcons (Qcutime
,
3003 ltime_from_jiffies (cutime
, clocks_per_sec
)),
3005 attrs
= Fcons (Fcons (Qcstime
,
3006 ltime_from_jiffies (cstime
, clocks_per_sec
)),
3008 attrs
= Fcons (Fcons (Qctime
,
3009 ltime_from_jiffies (cstime
+ cutime
,
3012 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
3013 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
3014 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount
)),
3016 tnow
= current_timespec ();
3017 telapsed
= get_up_time ();
3018 tboot
= timespec_sub (tnow
, telapsed
);
3019 tstart
= time_from_jiffies (start
, clocks_per_sec
);
3020 tstart
= timespec_add (tboot
, tstart
);
3021 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
3022 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/ 1024)),
3024 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4 * rss
)), attrs
);
3025 telapsed
= timespec_sub (tnow
, tstart
);
3026 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
3027 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
3028 pcpu
= timespectod (us_time
) / timespectod (telapsed
);
3031 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
3032 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
3035 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
3038 unbind_to (count
, Qnil
);
3041 strcpy (procfn_end
, "/cmdline");
3042 fd
= emacs_open (fn
, O_RDONLY
, 0);
3045 ptrdiff_t readsize
, nread_incr
;
3046 record_unwind_protect_int (close_file_unwind
, fd
);
3047 record_unwind_protect_nothing ();
3048 nread
= cmdline_size
= 0;
3052 cmdline
= xpalloc (cmdline
, &cmdline_size
, 2, STRING_BYTES_BOUND
, 1);
3053 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3055 /* Leave room even if every byte needs escaping below. */
3056 readsize
= (cmdline_size
>> 1) - nread
;
3058 nread_incr
= emacs_read (fd
, cmdline
+ nread
, readsize
);
3059 nread
+= max (0, nread_incr
);
3061 while (nread_incr
== readsize
);
3065 /* We don't want trailing null characters. */
3066 for (p
= cmdline
+ nread
; cmdline
< p
&& !p
[-1]; p
--)
3069 /* Escape-quote whitespace and backslashes. */
3070 q
= cmdline
+ cmdline_size
;
3075 if (c_isspace (c
) || c
== '\\')
3079 nread
= cmdline
+ cmdline_size
- q
;
3084 nread
= cmdsize
+ 2;
3085 cmdline_size
= nread
+ 1;
3086 q
= cmdline
= xrealloc (cmdline
, cmdline_size
);
3087 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3088 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3090 /* Command line is encoded in locale-coding-system; decode it. */
3091 cmd_str
= make_unibyte_string (q
, nread
);
3092 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3093 Vlocale_coding_system
, 0);
3094 unbind_to (count
, Qnil
);
3095 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3102 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3104 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3105 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3106 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3107 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3108 #undef _FILE_OFFSET_BITS
3110 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3115 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3116 #define _FILE_OFFSET_BITS 64
3117 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3119 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3122 system_process_attributes (Lisp_Object pid
)
3124 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3129 struct psinfo pinfo
;
3135 Lisp_Object attrs
= Qnil
;
3136 Lisp_Object decoded_cmd
;
3137 struct gcpro gcpro1
, gcpro2
;
3140 CHECK_NUMBER_OR_FLOAT (pid
);
3141 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3142 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3143 if (stat (procfn
, &st
) < 0)
3146 GCPRO2 (attrs
, decoded_cmd
);
3150 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3152 pw
= getpwuid (uid
);
3155 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3158 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3160 gr
= getgrgid (gid
);
3163 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3165 count
= SPECPDL_INDEX ();
3166 strcpy (fn
, procfn
);
3167 procfn_end
= fn
+ strlen (fn
);
3168 strcpy (procfn_end
, "/psinfo");
3169 fd
= emacs_open (fn
, O_RDONLY
, 0);
3174 record_unwind_protect (close_file_unwind
, fd
);
3175 nread
= emacs_read (fd
, &pinfo
, sizeof pinfo
);
3178 if (nread
== sizeof pinfo
)
3180 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3181 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3182 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3186 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3187 state_str
[1] = '\0';
3188 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3191 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3192 need to get a string from it. */
3194 /* FIXME: missing: Qtpgid */
3206 Are they available? */
3208 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3209 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3210 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3211 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3212 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)),
3215 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3216 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)),
3218 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)),
3221 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3222 range 0 .. 2**15, representing 0.0 .. 1.0. */
3223 attrs
= Fcons (Fcons (Qpcpu
,
3224 make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)),
3226 attrs
= Fcons (Fcons (Qpmem
,
3227 make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)),
3230 decoded_cmd
= (code_convert_string_norecord
3231 (build_unibyte_string (pinfo
.pr_fname
),
3232 Vlocale_coding_system
, 0));
3233 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3234 decoded_cmd
= (code_convert_string_norecord
3235 (build_unibyte_string (pinfo
.pr_psargs
),
3236 Vlocale_coding_system
, 0));
3237 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3239 unbind_to (count
, Qnil
);
3244 #elif defined __FreeBSD__
3246 static struct timespec
3247 timeval_to_timespec (struct timeval t
)
3249 return make_timespec (t
.tv_sec
, t
.tv_usec
* 1000);
3253 make_lisp_timeval (struct timeval t
)
3255 return make_lisp_time (timeval_to_timespec (t
));
3259 system_process_attributes (Lisp_Object pid
)
3262 int pagesize
= getpagesize ();
3263 unsigned long npages
;
3269 char args
[MAXPATHLEN
];
3270 struct timespec t
, now
;
3272 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3273 struct kinfo_proc proc
;
3274 size_t proclen
= sizeof proc
;
3276 struct gcpro gcpro1
, gcpro2
;
3277 Lisp_Object attrs
= Qnil
;
3278 Lisp_Object decoded_comm
;
3280 CHECK_NUMBER_OR_FLOAT (pid
);
3281 CONS_TO_INTEGER (pid
, int, proc_id
);
3284 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3287 GCPRO2 (attrs
, decoded_comm
);
3289 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3292 pw
= getpwuid (proc
.ki_uid
);
3295 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3297 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3300 gr
= getgrgid (proc
.ki_svgid
);
3303 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3305 decoded_comm
= (code_convert_string_norecord
3306 (build_unibyte_string (proc
.ki_comm
),
3307 Vlocale_coding_system
, 0));
3309 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3311 char state
[2] = {'\0', '\0'};
3312 switch (proc
.ki_stat
)
3334 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3337 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3338 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3339 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3342 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3345 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3347 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3348 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3349 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3350 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3351 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3353 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3355 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3357 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage
.ru_utime
),
3358 timeval_to_timespec (proc
.ki_rusage
.ru_stime
));
3359 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3361 attrs
= Fcons (Fcons (Qcutime
,
3362 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3364 attrs
= Fcons (Fcons (Qcstime
,
3365 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3367 t
= timespec_add (timeval_to_timespec (proc
.ki_rusage_ch
.ru_utime
),
3368 timeval_to_timespec (proc
.ki_rusage_ch
.ru_stime
));
3369 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3371 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3373 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3374 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3375 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3376 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3377 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3380 now
= current_timespec ();
3381 t
= timespec_sub (now
, timeval_to_timespec (proc
.ki_start
));
3382 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3384 len
= sizeof fscale
;
3385 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3390 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3392 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3393 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3394 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3398 len
= sizeof npages
;
3399 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3401 double pmem
= (proc
.ki_flag
& P_INMEM
3402 ? 100.0 * proc
.ki_rssize
/ npages
3404 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3407 mib
[2] = KERN_PROC_ARGS
;
3409 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3412 for (i
= 0; i
< len
; i
++)
3414 if (! args
[i
] && i
< len
- 1)
3419 (code_convert_string_norecord
3420 (build_unibyte_string (args
),
3421 Vlocale_coding_system
, 0));
3423 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3430 /* The WINDOWSNT implementation is in w32.c.
3431 The MSDOS implementation is in dosfns.c. */
3432 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3435 system_process_attributes (Lisp_Object pid
)
3440 #endif /* !defined (WINDOWSNT) */