1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2013 Free Software
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #define SYSTIME_INLINE EXTERN_INLINE
29 #endif /* HAVE_PWD_H */
37 #include "sysselect.h"
38 #include "blockinput.h"
40 #if defined DARWIN_OS || defined __FreeBSD__
41 # include <sys/sysctl.h>
46 #include <sys/resource.h>
52 #define write sys_write
54 #define STDERR_FILENO fileno(GetStdHandle(STD_ERROR_HANDLE))
57 #endif /* not WINDOWSNT */
59 #include <sys/types.h>
63 /* Get SI_SRPC_DOMAIN, if it is available. */
64 #ifdef HAVE_SYS_SYSTEMINFO_H
65 #include <sys/systeminfo.h>
68 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
72 #include <sys/param.h>
79 #ifdef HAVE_SYS_UTSNAME_H
80 #include <sys/utsname.h>
82 #endif /* HAVE_SYS_UTSNAME_H */
87 #include "termhooks.h"
90 #include "dispextern.h"
92 #include "cm.h" /* for reset_sys_modes */
96 /* In process.h which conflicts with the local copy. */
98 int _cdecl
_spawnlp (int, const char *, const char *, ...);
99 int _cdecl
_getpid (void);
102 #include "syssignal.h"
105 static int emacs_get_tty (int, struct emacs_tty
*);
106 static int emacs_set_tty (int, struct emacs_tty
*, int);
108 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
110 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
113 /* Declare here, including term.h is problematic on some systems. */
114 extern void tputs (const char *, int, int (*)(int));
116 static const int baud_convert
[] =
118 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
119 1800, 2400, 4800, 9600, 19200, 38400
123 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
125 /* Return the current working directory. Returns NULL on errors.
126 Any other returned value must be freed with free. This is used
127 only when get_current_dir_name is not defined on the system. */
129 get_current_dir_name (void)
132 char *pwd
= getenv ("PWD");
133 struct stat dotstat
, pwdstat
;
134 /* If PWD is accurate, use it instead of calling getcwd. PWD is
135 sometimes a nicer name, and using it may avoid a fatal error if a
136 parent directory is searchable but not readable. */
138 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
139 && stat (pwd
, &pwdstat
) == 0
140 && stat (".", &dotstat
) == 0
141 && dotstat
.st_ino
== pwdstat
.st_ino
142 && dotstat
.st_dev
== pwdstat
.st_dev
144 && strlen (pwd
) < MAXPATHLEN
148 buf
= malloc (strlen (pwd
) + 1);
155 size_t buf_size
= 1024;
156 buf
= malloc (buf_size
);
161 if (getcwd (buf
, buf_size
) == buf
)
165 int tmp_errno
= errno
;
171 buf
= realloc (buf
, buf_size
);
181 /* Discard pending input on all input descriptors. */
184 discard_tty_input (void)
187 struct emacs_tty buf
;
192 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
193 while (dos_keyread () != -1)
195 #else /* not MSDOS */
197 struct tty_display_info
*tty
;
198 for (tty
= tty_list
; tty
; tty
= tty
->next
)
200 if (tty
->input
) /* Is the device suspended? */
202 emacs_get_tty (fileno (tty
->input
), &buf
);
203 emacs_set_tty (fileno (tty
->input
), &buf
, 0);
207 #endif /* not MSDOS */
208 #endif /* not WINDOWSNT */
214 /* Arrange for character C to be read as the next input from
216 XXX What if we have multiple ttys?
222 if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
225 /* Should perhaps error if in batch mode */
227 ioctl (fileno (CURTTY()->input
), TIOCSTI
, &c
);
228 #else /* no TIOCSTI */
229 error ("Cannot stuff terminal input characters in this version of Unix");
230 #endif /* no TIOCSTI */
236 init_baud_rate (int fd
)
246 #else /* not DOS_NT */
251 emacs_ospeed
= cfgetospeed (&sg
);
252 #endif /* not DOS_NT */
255 baud_rate
= (emacs_ospeed
< sizeof baud_convert
/ sizeof baud_convert
[0]
256 ? baud_convert
[emacs_ospeed
] : 9600);
265 /* Wait for the subprocess with process id CHILD to terminate or change status.
266 CHILD must be a child process that has not been reaped.
267 If STATUS is non-null, store the waitpid-style exit status into *STATUS
268 and tell wait_reading_process_output that it needs to look around.
269 Use waitpid-style OPTIONS when waiting.
270 If INTERRUPTIBLE, this function is interruptible by a signal.
272 Return CHILD if successful, 0 if no status is available;
273 the latter is possible only when options & NOHANG. */
275 get_child_status (pid_t child
, int *status
, int options
, bool interruptible
)
279 /* Invoke waitpid only with a known process ID; do not invoke
280 waitpid with a nonpositive argument. Otherwise, Emacs might
281 reap an unwanted process by mistake. For example, invoking
282 waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
283 so that another thread running glib won't find them. */
286 while ((pid
= waitpid (child
, status
, options
)) < 0)
288 /* Check that CHILD is a child process that has not been reaped,
289 and that STATUS and OPTIONS are valid. Otherwise abort,
290 as continuing after this internal error could cause Emacs to
291 become confused and kill innocent-victim processes. */
295 /* Note: the MS-Windows emulation of waitpid calls QUIT
301 /* If successful and status is requested, tell wait_reading_process_output
302 that it needs to wake up and look around. */
303 if (pid
&& status
&& input_available_clear_time
)
304 *input_available_clear_time
= make_emacs_time (0, 0);
309 /* Wait for the subprocess with process id CHILD to terminate.
310 CHILD must be a child process that has not been reaped.
311 If STATUS is non-null, store the waitpid-style exit status into *STATUS
312 and tell wait_reading_process_output that it needs to look around.
313 If INTERRUPTIBLE, this function is interruptible by a signal. */
315 wait_for_termination (pid_t child
, int *status
, bool interruptible
)
317 get_child_status (child
, status
, 0, interruptible
);
320 /* Report whether the subprocess with process id CHILD has changed status.
321 Termination counts as a change of status.
322 CHILD must be a child process that has not been reaped.
323 If STATUS is non-null, store the waitpid-style exit status into *STATUS
324 and tell wait_reading_process_output that it needs to look around.
325 Use waitpid-style OPTIONS to check status, but do not wait.
327 Return CHILD if successful, 0 if no status is available because
328 the process's state has not changed. */
330 child_status_changed (pid_t child
, int *status
, int options
)
332 return get_child_status (child
, status
, WNOHANG
| options
, 0);
336 * flush any pending output
337 * (may flush input as well; it does not matter the way we use it)
341 flush_pending_output (int channel
)
343 /* FIXME: maybe this function should be removed */
346 /* Set up the terminal at the other end of a pseudo-terminal that
347 we will be controlling an inferior through.
348 It should not echo or do line-editing, since that is done
349 in Emacs. No padding needed for insertion into an Emacs buffer. */
352 child_setup_tty (int out
)
357 emacs_get_tty (out
, &s
);
358 s
.main
.c_oflag
|= OPOST
; /* Enable output postprocessing */
359 s
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL on output */
361 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
362 Some versions of GNU Hurd do not have FFDLY? */
364 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
|FFDLY
);
365 /* No output delays */
367 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
);
368 /* No output delays */
371 s
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
372 s
.main
.c_lflag
|= ISIG
; /* Enable signals */
374 s
.main
.c_iflag
&= ~IUCLC
; /* Disable downcasing on input. */
377 s
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
380 s
.main
.c_oflag
&= ~OLCUC
; /* Disable upcasing on output. */
382 s
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
383 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CSIZE
) | CS8
; /* Don't strip 8th bit */
384 s
.main
.c_cc
[VERASE
] = CDISABLE
; /* disable erase processing */
385 s
.main
.c_cc
[VKILL
] = CDISABLE
; /* disable kill processing */
388 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
391 #ifdef SIGNALS_VIA_CHARACTERS
392 /* the QUIT and INTR character are used in process_send_signal
393 so set them here to something useful. */
394 if (s
.main
.c_cc
[VQUIT
] == CDISABLE
)
395 s
.main
.c_cc
[VQUIT
] = '\\'&037; /* Control-\ */
396 if (s
.main
.c_cc
[VINTR
] == CDISABLE
)
397 s
.main
.c_cc
[VINTR
] = 'C'&037; /* Control-C */
398 #endif /* not SIGNALS_VIA_CHARACTERS */
401 /* Also, PTY overloads NUL and BREAK.
402 don't ignore break, but don't signal either, so it looks like NUL. */
403 s
.main
.c_iflag
&= ~IGNBRK
;
404 s
.main
.c_iflag
&= ~BRKINT
;
405 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
406 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
407 would force it to 0377. That looks like duplicated code. */
408 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
411 /* We originally enabled ICANON (and set VEOF to 04), and then had
412 process.c send additional EOF chars to flush the output when faced
413 with long lines, but this leads to weird effects when the
414 subprocess has disabled ICANON and ends up seeing those spurious
415 extra EOFs. So we don't send EOFs any more in
416 process.c:send_process. First we tried to disable ICANON by
417 default, so if a subsprocess sets up ICANON, it's his problem (or
418 the Elisp package that talks to it) to deal with lines that are
419 too long. But this disables some features, such as the ability
420 to send EOF signals. So we re-enabled ICANON but there is no
421 more "send eof to flush" going on (which is wrong and unportable
422 in itself). The correct way to handle too much output is to
423 buffer what could not be written and then write it again when
424 select returns ok for writing. This has it own set of
425 problems. Write is now asynchronous, is that a problem? How much
426 do we buffer, and what do we do when that limit is reached? */
428 s
.main
.c_lflag
|= ICANON
; /* Enable line editing and eof processing */
429 s
.main
.c_cc
[VEOF
] = 'D'&037; /* Control-D */
430 #if 0 /* These settings only apply to non-ICANON mode. */
431 s
.main
.c_cc
[VMIN
] = 1;
432 s
.main
.c_cc
[VTIME
] = 0;
435 emacs_set_tty (out
, &s
, 0);
436 #endif /* not WINDOWSNT */
438 #endif /* not MSDOS */
441 /* Record a signal code and the action for it. */
445 struct sigaction action
;
448 static void save_signal_handlers (struct save_signal
*);
449 static void restore_signal_handlers (struct save_signal
*);
451 /* Suspend the Emacs process; give terminal to its superior. */
459 /* On a system where suspending is not implemented,
460 instead fork a subshell and let it talk directly to the terminal
467 /* Fork a subshell. */
472 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
474 char oldwd
[MAXPATHLEN
+1]; /* Fixed length is safe on MSDOS. */
478 struct save_signal saved_handlers
[5];
480 unsigned char *volatile str_volatile
= 0;
484 saved_handlers
[0].code
= SIGINT
;
485 saved_handlers
[1].code
= SIGQUIT
;
486 saved_handlers
[2].code
= SIGTERM
;
488 saved_handlers
[3].code
= SIGIO
;
489 saved_handlers
[4].code
= 0;
491 saved_handlers
[3].code
= 0;
494 /* Mentioning current_buffer->buffer would mean including buffer.h,
495 which somehow wedges the hp compiler. So instead... */
497 dir
= intern ("default-directory");
498 if (NILP (Fboundp (dir
)))
500 dir
= Fsymbol_value (dir
);
504 dir
= expand_and_dir_to_file (Funhandled_file_name_directory (dir
), Qnil
);
505 str_volatile
= str
= alloca (SCHARS (dir
) + 2);
507 memcpy (str
, SDATA (dir
), len
);
508 if (str
[len
- 1] != '/') str
[len
++] = '/';
514 save_signal_handlers (saved_handlers
);
518 error ("Can't spawn subshell");
525 #ifdef DOS_NT /* MW, Aug 1993 */
526 getcwd (oldwd
, sizeof oldwd
);
528 sh
= egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
531 sh
= egetenv ("SHELL");
535 /* Use our buffer's default directory for the subshell. */
537 if (str
&& chdir ((char *) str
) != 0)
540 emacs_perror ((char *) str
);
541 _exit (EXIT_CANCELED
);
545 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
547 char *epwd
= getenv ("PWD");
548 char old_pwd
[MAXPATHLEN
+1+4];
550 /* If PWD is set, pass it with corrected value. */
553 strcpy (old_pwd
, epwd
);
554 if (str
[len
- 1] == '/')
556 setenv ("PWD", str
, 1);
559 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
561 putenv (old_pwd
); /* restore previous value */
563 #else /* not MSDOS */
565 /* Waits for process completion */
566 pid
= _spawnlp (_P_WAIT
, sh
, sh
, NULL
);
567 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
569 write (1, "Can't execute subshell", 22);
570 #else /* not WINDOWSNT */
571 execlp (sh
, sh
, (char *) 0);
573 _exit (errno
== ENOENT
? EXIT_ENOENT
: EXIT_CANNOT_INVOKE
);
574 #endif /* not WINDOWSNT */
575 #endif /* not MSDOS */
578 /* Do this now if we did not do it before. */
580 save_signal_handlers (saved_handlers
);
584 wait_for_termination (pid
, &status
, 0);
586 restore_signal_handlers (saved_handlers
);
590 save_signal_handlers (struct save_signal
*saved_handlers
)
592 while (saved_handlers
->code
)
594 struct sigaction action
;
595 emacs_sigaction_init (&action
, SIG_IGN
);
596 sigaction (saved_handlers
->code
, &action
, &saved_handlers
->action
);
602 restore_signal_handlers (struct save_signal
*saved_handlers
)
604 while (saved_handlers
->code
)
606 sigaction (saved_handlers
->code
, &saved_handlers
->action
, 0);
612 static int old_fcntl_flags
[MAXDESC
];
619 old_fcntl_flags
[fd
] = fcntl (fd
, F_GETFL
, 0) & ~FASYNC
;
620 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
] | FASYNC
);
621 interrupts_deferred
= 0;
629 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
]);
642 sigemptyset (&unblocked
);
644 sigaddset (&unblocked
, SIGWINCH
);
646 sigaddset (&unblocked
, SIGIO
);
647 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
649 interrupts_deferred
= 0;
654 unrequest_sigio (void)
662 sigemptyset (&blocked
);
664 sigaddset (&blocked
, SIGWINCH
);
666 sigaddset (&blocked
, SIGIO
);
667 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
668 interrupts_deferred
= 1;
676 signal (SIGIO
, SIG_IGN
);
681 /* Saving and restoring the process group of Emacs's terminal. */
683 /* The process group of which Emacs was a member when it initially
686 If Emacs was in its own process group (i.e. inherited_pgroup ==
687 getpid ()), then we know we're running under a shell with job
688 control (Emacs would never be run as part of a pipeline).
691 If Emacs was not in its own process group, then we know we're
692 running under a shell (or a caller) that doesn't know how to
693 separate itself from Emacs (like sh). Emacs must be in its own
694 process group in order to receive SIGIO correctly. In this
695 situation, we put ourselves in our own pgroup, forcibly set the
696 tty's pgroup to our pgroup, and make sure to restore and reinstate
697 the tty's pgroup just like any other terminal setting. If
698 inherited_group was not the tty's pgroup, then we'll get a
699 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
700 it goes foreground in the future, which is what should happen. */
702 static pid_t inherited_pgroup
;
705 init_foreground_group (void)
707 pid_t pgrp
= getpgrp ();
708 inherited_pgroup
= getpid () == pgrp
? 0 : pgrp
;
711 /* Block and unblock SIGTTOU. */
714 block_tty_out_signal (void)
718 sigemptyset (&blocked
);
719 sigaddset (&blocked
, SIGTTOU
);
720 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
725 unblock_tty_out_signal (void)
728 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
732 /* Safely set a controlling terminal FD's process group to PGID.
733 If we are not in the foreground already, POSIX requires tcsetpgrp
734 to deliver a SIGTTOU signal, which would stop us. This is an
735 annoyance, so temporarily ignore the signal.
737 In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
738 skip all this unless SIGTTOU is defined. */
740 tcsetpgrp_without_stopping (int fd
, pid_t pgid
)
744 block_tty_out_signal ();
745 tcsetpgrp (fd
, pgid
);
746 unblock_tty_out_signal ();
751 /* Split off the foreground process group to Emacs alone. When we are
752 in the foreground, but not started in our own process group,
753 redirect the tty device handle FD to point to our own process
754 group. FD must be the file descriptor of the controlling tty. */
756 narrow_foreground_group (int fd
)
758 if (inherited_pgroup
&& setpgid (0, 0) == 0)
759 tcsetpgrp_without_stopping (fd
, getpid ());
762 /* Set the tty to our original foreground group. */
764 widen_foreground_group (int fd
)
766 if (inherited_pgroup
&& setpgid (0, inherited_pgroup
) == 0)
767 tcsetpgrp_without_stopping (fd
, inherited_pgroup
);
770 /* Getting and setting emacs_tty structures. */
772 /* Set *TC to the parameters associated with the terminal FD.
773 Return zero if all's well, or -1 if we ran into an error we
774 couldn't deal with. */
776 emacs_get_tty (int fd
, struct emacs_tty
*settings
)
778 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
780 /* We have those nifty POSIX tcmumbleattr functions. */
781 memset (&settings
->main
, 0, sizeof (settings
->main
));
782 if (tcgetattr (fd
, &settings
->main
) < 0)
786 /* We have survived the tempest. */
791 /* Set the parameters of the tty on FD according to the contents of
792 *SETTINGS. If FLUSHP is non-zero, we discard input.
793 Return 0 if all went well, and -1 if anything failed. */
796 emacs_set_tty (int fd
, struct emacs_tty
*settings
, int flushp
)
798 /* Set the primary parameters - baud rate, character size, etcetera. */
801 /* We have those nifty POSIX tcmumbleattr functions.
802 William J. Smith <wjs@wiis.wang.com> writes:
803 "POSIX 1003.1 defines tcsetattr to return success if it was
804 able to perform any of the requested actions, even if some
805 of the requested actions could not be performed.
806 We must read settings back to ensure tty setup properly.
807 AIX requires this to keep tty from hanging occasionally." */
808 /* This make sure that we don't loop indefinitely in here. */
809 for (i
= 0 ; i
< 10 ; i
++)
810 if (tcsetattr (fd
, flushp
? TCSAFLUSH
: TCSADRAIN
, &settings
->main
) < 0)
821 memset (&new, 0, sizeof (new));
822 /* Get the current settings, and see if they're what we asked for. */
823 tcgetattr (fd
, &new);
824 /* We cannot use memcmp on the whole structure here because under
825 * aix386 the termios structure has some reserved field that may
828 if ( new.c_iflag
== settings
->main
.c_iflag
829 && new.c_oflag
== settings
->main
.c_oflag
830 && new.c_cflag
== settings
->main
.c_cflag
831 && new.c_lflag
== settings
->main
.c_lflag
832 && memcmp (new.c_cc
, settings
->main
.c_cc
, NCCS
) == 0)
839 /* We have survived the tempest. */
846 static int old_fcntl_owner
[MAXDESC
];
847 #endif /* F_SETOWN */
849 /* This may also be defined in stdio,
850 but if so, this does no harm,
851 and using the same name avoids wasting the other one's space. */
854 unsigned char _sobuf
[BUFSIZ
+8];
859 /* Initialize the terminal mode on all tty devices that are currently
863 init_all_sys_modes (void)
865 struct tty_display_info
*tty
;
866 for (tty
= tty_list
; tty
; tty
= tty
->next
)
867 init_sys_modes (tty
);
870 /* Initialize the terminal mode on the given tty device. */
873 init_sys_modes (struct tty_display_info
*tty_out
)
875 struct emacs_tty tty
;
876 Lisp_Object terminal
;
878 Vtty_erase_char
= Qnil
;
883 if (!tty_out
->output
)
884 return; /* The tty is suspended. */
886 narrow_foreground_group (fileno (tty_out
->input
));
888 if (! tty_out
->old_tty
)
889 tty_out
->old_tty
= xmalloc (sizeof *tty_out
->old_tty
);
891 emacs_get_tty (fileno (tty_out
->input
), tty_out
->old_tty
);
893 tty
= *tty_out
->old_tty
;
895 #if !defined (DOS_NT)
896 XSETINT (Vtty_erase_char
, tty
.main
.c_cc
[VERASE
]);
898 tty
.main
.c_iflag
|= (IGNBRK
); /* Ignore break condition */
899 tty
.main
.c_iflag
&= ~ICRNL
; /* Disable map of CR to NL on input */
900 #ifdef INLCR /* I'm just being cautious,
901 since I can't check how widespread INLCR is--rms. */
902 tty
.main
.c_iflag
&= ~INLCR
; /* Disable map of NL to CR on input */
905 tty
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
907 tty
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
908 tty
.main
.c_lflag
&= ~ICANON
; /* Disable erase/kill processing */
910 tty
.main
.c_lflag
&= ~IEXTEN
; /* Disable other editing characters. */
912 tty
.main
.c_lflag
|= ISIG
; /* Enable signals */
913 if (tty_out
->flow_control
)
915 tty
.main
.c_iflag
|= IXON
; /* Enable start/stop output control */
917 tty
.main
.c_iflag
&= ~IXANY
;
921 tty
.main
.c_iflag
&= ~IXON
; /* Disable start/stop output control */
922 tty
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL
924 tty
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
926 if (tty_out
->meta_key
)
928 tty
.main
.c_cflag
|= CS8
; /* allow 8th bit on input */
929 tty
.main
.c_cflag
&= ~PARENB
;/* Don't check parity */
933 XSETTERMINAL(terminal
, tty_out
->terminal
);
934 if (!NILP (Fcontrolling_tty_p (terminal
)))
936 tty
.main
.c_cc
[VINTR
] = quit_char
; /* C-g (usually) gives SIGINT */
937 /* Set up C-g for both SIGQUIT and SIGINT.
938 We don't know which we will get, but we handle both alike
939 so which one it really gives us does not matter. */
940 tty
.main
.c_cc
[VQUIT
] = quit_char
;
944 /* We normally don't get interrupt or quit signals from tty
945 devices other than our controlling terminal; therefore,
946 we must handle C-g as normal input. Unfortunately, this
947 means that the interrupt and quit feature must be
948 disabled on secondary ttys, or we would not even see the
951 Note that even though emacsclient could have special code
952 to pass SIGINT to Emacs, we should _not_ enable
953 interrupt/quit keys for emacsclient frames. This means
954 that we can't break out of loops in C code from a
955 secondary tty frame, but we can always decide what
956 display the C-g came from, which is more important from a
957 usability point of view. (Consider the case when two
958 people work together using the same Emacs instance.) */
959 tty
.main
.c_cc
[VINTR
] = CDISABLE
;
960 tty
.main
.c_cc
[VQUIT
] = CDISABLE
;
962 tty
.main
.c_cc
[VMIN
] = 1; /* Input should wait for at least 1 char */
963 tty
.main
.c_cc
[VTIME
] = 0; /* no matter how long that takes. */
965 tty
.main
.c_cc
[VSWTCH
] = CDISABLE
; /* Turn off shell layering use
970 tty
.main
.c_cc
[VSUSP
] = CDISABLE
; /* Turn off handling of C-z. */
973 tty
.main
.c_cc
[V_DSUSP
] = CDISABLE
; /* Turn off handling of C-y. */
975 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
976 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
979 tty
.main
.c_cc
[VLNEXT
] = CDISABLE
;
982 tty
.main
.c_cc
[VREPRINT
] = CDISABLE
;
983 #endif /* VREPRINT */
985 tty
.main
.c_cc
[VWERASE
] = CDISABLE
;
988 tty
.main
.c_cc
[VDISCARD
] = CDISABLE
;
989 #endif /* VDISCARD */
991 if (tty_out
->flow_control
)
994 tty
.main
.c_cc
[VSTART
] = '\021';
997 tty
.main
.c_cc
[VSTOP
] = '\023';
1003 tty
.main
.c_cc
[VSTART
] = CDISABLE
;
1006 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1011 tty
.main
.c_cc
[VSTRT
] = CDISABLE
;
1012 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1013 tty
.main
.c_cc
[VSUSP
] = CDISABLE
;
1014 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1015 if (tty_out
->flow_control
)
1018 tty
.main
.c_cc
[VSTART
] = '\021';
1021 tty
.main
.c_cc
[VSTOP
] = '\023';
1024 /* Also, PTY overloads NUL and BREAK.
1025 don't ignore break, but don't signal either, so it looks like NUL.
1026 This really serves a purpose only if running in an XTERM window
1027 or via TELNET or the like, but does no harm elsewhere. */
1028 tty
.main
.c_iflag
&= ~IGNBRK
;
1029 tty
.main
.c_iflag
&= ~BRKINT
;
1031 #endif /* not DOS_NT */
1033 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1034 if (!tty_out
->term_initted
)
1035 internal_terminal_init ();
1036 dos_ttraw (tty_out
);
1039 emacs_set_tty (fileno (tty_out
->input
), &tty
, 0);
1041 /* This code added to insure that, if flow-control is not to be used,
1042 we have an unlocked terminal at the start. */
1045 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TCXONC
, 1);
1048 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TIOCSTART
, 0);
1051 #if !defined (DOS_NT)
1053 if (!tty_out
->flow_control
) tcflow (fileno (tty_out
->input
), TCOON
);
1058 if (interrupt_input
)
1060 old_fcntl_owner
[fileno (tty_out
->input
)] =
1061 fcntl (fileno (tty_out
->input
), F_GETOWN
, 0);
1062 fcntl (fileno (tty_out
->input
), F_SETOWN
, getpid ());
1063 init_sigio (fileno (tty_out
->input
));
1065 if (gpm_tty
== tty_out
)
1067 /* Arrange for mouse events to give us SIGIO signals. */
1068 fcntl (gpm_fd
, F_SETOWN
, getpid ());
1069 fcntl (gpm_fd
, F_SETFL
, fcntl (gpm_fd
, F_GETFL
, 0) | O_NONBLOCK
);
1070 init_sigio (gpm_fd
);
1072 #endif /* HAVE_GPM */
1074 #endif /* F_GETOWN */
1077 /* This symbol is defined on recent USG systems.
1078 Someone says without this call USG won't really buffer the file
1079 even with a call to setbuf. */
1080 setvbuf (tty_out
->output
, (char *) _sobuf
, _IOFBF
, sizeof _sobuf
);
1082 setbuf (tty_out
->output
, (char *) _sobuf
);
1085 if (tty_out
->terminal
->set_terminal_modes_hook
)
1086 tty_out
->terminal
->set_terminal_modes_hook (tty_out
->terminal
);
1088 if (!tty_out
->term_initted
)
1090 Lisp_Object tail
, frame
;
1091 FOR_EACH_FRAME (tail
, frame
)
1093 /* XXX This needs to be revised. */
1094 if (FRAME_TERMCAP_P (XFRAME (frame
))
1095 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1096 init_frame_faces (XFRAME (frame
));
1100 if (tty_out
->term_initted
&& no_redraw_on_reenter
)
1102 /* We used to call "direct_output_forward_char(0)" here,
1103 but it's not clear why, since it may not do anything anyway. */
1107 Lisp_Object tail
, frame
;
1109 FOR_EACH_FRAME (tail
, frame
)
1111 if ((FRAME_TERMCAP_P (XFRAME (frame
))
1112 || FRAME_MSDOS_P (XFRAME (frame
)))
1113 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1114 FRAME_GARBAGED_P (XFRAME (frame
)) = 1;
1118 tty_out
->term_initted
= 1;
1121 /* Return nonzero if safe to use tabs in output.
1122 At the time this is called, init_sys_modes has not been done yet. */
1125 tabs_safe_p (int fd
)
1127 struct emacs_tty etty
;
1129 emacs_get_tty (fd
, &etty
);
1132 return ((etty
.main
.c_oflag
& TABDLY
) != TAB3
);
1133 #else /* not TABDLY */
1135 #endif /* not TABDLY */
1141 /* Get terminal size from system.
1142 Store number of lines into *HEIGHTP and width into *WIDTHP.
1143 We store 0 if there's no valid information. */
1146 get_tty_size (int fd
, int *widthp
, int *heightp
)
1148 #if defined TIOCGWINSZ
1151 struct winsize size
;
1153 if (ioctl (fd
, TIOCGWINSZ
, &size
) == -1)
1154 *widthp
= *heightp
= 0;
1157 *widthp
= size
.ws_col
;
1158 *heightp
= size
.ws_row
;
1161 #elif defined TIOCGSIZE
1163 /* SunOS - style. */
1164 struct ttysize size
;
1166 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1167 *widthp
= *heightp
= 0;
1170 *widthp
= size
.ts_cols
;
1171 *heightp
= size
.ts_lines
;
1174 #elif defined WINDOWSNT
1176 CONSOLE_SCREEN_BUFFER_INFO info
;
1177 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE
), &info
))
1179 *widthp
= info
.srWindow
.Right
- info
.srWindow
.Left
+ 1;
1180 *heightp
= info
.srWindow
.Bottom
- info
.srWindow
.Top
+ 1;
1183 *widthp
= *heightp
= 0;
1187 *widthp
= ScreenCols ();
1188 *heightp
= ScreenRows ();
1190 #else /* system doesn't know size */
1198 /* Set the logical window size associated with descriptor FD
1199 to HEIGHT and WIDTH. This is used mainly with ptys. */
1202 set_window_size (int fd
, int height
, int width
)
1207 struct winsize size
;
1208 size
.ws_row
= height
;
1209 size
.ws_col
= width
;
1211 if (ioctl (fd
, TIOCSWINSZ
, &size
) == -1)
1212 return 0; /* error */
1219 /* SunOS - style. */
1220 struct ttysize size
;
1221 size
.ts_lines
= height
;
1222 size
.ts_cols
= width
;
1224 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1230 #endif /* not SunOS-style */
1231 #endif /* not BSD-style */
1236 /* Prepare all terminal devices for exiting Emacs. */
1239 reset_all_sys_modes (void)
1241 struct tty_display_info
*tty
;
1242 for (tty
= tty_list
; tty
; tty
= tty
->next
)
1243 reset_sys_modes (tty
);
1246 /* Prepare the terminal for closing it; move the cursor to the
1247 bottom of the frame, turn off interrupt-driven I/O, etc. */
1250 reset_sys_modes (struct tty_display_info
*tty_out
)
1257 if (!tty_out
->term_initted
)
1260 if (!tty_out
->output
)
1261 return; /* The tty is suspended. */
1263 /* Go to and clear the last line of the terminal. */
1265 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1267 /* Code adapted from tty_clear_end_of_line. */
1268 if (tty_out
->TS_clr_line
)
1270 emacs_tputs (tty_out
, tty_out
->TS_clr_line
, 1, cmputc
);
1273 { /* have to do it the hard way */
1275 tty_turn_off_insert (tty_out
);
1277 for (i
= curX (tty_out
); i
< FrameCols (tty_out
) - 1; i
++)
1279 fputc (' ', tty_out
->output
);
1283 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1284 fflush (tty_out
->output
);
1286 if (tty_out
->terminal
->reset_terminal_modes_hook
)
1287 tty_out
->terminal
->reset_terminal_modes_hook (tty_out
->terminal
);
1289 /* Avoid possible loss of output when changing terminal modes. */
1290 while (fdatasync (fileno (tty_out
->output
)) != 0 && errno
== EINTR
)
1295 if (interrupt_input
)
1297 reset_sigio (fileno (tty_out
->input
));
1298 fcntl (fileno (tty_out
->input
), F_SETOWN
,
1299 old_fcntl_owner
[fileno (tty_out
->input
)]);
1301 #endif /* F_SETOWN */
1302 fcntl (fileno (tty_out
->input
), F_SETFL
,
1303 fcntl (fileno (tty_out
->input
), F_GETFL
, 0) & ~O_NONBLOCK
);
1306 if (tty_out
->old_tty
)
1307 while (emacs_set_tty (fileno (tty_out
->input
),
1308 tty_out
->old_tty
, 0) < 0 && errno
== EINTR
)
1311 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1315 widen_foreground_group (fileno (tty_out
->input
));
1320 /* Set up the proper status flags for use of a pty. */
1325 /* I'm told that TOICREMOTE does not mean control chars
1326 "can't be sent" but rather that they don't have
1327 input-editing or signaling effects.
1328 That should be good, because we have other ways
1329 to do those things in Emacs.
1330 However, telnet mode seems not to work on 4.2.
1331 So TIOCREMOTE is turned off now. */
1333 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1334 will hang. In particular, the "timeout" feature (which
1335 causes a read to return if there is no data available)
1336 does this. Also it is known that telnet mode will hang
1337 in such a way that Emacs must be stopped (perhaps this
1338 is the same problem).
1340 If TIOCREMOTE is turned off, then there is a bug in
1341 hp-ux which sometimes loses data. Apparently the
1342 code which blocks the master process when the internal
1343 buffer fills up does not work. Other than this,
1344 though, everything else seems to work fine.
1346 Since the latter lossage is more benign, we may as well
1347 lose that way. -- cph */
1349 #if defined (UNIX98_PTYS)
1352 ioctl (fd
, FIONBIO
, &on
);
1357 #endif /* HAVE_PTYS */
1360 #include <sys/socket.h>
1362 #endif /* HAVE_SOCKETS */
1365 #ifndef HAVE_H_ERRNO
1368 #endif /* TRY_AGAIN */
1371 init_system_name (void)
1373 #ifndef HAVE_GETHOSTNAME
1376 Vsystem_name
= build_string (uts
.nodename
);
1377 #else /* HAVE_GETHOSTNAME */
1378 unsigned int hostname_size
= 256;
1379 char *hostname
= alloca (hostname_size
);
1381 /* Try to get the host name; if the buffer is too short, try
1382 again. Apparently, the only indication gethostname gives of
1383 whether the buffer was large enough is the presence or absence
1384 of a '\0' in the string. Eech. */
1387 gethostname (hostname
, hostname_size
- 1);
1388 hostname
[hostname_size
- 1] = '\0';
1390 /* Was the buffer large enough for the '\0'? */
1391 if (strlen (hostname
) < hostname_size
- 1)
1394 hostname_size
<<= 1;
1395 hostname
= alloca (hostname_size
);
1398 /* Turn the hostname into the official, fully-qualified hostname.
1399 Don't do this if we're going to dump; this can confuse system
1400 libraries on some machines and make the dumped emacs core dump. */
1403 #endif /* not CANNOT_DUMP */
1404 if (! strchr (hostname
, '.'))
1407 #ifdef HAVE_GETADDRINFO
1408 struct addrinfo
*res
;
1409 struct addrinfo hints
;
1412 memset (&hints
, 0, sizeof (hints
));
1413 hints
.ai_socktype
= SOCK_STREAM
;
1414 hints
.ai_flags
= AI_CANONNAME
;
1416 for (count
= 0;; count
++)
1418 if ((ret
= getaddrinfo (hostname
, NULL
, &hints
, &res
)) == 0
1419 || ret
!= EAI_AGAIN
)
1424 Fsleep_for (make_number (1), Qnil
);
1429 struct addrinfo
*it
= res
;
1432 char *fqdn
= it
->ai_canonname
;
1433 if (fqdn
&& strchr (fqdn
, '.')
1434 && strcmp (fqdn
, "localhost.localdomain") != 0)
1440 hostname
= alloca (strlen (it
->ai_canonname
) + 1);
1441 strcpy (hostname
, it
->ai_canonname
);
1445 #else /* !HAVE_GETADDRINFO */
1447 for (count
= 0;; count
++)
1453 hp
= gethostbyname (hostname
);
1455 if (! (hp
== 0 && h_errno
== TRY_AGAIN
))
1462 Fsleep_for (make_number (1), Qnil
);
1467 char *fqdn
= (char *) hp
->h_name
;
1469 if (!strchr (fqdn
, '.'))
1471 /* We still don't have a fully qualified domain name.
1472 Try to find one in the list of alternate names */
1473 char **alias
= hp
->h_aliases
;
1475 && (!strchr (*alias
, '.')
1476 || !strcmp (*alias
, "localhost.localdomain")))
1483 #endif /* !HAVE_GETADDRINFO */
1485 #endif /* HAVE_SOCKETS */
1486 Vsystem_name
= build_string (hostname
);
1487 #endif /* HAVE_GETHOSTNAME */
1490 for (p
= SDATA (Vsystem_name
); *p
; p
++)
1491 if (*p
== ' ' || *p
== '\t')
1496 sigset_t empty_mask
;
1498 static struct sigaction process_fatal_action
;
1501 emacs_sigaction_flags (void)
1504 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1505 'select') to reset their timeout on some platforms (e.g.,
1506 HP-UX 11), which is not what we want. Also, when Emacs is
1507 interactive, we don't want SA_RESTART because we need to poll
1508 for pending input so we need long-running syscalls to be interrupted
1509 after a signal that sets pending_signals.
1511 Non-interactive keyboard input goes through stdio, where we
1512 always want restartable system calls. */
1519 /* Store into *ACTION a signal action suitable for Emacs, with handler
1522 emacs_sigaction_init (struct sigaction
*action
, signal_handler_t handler
)
1524 sigemptyset (&action
->sa_mask
);
1526 /* When handling a signal, block nonfatal system signals that are caught
1527 by Emacs. This makes race conditions less likely. */
1528 sigaddset (&action
->sa_mask
, SIGALRM
);
1529 sigaddset (&action
->sa_mask
, SIGCHLD
);
1531 sigaddset (&action
->sa_mask
, SIGDANGER
);
1533 #ifdef PROFILER_CPU_SUPPORT
1534 sigaddset (&action
->sa_mask
, SIGPROF
);
1537 sigaddset (&action
->sa_mask
, SIGWINCH
);
1539 if (! noninteractive
)
1541 sigaddset (&action
->sa_mask
, SIGINT
);
1542 sigaddset (&action
->sa_mask
, SIGQUIT
);
1544 sigaddset (&action
->sa_mask
, SIGIO
);
1548 if (! IEEE_FLOATING_POINT
)
1549 sigaddset (&action
->sa_mask
, SIGFPE
);
1551 action
->sa_handler
= handler
;
1552 action
->sa_flags
= emacs_sigaction_flags ();
1555 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1556 static pthread_t main_thread
;
1559 /* SIG has arrived at the current process. Deliver it to the main
1560 thread, which should handle it with HANDLER.
1562 If we are on the main thread, handle the signal SIG with HANDLER.
1563 Otherwise, redirect the signal to the main thread, blocking it from
1564 this thread. POSIX says any thread can receive a signal that is
1565 associated with a process, process group, or asynchronous event.
1566 On GNU/Linux that is not true, but for other systems (FreeBSD at
1569 deliver_process_signal (int sig
, signal_handler_t handler
)
1571 /* Preserve errno, to avoid race conditions with signal handlers that
1572 might change errno. Races can occur even in single-threaded hosts. */
1573 int old_errno
= errno
;
1575 bool on_main_thread
= true;
1576 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1577 if (! pthread_equal (pthread_self (), main_thread
))
1580 sigemptyset (&blocked
);
1581 sigaddset (&blocked
, sig
);
1582 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1583 pthread_kill (main_thread
, sig
);
1584 on_main_thread
= false;
1593 /* Static location to save a fatal backtrace in a thread.
1594 FIXME: If two subsidiary threads fail simultaneously, the resulting
1595 backtrace may be garbage. */
1596 enum { BACKTRACE_LIMIT_MAX
= 500 };
1597 static void *thread_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
1598 static int thread_backtrace_npointers
;
1600 /* SIG has arrived at the current thread.
1601 If we are on the main thread, handle the signal SIG with HANDLER.
1602 Otherwise, this is a fatal error in the handling thread. */
1604 deliver_thread_signal (int sig
, signal_handler_t handler
)
1606 int old_errno
= errno
;
1608 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1609 if (! pthread_equal (pthread_self (), main_thread
))
1611 thread_backtrace_npointers
1612 = backtrace (thread_backtrace_buffer
, BACKTRACE_LIMIT_MAX
);
1613 sigaction (sig
, &process_fatal_action
, 0);
1614 pthread_kill (main_thread
, sig
);
1616 /* Avoid further damage while the main thread is exiting. */
1618 sigsuspend (&empty_mask
);
1626 #if !HAVE_DECL_SYS_SIGLIST
1628 # ifdef _sys_siglist
1629 # define sys_siglist _sys_siglist
1630 # elif HAVE_DECL___SYS_SIGLIST
1631 # define sys_siglist __sys_siglist
1633 # define sys_siglist my_sys_siglist
1634 static char const *sys_siglist
[NSIG
];
1639 # define sys_siglist_entries _sys_nsig
1641 # define sys_siglist_entries NSIG
1644 /* Handle bus errors, invalid instruction, etc. */
1646 handle_fatal_signal (int sig
)
1648 terminate_due_to_signal (sig
, 40);
1652 deliver_fatal_signal (int sig
)
1654 deliver_process_signal (sig
, handle_fatal_signal
);
1658 deliver_fatal_thread_signal (int sig
)
1660 deliver_thread_signal (sig
, handle_fatal_signal
);
1663 static _Noreturn
void
1664 handle_arith_signal (int sig
)
1666 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1667 xsignal0 (Qarith_error
);
1671 deliver_arith_signal (int sig
)
1673 deliver_thread_signal (sig
, handle_arith_signal
);
1678 /* Handler for SIGDANGER. */
1680 handle_danger_signal (int sig
)
1682 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1684 /* It might be unsafe to call do_auto_save now. */
1685 force_auto_save_soon ();
1689 deliver_danger_signal (int sig
)
1691 deliver_process_signal (sig
, handle_danger_signal
);
1695 /* Treat SIG as a terminating signal, unless it is already ignored and
1696 we are in --batch mode. Among other things, this makes nohup work. */
1698 maybe_fatal_sig (int sig
)
1700 bool catch_sig
= !noninteractive
;
1703 struct sigaction old_action
;
1704 sigaction (sig
, 0, &old_action
);
1705 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1708 sigaction (sig
, &process_fatal_action
, 0);
1712 init_signals (bool dumping
)
1714 struct sigaction thread_fatal_action
;
1715 struct sigaction action
;
1717 sigemptyset (&empty_mask
);
1719 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1720 main_thread
= pthread_self ();
1723 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1726 sys_siglist
[SIGABRT
] = "Aborted";
1728 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1730 sys_siglist
[SIGALRM
] = "Alarm clock";
1732 sys_siglist
[SIGBUS
] = "Bus error";
1734 sys_siglist
[SIGCHLD
] = "Child status changed";
1736 sys_siglist
[SIGCONT
] = "Continued";
1739 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1742 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1745 sys_siglist
[SIGEMT
] = "Emulation trap";
1747 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1749 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1752 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1754 sys_siglist
[SIGHUP
] = "Hangup";
1755 sys_siglist
[SIGILL
] = "Illegal instruction";
1756 sys_siglist
[SIGINT
] = "Interrupt";
1758 sys_siglist
[SIGIO
] = "I/O possible";
1761 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1764 sys_siglist
[SIGIOT
] = "IOT trap";
1766 sys_siglist
[SIGKILL
] = "Killed";
1768 sys_siglist
[SIGLOST
] = "Resource lost";
1771 sys_siglist
[SIGLWP
] = "SIGLWP";
1774 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1777 sys_siglist
[SIGWIND
] = "SIGPHONE";
1779 sys_siglist
[SIGPIPE
] = "Broken pipe";
1781 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1784 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1787 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1790 sys_siglist
[SIGPWR
] = "Power-fail restart";
1792 sys_siglist
[SIGQUIT
] = "Quit";
1794 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1797 sys_siglist
[SIGSAK
] = "Secure attention";
1799 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1801 sys_siglist
[SIGSOUND
] = "Sound completed";
1804 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1807 sys_siglist
[SIGSTP
] = "Stopped (user)";
1810 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1812 sys_siglist
[SIGTERM
] = "Terminated";
1814 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1817 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1820 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1823 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1826 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1829 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1832 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1835 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1838 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1841 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1844 sys_siglist
[SIGWINCH
] = "Window size changed";
1847 sys_siglist
[SIGWIND
] = "SIGWIND";
1850 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1853 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1856 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1858 /* Don't alter signal handlers if dumping. On some machines,
1859 changing signal handlers sets static data that would make signals
1860 fail to work right when the dumped Emacs is run. */
1864 sigfillset (&process_fatal_action
.sa_mask
);
1865 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1866 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1868 sigfillset (&thread_fatal_action
.sa_mask
);
1869 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1870 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1872 /* SIGINT may need special treatment on MS-Windows. See
1873 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1874 Please update the doc of kill-emacs, kill-emacs-hook, and
1875 NEWS if you change this. */
1877 maybe_fatal_sig (SIGHUP
);
1878 maybe_fatal_sig (SIGINT
);
1879 maybe_fatal_sig (SIGTERM
);
1881 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1882 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1883 to behave more like typical batch applications do. */
1884 if (! noninteractive
)
1885 signal (SIGPIPE
, SIG_IGN
);
1887 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1888 sigaction (SIGILL
, &thread_fatal_action
, 0);
1889 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1891 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1892 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1893 interpreter's floating point operations, so treat SIGFPE as an
1894 arith-error if it arises in the main thread. */
1895 if (IEEE_FLOATING_POINT
)
1896 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1899 emacs_sigaction_init (&action
, deliver_arith_signal
);
1900 sigaction (SIGFPE
, &action
, 0);
1904 add_user_signal (SIGUSR1
, "sigusr1");
1907 add_user_signal (SIGUSR2
, "sigusr2");
1909 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1911 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1914 sigaction (SIGORE
, &thread_fatal_action
, 0);
1917 sigaction (SIGUME
, &thread_fatal_action
, 0);
1920 sigaction (SIGDLK
, &process_fatal_action
, 0);
1923 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1926 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1929 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1932 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1934 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
1936 sigaction (SIGSYS
, &thread_fatal_action
, 0);
1938 sigaction (SIGTERM
, &process_fatal_action
, 0);
1940 signal (SIGPROF
, SIG_IGN
);
1943 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
1946 sigaction (SIGXCPU
, &process_fatal_action
, 0);
1949 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
1953 /* This just means available memory is getting low. */
1954 emacs_sigaction_init (&action
, deliver_danger_signal
);
1955 sigaction (SIGDANGER
, &action
, 0);
1958 /* AIX-specific signals. */
1960 sigaction (SIGGRANT
, &process_fatal_action
, 0);
1963 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
1966 sigaction (SIGMSG
, &process_fatal_action
, 0);
1969 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
1972 sigaction (SIGSAK
, &process_fatal_action
, 0);
1975 sigaction (SIGSOUND
, &process_fatal_action
, 0);
1978 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
1988 /* Figure out how many bits the system's random number generator uses.
1989 `random' and `lrand48' are assumed to return 31 usable bits.
1990 BSD `rand' returns a 31 bit value but the low order bits are unusable;
1991 so we'll shift it and treat it like the 15-bit USG `rand'. */
1995 # define RAND_BITS 31
1996 # else /* !HAVE_RANDOM */
1997 # ifdef HAVE_LRAND48
1998 # define RAND_BITS 31
1999 # define random lrand48
2000 # else /* !HAVE_LRAND48 */
2001 # define RAND_BITS 15
2002 # if RAND_MAX == 32767
2003 # define random rand
2004 # else /* RAND_MAX != 32767 */
2005 # if RAND_MAX == 2147483647
2006 # define random() (rand () >> 16)
2007 # else /* RAND_MAX != 2147483647 */
2009 # define random rand
2011 # define random() (rand () >> 16)
2013 # endif /* RAND_MAX != 2147483647 */
2014 # endif /* RAND_MAX != 32767 */
2015 # endif /* !HAVE_LRAND48 */
2016 # endif /* !HAVE_RANDOM */
2017 #endif /* !RAND_BITS */
2020 seed_random (void *seed
, ptrdiff_t seed_size
)
2022 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
2023 unsigned int arg
= 0;
2027 unsigned char *argp
= (unsigned char *) &arg
;
2028 unsigned char *seedp
= seed
;
2030 for (i
= 0; i
< seed_size
; i
++)
2031 argp
[i
% sizeof arg
] ^= seedp
[i
];
2035 # ifdef HAVE_LRAND48
2046 EMACS_TIME t
= current_emacs_time ();
2047 uintmax_t v
= getpid () ^ EMACS_SECS (t
) ^ EMACS_NSECS (t
);
2048 seed_random (&v
, sizeof v
);
2052 * Return a nonnegative random integer out of whatever we've got.
2053 * It contains enough bits to make a random (signed) Emacs fixnum.
2054 * This suffices even for a 64-bit architecture with a 15-bit rand.
2061 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2062 val
= (random () ^ (val
<< RAND_BITS
)
2063 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2064 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2065 return val
& INTMASK
;
2068 #ifndef HAVE_SNPRINTF
2069 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2071 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2073 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2074 ptrdiff_t nbytes
= size
- 1;
2079 va_start (ap
, format
);
2080 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2084 if (nbytes
== size
- 1)
2086 /* Calculate the length of the string that would have been created
2087 had the buffer been large enough. */
2088 char stackbuf
[4000];
2090 ptrdiff_t bsize
= sizeof stackbuf
;
2091 va_start (ap
, format
);
2092 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2098 if (INT_MAX
< nbytes
)
2111 /* If a backtrace is available, output the top lines of it to stderr.
2112 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2113 This function may be called from a signal handler, so it should
2114 not invoke async-unsafe functions like malloc. */
2116 emacs_backtrace (int backtrace_limit
)
2118 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2119 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2123 if (thread_backtrace_npointers
)
2125 buffer
= thread_backtrace_buffer
;
2126 npointers
= thread_backtrace_npointers
;
2130 buffer
= main_backtrace_buffer
;
2131 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2136 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2137 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2138 if (bounded_limit
< npointers
)
2139 emacs_write (STDERR_FILENO
, "...\n", 4);
2147 terminate_due_to_signal (SIGABRT
, 40);
2151 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2152 Arrange for subprograms to not inherit the file descriptor.
2153 Prefer a method that is multithread-safe, if available.
2154 Do not fail merely because the open was interrupted by a signal.
2155 Allow the user to quit. */
2158 emacs_open (const char *file
, int oflags
, int mode
)
2161 oflags
|= O_CLOEXEC
;
2162 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2164 if (! O_CLOEXEC
&& 0 <= fd
)
2165 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2169 /* Open FILE as a stream for Emacs use, with mode MODE.
2170 Act like emacs_open with respect to threads, signals, and quits. */
2173 emacs_fopen (char const *file
, char const *mode
)
2175 int fd
, omode
, oflags
;
2177 char const *m
= mode
;
2181 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2182 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2183 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2184 default: emacs_abort ();
2190 case '+': omode
= O_RDWR
; break;
2191 case 'b': bflag
= O_BINARY
; break;
2192 case 't': bflag
= O_TEXT
; break;
2193 default: /* Ignore. */ break;
2196 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2197 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2201 emacs_close (int fd
)
2204 register int rtnval
;
2206 while ((rtnval
= close (fd
)) == -1
2207 && (errno
== EINTR
))
2210 /* If close is interrupted SunOS 4.1 may or may not have closed the
2211 file descriptor. If it did the second close will fail with
2212 errno = EBADF. That means we have succeeded. */
2213 if (rtnval
== -1 && did_retry
&& errno
== EBADF
)
2219 /* Maximum number of bytes to read or write in a single system call.
2220 This works around a serious bug in Linux kernels before 2.6.16; see
2221 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2222 It's likely to work around similar bugs in other operating systems, so do it
2223 on all platforms. Round INT_MAX down to a page size, with the conservative
2224 assumption that page sizes are at most 2**18 bytes (any kernel with a
2225 page size larger than that shouldn't have the bug). */
2226 #ifndef MAX_RW_COUNT
2227 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2230 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2231 Return the number of bytes read, which might be less than NBYTE.
2232 On error, set errno and return -1. */
2234 emacs_read (int fildes
, char *buf
, ptrdiff_t nbyte
)
2236 register ssize_t rtnval
;
2238 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2239 passes a size that large to emacs_read. */
2241 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2242 && (errno
== EINTR
))
2247 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2248 or if a partial write occurs. If interrupted, process pending
2249 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2250 errno if this is less than NBYTE. */
2252 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2253 bool process_signals
)
2255 ptrdiff_t bytes_written
= 0;
2259 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2265 /* I originally used `QUIT' but that might causes files to
2266 be truncated if you hit C-g in the middle of it. --Stef */
2267 if (process_signals
&& pending_signals
)
2268 process_pending_signals ();
2280 return bytes_written
;
2283 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2284 interrupted or if a partial write occurs. Return the number of
2285 bytes written, setting errno if this is less than NBYTE. */
2287 emacs_write (int fildes
, char const *buf
, ptrdiff_t nbyte
)
2289 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2292 /* Like emacs_write, but also process pending signals if interrupted. */
2294 emacs_write_sig (int fildes
, char const *buf
, ptrdiff_t nbyte
)
2296 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2299 /* Write a diagnostic to standard error that contains MESSAGE and a
2300 string derived from errno. Preserve errno. Do not buffer stderr.
2301 Do not process pending signals if interrupted. */
2303 emacs_perror (char const *message
)
2306 char const *error_string
= strerror (err
);
2307 char const *command
= (initial_argv
&& initial_argv
[0]
2308 ? initial_argv
[0] : "emacs");
2309 /* Write it out all at once, if it's short; this is less likely to
2310 be interleaved with other output. */
2312 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2313 command
, message
, error_string
);
2314 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2315 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2318 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2319 emacs_write (STDERR_FILENO
, ": ", 2);
2320 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2321 emacs_write (STDERR_FILENO
, ": ", 2);
2322 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2323 emacs_write (STDERR_FILENO
, "\n", 1);
2328 /* Return a struct timeval that is roughly equivalent to T.
2329 Use the least timeval not less than T.
2330 Return an extremal value if the result would overflow. */
2332 make_timeval (EMACS_TIME t
)
2335 tv
.tv_sec
= t
.tv_sec
;
2336 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2338 if (t
.tv_nsec
% 1000 != 0)
2340 if (tv
.tv_usec
< 999999)
2342 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2352 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2353 ATIME and MTIME, respectively.
2354 FD must be either negative -- in which case it is ignored --
2355 or a file descriptor that is open on FILE.
2356 If FD is nonnegative, then FILE can be NULL. */
2358 set_file_times (int fd
, const char *filename
,
2359 EMACS_TIME atime
, EMACS_TIME mtime
)
2361 struct timespec timespec
[2];
2362 timespec
[0] = atime
;
2363 timespec
[1] = mtime
;
2364 return fdutimens (fd
, filename
, timespec
);
2367 /* Like strsignal, except async-signal-safe, and this function typically
2368 returns a string in the C locale rather than the current locale. */
2370 safe_strsignal (int code
)
2372 char const *signame
= 0;
2374 if (0 <= code
&& code
< sys_siglist_entries
)
2375 signame
= sys_siglist
[code
];
2377 signame
= "Unknown signal";
2383 /* For make-serial-process */
2385 serial_open (char *port
)
2387 int fd
= emacs_open (port
, O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2390 error ("Could not open %s: %s",
2391 port
, emacs_strerror (errno
));
2394 ioctl (fd
, TIOCEXCL
, (char *) 0);
2400 #if !defined (HAVE_CFMAKERAW)
2401 /* Workaround for targets which are missing cfmakeraw. */
2402 /* Pasted from man page. */
2404 cfmakeraw (struct termios
*termios_p
)
2406 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2407 termios_p
->c_oflag
&= ~OPOST
;
2408 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2409 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2410 termios_p
->c_cflag
|= CS8
;
2412 #endif /* !defined (HAVE_CFMAKERAW */
2414 #if !defined (HAVE_CFSETSPEED)
2415 /* Workaround for targets which are missing cfsetspeed. */
2417 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2419 return (cfsetispeed (termios_p
, vitesse
)
2420 + cfsetospeed (termios_p
, vitesse
));
2424 /* For serial-process-configure */
2426 serial_configure (struct Lisp_Process
*p
,
2427 Lisp_Object contact
)
2429 Lisp_Object childp2
= Qnil
;
2430 Lisp_Object tem
= Qnil
;
2431 struct termios attr
;
2433 char summary
[4] = "???"; /* This usually becomes "8N1". */
2435 childp2
= Fcopy_sequence (p
->childp
);
2437 /* Read port attributes and prepare default configuration. */
2438 err
= tcgetattr (p
->outfd
, &attr
);
2440 error ("tcgetattr() failed: %s", emacs_strerror (errno
));
2442 #if defined (CLOCAL)
2443 attr
.c_cflag
|= CLOCAL
;
2446 attr
.c_cflag
|= CREAD
;
2449 /* Configure speed. */
2450 if (!NILP (Fplist_member (contact
, QCspeed
)))
2451 tem
= Fplist_get (contact
, QCspeed
);
2453 tem
= Fplist_get (p
->childp
, QCspeed
);
2455 err
= cfsetspeed (&attr
, XINT (tem
));
2457 error ("cfsetspeed(%"pI
"d) failed: %s", XINT (tem
),
2458 emacs_strerror (errno
));
2459 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2461 /* Configure bytesize. */
2462 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2463 tem
= Fplist_get (contact
, QCbytesize
);
2465 tem
= Fplist_get (p
->childp
, QCbytesize
);
2467 tem
= make_number (8);
2469 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2470 error (":bytesize must be nil (8), 7, or 8");
2471 summary
[0] = XINT (tem
) + '0';
2472 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2473 attr
.c_cflag
&= ~CSIZE
;
2474 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2476 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2477 if (XINT (tem
) != 8)
2478 error ("Bytesize cannot be changed");
2480 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2482 /* Configure parity. */
2483 if (!NILP (Fplist_member (contact
, QCparity
)))
2484 tem
= Fplist_get (contact
, QCparity
);
2486 tem
= Fplist_get (p
->childp
, QCparity
);
2487 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2488 error (":parity must be nil (no parity), `even', or `odd'");
2489 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2490 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2491 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2496 else if (EQ (tem
, Qeven
))
2499 attr
.c_cflag
|= PARENB
;
2500 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2502 else if (EQ (tem
, Qodd
))
2505 attr
.c_cflag
|= (PARENB
| PARODD
);
2506 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2509 /* Don't error on no parity, which should be set by cfmakeraw. */
2511 error ("Parity cannot be configured");
2513 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2515 /* Configure stopbits. */
2516 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2517 tem
= Fplist_get (contact
, QCstopbits
);
2519 tem
= Fplist_get (p
->childp
, QCstopbits
);
2521 tem
= make_number (1);
2523 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2524 error (":stopbits must be nil (1 stopbit), 1, or 2");
2525 summary
[2] = XINT (tem
) + '0';
2526 #if defined (CSTOPB)
2527 attr
.c_cflag
&= ~CSTOPB
;
2528 if (XINT (tem
) == 2)
2529 attr
.c_cflag
|= CSTOPB
;
2531 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2532 if (XINT (tem
) != 1)
2533 error ("Stopbits cannot be configured");
2535 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2537 /* Configure flowcontrol. */
2538 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2539 tem
= Fplist_get (contact
, QCflowcontrol
);
2541 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2542 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2543 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2544 #if defined (CRTSCTS)
2545 attr
.c_cflag
&= ~CRTSCTS
;
2547 #if defined (CNEW_RTSCTS)
2548 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2550 #if defined (IXON) && defined (IXOFF)
2551 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2555 /* Already configured. */
2557 else if (EQ (tem
, Qhw
))
2559 #if defined (CRTSCTS)
2560 attr
.c_cflag
|= CRTSCTS
;
2561 #elif defined (CNEW_RTSCTS)
2562 attr
.c_cflag
|= CNEW_RTSCTS
;
2564 error ("Hardware flowcontrol (RTS/CTS) not supported");
2567 else if (EQ (tem
, Qsw
))
2569 #if defined (IXON) && defined (IXOFF)
2570 attr
.c_iflag
|= (IXON
| IXOFF
);
2572 error ("Software flowcontrol (XON/XOFF) not supported");
2575 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2577 /* Activate configuration. */
2578 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2580 error ("tcsetattr() failed: %s", emacs_strerror (errno
));
2582 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2583 pset_childp (p
, childp2
);
2585 #endif /* not DOS_NT */
2587 /* System depended enumeration of and access to system processes a-la ps(1). */
2591 /* Process enumeration and access via /proc. */
2594 list_system_processes (void)
2596 Lisp_Object procdir
, match
, proclist
, next
;
2597 struct gcpro gcpro1
, gcpro2
;
2598 register Lisp_Object tail
;
2600 GCPRO2 (procdir
, match
);
2601 /* For every process on the system, there's a directory in the
2602 "/proc" pseudo-directory whose name is the numeric ID of that
2604 procdir
= build_string ("/proc");
2605 match
= build_string ("[0-9]+");
2606 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2608 /* `proclist' gives process IDs as strings. Destructively convert
2609 each string into a number. */
2610 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2613 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2617 /* directory_files_internal returns the files in reverse order; undo
2619 proclist
= Fnreverse (proclist
);
2623 #elif defined DARWIN_OS || defined __FreeBSD__
2626 list_system_processes (void)
2629 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2631 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2634 struct kinfo_proc
*procs
;
2637 struct gcpro gcpro1
;
2638 Lisp_Object proclist
= Qnil
;
2640 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2643 procs
= xmalloc (len
);
2644 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2651 len
/= sizeof (struct kinfo_proc
);
2652 for (i
= 0; i
< len
; i
++)
2655 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2657 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2667 /* The WINDOWSNT implementation is in w32.c.
2668 The MSDOS implementation is in dosfns.c. */
2669 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2672 list_system_processes (void)
2677 #endif /* !defined (WINDOWSNT) */
2681 time_from_jiffies (unsigned long long tval
, long hz
)
2683 unsigned long long s
= tval
/ hz
;
2684 unsigned long long frac
= tval
% hz
;
2687 if (TYPE_MAXIMUM (time_t) < s
)
2689 if (LONG_MAX
- 1 <= ULLONG_MAX
/ EMACS_TIME_RESOLUTION
2690 || frac
<= ULLONG_MAX
/ EMACS_TIME_RESOLUTION
)
2691 ns
= frac
* EMACS_TIME_RESOLUTION
/ hz
;
2694 /* This is reachable only in the unlikely case that HZ * HZ
2695 exceeds ULLONG_MAX. It calculates an approximation that is
2696 guaranteed to be in range. */
2697 long hz_per_ns
= (hz
/ EMACS_TIME_RESOLUTION
2698 + (hz
% EMACS_TIME_RESOLUTION
!= 0));
2699 ns
= frac
/ hz_per_ns
;
2702 return make_emacs_time (s
, ns
);
2706 ltime_from_jiffies (unsigned long long tval
, long hz
)
2708 EMACS_TIME t
= time_from_jiffies (tval
, hz
);
2709 return make_lisp_time (t
);
2716 EMACS_TIME up
= make_emacs_time (0, 0);
2719 fup
= emacs_fopen ("/proc/uptime", "r");
2723 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2724 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2726 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2727 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2728 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2731 if (TYPE_MAXIMUM (time_t) < upsec
)
2733 upsec
= TYPE_MAXIMUM (time_t);
2734 upfrac
= EMACS_TIME_RESOLUTION
- 1;
2738 int upfraclen
= upfrac_end
- upfrac_start
;
2739 for (; upfraclen
< LOG10_EMACS_TIME_RESOLUTION
; upfraclen
++)
2741 for (; LOG10_EMACS_TIME_RESOLUTION
< upfraclen
; upfraclen
--)
2743 upfrac
= min (upfrac
, EMACS_TIME_RESOLUTION
- 1);
2745 up
= make_emacs_time (upsec
, upfrac
);
2754 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2755 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2758 procfs_ttyname (int rdev
)
2761 char name
[PATH_MAX
];
2764 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2769 unsigned long minor_beg
, minor_end
;
2770 char minor
[25]; /* 2 32-bit numbers + dash */
2773 while (!feof (fdev
) && !ferror (fdev
))
2775 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2776 && major
== MAJOR (rdev
))
2778 minor_beg
= strtoul (minor
, &endp
, 0);
2780 minor_end
= minor_beg
;
2781 else if (*endp
== '-')
2782 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2786 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2788 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2796 return build_string (name
);
2799 static unsigned long
2800 procfs_get_total_memory (void)
2803 unsigned long retval
= 2 * 1024 * 1024; /* default: 2GB */
2806 fmem
= emacs_fopen ("/proc/meminfo", "r");
2810 unsigned long entry_value
;
2811 char entry_name
[20]; /* the longest I saw is 13+1 */
2813 while (!feof (fmem
) && !ferror (fmem
))
2815 if (fscanf (fmem
, "%s %lu kB\n", entry_name
, &entry_value
) >= 2
2816 && strcmp (entry_name
, "MemTotal:") == 0)
2818 retval
= entry_value
;
2829 system_process_attributes (Lisp_Object pid
)
2831 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
2835 long clocks_per_sec
;
2837 char procbuf
[1025], *p
, *q
;
2840 static char const default_cmd
[] = "???";
2841 const char *cmd
= default_cmd
;
2842 int cmdsize
= sizeof default_cmd
- 1;
2843 char *cmdline
= NULL
;
2844 ptrdiff_t cmdline_size
;
2847 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
2850 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
2851 long priority
, niceness
, rss
;
2852 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
2853 EMACS_TIME tnow
, tstart
, tboot
, telapsed
, us_time
;
2855 Lisp_Object attrs
= Qnil
;
2856 Lisp_Object cmd_str
, decoded_cmd
, tem
;
2857 struct gcpro gcpro1
, gcpro2
;
2859 CHECK_NUMBER_OR_FLOAT (pid
);
2860 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
2861 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
2862 if (stat (procfn
, &st
) < 0)
2865 GCPRO2 (attrs
, decoded_cmd
);
2869 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
2871 pw
= getpwuid (uid
);
2874 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
2877 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
2879 gr
= getgrgid (gid
);
2882 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
2884 strcpy (fn
, procfn
);
2885 procfn_end
= fn
+ strlen (fn
);
2886 strcpy (procfn_end
, "/stat");
2887 fd
= emacs_open (fn
, O_RDONLY
, 0);
2888 if (fd
>= 0 && (nread
= emacs_read (fd
, procbuf
, sizeof (procbuf
) - 1)) > 0)
2890 procbuf
[nread
] = '\0';
2893 p
= strchr (p
, '(');
2896 q
= strrchr (p
+ 1, ')');
2906 /* Command name is encoded in locale-coding-system; decode it. */
2907 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
2908 decoded_cmd
= code_convert_string_norecord (cmd_str
,
2909 Vlocale_coding_system
, 0);
2910 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
2914 EMACS_INT ppid_eint
, pgrp_eint
, sess_eint
, tpgid_eint
, thcount_eint
;
2916 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt utime stime cutime cstime priority nice thcount . start vsize rss */
2917 sscanf (p
, "%c %d %d %d %d %d %*u %lu %lu %lu %lu %Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld",
2918 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
2919 &minflt
, &cminflt
, &majflt
, &cmajflt
,
2920 &u_time
, &s_time
, &cutime
, &cstime
,
2921 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
);
2926 state_str
[1] = '\0';
2927 tem
= build_string (state_str
);
2928 attrs
= Fcons (Fcons (Qstate
, tem
), attrs
);
2930 /* Stops GCC whining about limited range of data type. */
2935 thcount_eint
= thcount
;
2936 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid_eint
)), attrs
);
2937 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp_eint
)), attrs
);
2938 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess_eint
)), attrs
);
2939 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
2940 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid_eint
)), attrs
);
2941 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
2942 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
2943 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)), attrs
);
2944 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)), attrs
);
2945 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
2946 if (clocks_per_sec
< 0)
2947 clocks_per_sec
= 100;
2948 attrs
= Fcons (Fcons (Qutime
,
2949 ltime_from_jiffies (u_time
, clocks_per_sec
)),
2951 attrs
= Fcons (Fcons (Qstime
,
2952 ltime_from_jiffies (s_time
, clocks_per_sec
)),
2954 attrs
= Fcons (Fcons (Qtime
,
2955 ltime_from_jiffies (s_time
+ u_time
,
2958 attrs
= Fcons (Fcons (Qcutime
,
2959 ltime_from_jiffies (cutime
, clocks_per_sec
)),
2961 attrs
= Fcons (Fcons (Qcstime
,
2962 ltime_from_jiffies (cstime
, clocks_per_sec
)),
2964 attrs
= Fcons (Fcons (Qctime
,
2965 ltime_from_jiffies (cstime
+cutime
, clocks_per_sec
)),
2967 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
2968 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
2969 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount_eint
)), attrs
);
2970 tnow
= current_emacs_time ();
2971 telapsed
= get_up_time ();
2972 tboot
= sub_emacs_time (tnow
, telapsed
);
2973 tstart
= time_from_jiffies (start
, clocks_per_sec
);
2974 tstart
= add_emacs_time (tboot
, tstart
);
2975 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
2976 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/1024)), attrs
);
2977 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4*rss
)), attrs
);
2978 telapsed
= sub_emacs_time (tnow
, tstart
);
2979 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
2980 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
2981 pcpu
= (EMACS_TIME_TO_DOUBLE (us_time
)
2982 / EMACS_TIME_TO_DOUBLE (telapsed
));
2985 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
2986 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
2989 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
2996 strcpy (procfn_end
, "/cmdline");
2997 fd
= emacs_open (fn
, O_RDONLY
, 0);
3001 for (cmdline_size
= 0; cmdline_size
< STRING_BYTES_BOUND
; cmdline_size
++)
3003 if (emacs_read (fd
, &ch
, 1) != 1)
3006 if (c_isspace (c
) || c
== '\\')
3007 cmdline_size
++; /* for later quoting, see below */
3011 cmdline
= xmalloc (cmdline_size
+ 1);
3012 lseek (fd
, 0L, SEEK_SET
);
3014 if ((nread
= read (fd
, cmdline
, cmdline_size
)) >= 0)
3015 cmdline
[nread
++] = '\0';
3018 /* Assigning zero to `nread' makes us skip the following
3019 two loops, assign zero to cmdline_size, and enter the
3020 following `if' clause that handles unknown command
3024 /* We don't want trailing null characters. */
3025 for (p
= cmdline
+ nread
; p
> cmdline
+ 1 && !p
[-1]; p
--)
3027 for (p
= cmdline
; p
< cmdline
+ nread
; p
++)
3029 /* Escape-quote whitespace and backslashes. */
3030 if (c_isspace (*p
) || *p
== '\\')
3032 memmove (p
+ 1, p
, nread
- (p
- cmdline
));
3036 else if (*p
== '\0')
3039 cmdline_size
= nread
;
3043 cmdline_size
= cmdsize
+ 2;
3044 cmdline
= xmalloc (cmdline_size
+ 1);
3045 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3048 /* Command line is encoded in locale-coding-system; decode it. */
3049 cmd_str
= make_unibyte_string (cmdline
, cmdline_size
);
3050 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3051 Vlocale_coding_system
, 0);
3053 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3060 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3062 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3063 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3064 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3065 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3066 #undef _FILE_OFFSET_BITS
3068 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3073 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3074 #define _FILE_OFFSET_BITS 64
3075 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3077 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3080 system_process_attributes (Lisp_Object pid
)
3082 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3087 struct psinfo pinfo
;
3093 Lisp_Object attrs
= Qnil
;
3094 Lisp_Object decoded_cmd
, tem
;
3095 struct gcpro gcpro1
, gcpro2
;
3097 CHECK_NUMBER_OR_FLOAT (pid
);
3098 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3099 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3100 if (stat (procfn
, &st
) < 0)
3103 GCPRO2 (attrs
, decoded_cmd
);
3107 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3109 pw
= getpwuid (uid
);
3112 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3115 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3117 gr
= getgrgid (gid
);
3120 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3122 strcpy (fn
, procfn
);
3123 procfn_end
= fn
+ strlen (fn
);
3124 strcpy (procfn_end
, "/psinfo");
3125 fd
= emacs_open (fn
, O_RDONLY
, 0);
3127 && (nread
= read (fd
, (char*)&pinfo
, sizeof (struct psinfo
)) > 0))
3129 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3130 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3131 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3135 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3136 state_str
[1] = '\0';
3137 tem
= build_string (state_str
);
3138 attrs
= Fcons (Fcons (Qstate
, tem
), attrs
);
3141 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3142 need to get a string from it. */
3144 /* FIXME: missing: Qtpgid */
3156 Are they available? */
3158 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3159 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3160 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3161 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3162 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)), attrs
);
3164 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3165 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)), attrs
);
3166 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)), attrs
);
3168 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3169 range 0 .. 2**15, representing 0.0 .. 1.0. */
3170 attrs
= Fcons (Fcons (Qpcpu
, make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)), attrs
);
3171 attrs
= Fcons (Fcons (Qpmem
, make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)), attrs
);
3174 = code_convert_string_norecord (make_unibyte_string (pinfo
.pr_fname
,
3175 strlen (pinfo
.pr_fname
)),
3176 Vlocale_coding_system
, 0);
3177 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3179 = code_convert_string_norecord (make_unibyte_string (pinfo
.pr_psargs
,
3180 strlen (pinfo
.pr_psargs
)),
3181 Vlocale_coding_system
, 0);
3182 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3192 #elif defined __FreeBSD__
3195 timeval_to_EMACS_TIME (struct timeval t
)
3197 return make_emacs_time (t
.tv_sec
, t
.tv_usec
* 1000);
3201 make_lisp_timeval (struct timeval t
)
3203 return make_lisp_time (timeval_to_EMACS_TIME (t
));
3207 system_process_attributes (Lisp_Object pid
)
3210 int pagesize
= getpagesize ();
3217 char args
[MAXPATHLEN
];
3220 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3221 struct kinfo_proc proc
;
3222 size_t proclen
= sizeof proc
;
3224 struct gcpro gcpro1
, gcpro2
;
3225 Lisp_Object attrs
= Qnil
;
3226 Lisp_Object decoded_comm
;
3228 CHECK_NUMBER_OR_FLOAT (pid
);
3229 CONS_TO_INTEGER (pid
, int, proc_id
);
3232 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3235 GCPRO2 (attrs
, decoded_comm
);
3237 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3240 pw
= getpwuid (proc
.ki_uid
);
3243 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3245 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3248 gr
= getgrgid (proc
.ki_svgid
);
3251 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3253 decoded_comm
= code_convert_string_norecord
3254 (make_unibyte_string (proc
.ki_comm
, strlen (proc
.ki_comm
)),
3255 Vlocale_coding_system
, 0);
3257 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3259 char state
[2] = {'\0', '\0'};
3260 switch (proc
.ki_stat
)
3282 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3285 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3286 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3287 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3290 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3293 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3295 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3296 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3297 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3298 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3299 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3301 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3303 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3305 t
= add_emacs_time (timeval_to_EMACS_TIME (proc
.ki_rusage
.ru_utime
),
3306 timeval_to_EMACS_TIME (proc
.ki_rusage
.ru_stime
));
3307 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3309 attrs
= Fcons (Fcons (Qcutime
,
3310 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3312 attrs
= Fcons (Fcons (Qcstime
,
3313 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3315 t
= add_emacs_time (timeval_to_EMACS_TIME (proc
.ki_rusage_ch
.ru_utime
),
3316 timeval_to_EMACS_TIME (proc
.ki_rusage_ch
.ru_stime
));
3317 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3319 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3321 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3322 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3323 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3324 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3325 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3328 now
= current_emacs_time ();
3329 t
= sub_emacs_time (now
, timeval_to_EMACS_TIME (proc
.ki_start
));
3330 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3332 len
= sizeof fscale
;
3333 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3338 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3340 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3341 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3342 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3346 len
= sizeof npages
;
3347 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3349 double pmem
= (proc
.ki_flag
& P_INMEM
3350 ? 100.0 * proc
.ki_rssize
/ npages
3352 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3355 mib
[2] = KERN_PROC_ARGS
;
3357 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3360 for (i
= 0; i
< len
; i
++)
3362 if (! args
[i
] && i
< len
- 1)
3367 (code_convert_string_norecord
3368 (build_unibyte_string (args
),
3369 Vlocale_coding_system
, 0));
3371 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3378 /* The WINDOWSNT implementation is in w32.c.
3379 The MSDOS implementation is in dosfns.c. */
3380 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3383 system_process_attributes (Lisp_Object pid
)
3388 #endif /* !defined (WINDOWSNT) */