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>
45 /* Sparc/ARM machine/frame.h has 'struct frame' which conflicts with Emacs's
46 'struct frame', so rename it. */
47 # define frame freebsd_frame
48 # include <sys/user.h>
51 # include <sys/resource.h>
57 #define write sys_write
59 #define STDERR_FILENO fileno(GetStdHandle(STD_ERROR_HANDLE))
62 #endif /* not WINDOWSNT */
64 #include <sys/types.h>
68 /* Get SI_SRPC_DOMAIN, if it is available. */
69 #ifdef HAVE_SYS_SYSTEMINFO_H
70 #include <sys/systeminfo.h>
73 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
77 #include <sys/param.h>
84 #ifdef HAVE_SYS_UTSNAME_H
85 #include <sys/utsname.h>
87 #endif /* HAVE_SYS_UTSNAME_H */
92 #include "termhooks.h"
95 #include "dispextern.h"
97 #include "cm.h" /* for reset_sys_modes */
101 /* In process.h which conflicts with the local copy. */
103 int _cdecl
_spawnlp (int, const char *, const char *, ...);
104 int _cdecl
_getpid (void);
107 #include "syssignal.h"
110 static void emacs_get_tty (int, struct emacs_tty
*);
111 static int emacs_set_tty (int, struct emacs_tty
*, bool);
113 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
115 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
118 /* Declare here, including term.h is problematic on some systems. */
119 extern void tputs (const char *, int, int (*)(int));
121 static const int baud_convert
[] =
123 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
124 1800, 2400, 4800, 9600, 19200, 38400
128 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
130 /* Return the current working directory. Returns NULL on errors.
131 Any other returned value must be freed with free. This is used
132 only when get_current_dir_name is not defined on the system. */
134 get_current_dir_name (void)
137 char *pwd
= getenv ("PWD");
138 struct stat dotstat
, pwdstat
;
139 /* If PWD is accurate, use it instead of calling getcwd. PWD is
140 sometimes a nicer name, and using it may avoid a fatal error if a
141 parent directory is searchable but not readable. */
143 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
144 && stat (pwd
, &pwdstat
) == 0
145 && stat (".", &dotstat
) == 0
146 && dotstat
.st_ino
== pwdstat
.st_ino
147 && dotstat
.st_dev
== pwdstat
.st_dev
149 && strlen (pwd
) < MAXPATHLEN
153 buf
= malloc (strlen (pwd
) + 1);
160 size_t buf_size
= 1024;
161 buf
= malloc (buf_size
);
166 if (getcwd (buf
, buf_size
) == buf
)
170 int tmp_errno
= errno
;
176 buf
= realloc (buf
, buf_size
);
186 /* Discard pending input on all input descriptors. */
189 discard_tty_input (void)
192 struct emacs_tty buf
;
197 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
198 while (dos_keyread () != -1)
200 #else /* not MSDOS */
202 struct tty_display_info
*tty
;
203 for (tty
= tty_list
; tty
; tty
= tty
->next
)
205 if (tty
->input
) /* Is the device suspended? */
207 emacs_get_tty (fileno (tty
->input
), &buf
);
208 emacs_set_tty (fileno (tty
->input
), &buf
, 0);
212 #endif /* not MSDOS */
213 #endif /* not WINDOWSNT */
219 /* Arrange for character C to be read as the next input from
221 XXX What if we have multiple ttys?
227 if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
230 /* Should perhaps error if in batch mode */
232 ioctl (fileno (CURTTY()->input
), TIOCSTI
, &c
);
233 #else /* no TIOCSTI */
234 error ("Cannot stuff terminal input characters in this version of Unix");
235 #endif /* no TIOCSTI */
241 init_baud_rate (int fd
)
251 #else /* not DOS_NT */
256 emacs_ospeed
= cfgetospeed (&sg
);
257 #endif /* not DOS_NT */
260 baud_rate
= (emacs_ospeed
< sizeof baud_convert
/ sizeof baud_convert
[0]
261 ? baud_convert
[emacs_ospeed
] : 9600);
270 /* Wait for the subprocess with process id CHILD to terminate or change status.
271 CHILD must be a child process that has not been reaped.
272 If STATUS is non-null, store the waitpid-style exit status into *STATUS
273 and tell wait_reading_process_output that it needs to look around.
274 Use waitpid-style OPTIONS when waiting.
275 If INTERRUPTIBLE, this function is interruptible by a signal.
277 Return CHILD if successful, 0 if no status is available;
278 the latter is possible only when options & NOHANG. */
280 get_child_status (pid_t child
, int *status
, int options
, bool interruptible
)
284 /* Invoke waitpid only with a known process ID; do not invoke
285 waitpid with a nonpositive argument. Otherwise, Emacs might
286 reap an unwanted process by mistake. For example, invoking
287 waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
288 so that another thread running glib won't find them. */
291 while ((pid
= waitpid (child
, status
, options
)) < 0)
293 /* Check that CHILD is a child process that has not been reaped,
294 and that STATUS and OPTIONS are valid. Otherwise abort,
295 as continuing after this internal error could cause Emacs to
296 become confused and kill innocent-victim processes. */
300 /* Note: the MS-Windows emulation of waitpid calls QUIT
306 /* If successful and status is requested, tell wait_reading_process_output
307 that it needs to wake up and look around. */
308 if (pid
&& status
&& input_available_clear_time
)
309 *input_available_clear_time
= make_emacs_time (0, 0);
314 /* Wait for the subprocess with process id CHILD to terminate.
315 CHILD must be a child process that has not been reaped.
316 If STATUS is non-null, store the waitpid-style exit status into *STATUS
317 and tell wait_reading_process_output that it needs to look around.
318 If INTERRUPTIBLE, this function is interruptible by a signal. */
320 wait_for_termination (pid_t child
, int *status
, bool interruptible
)
322 get_child_status (child
, status
, 0, interruptible
);
325 /* Report whether the subprocess with process id CHILD has changed status.
326 Termination counts as a change of status.
327 CHILD must be a child process that has not been reaped.
328 If STATUS is non-null, store the waitpid-style exit status into *STATUS
329 and tell wait_reading_process_output that it needs to look around.
330 Use waitpid-style OPTIONS to check status, but do not wait.
332 Return CHILD if successful, 0 if no status is available because
333 the process's state has not changed. */
335 child_status_changed (pid_t child
, int *status
, int options
)
337 return get_child_status (child
, status
, WNOHANG
| options
, 0);
341 /* Set up the terminal at the other end of a pseudo-terminal that
342 we will be controlling an inferior through.
343 It should not echo or do line-editing, since that is done
344 in Emacs. No padding needed for insertion into an Emacs buffer. */
347 child_setup_tty (int out
)
352 emacs_get_tty (out
, &s
);
353 s
.main
.c_oflag
|= OPOST
; /* Enable output postprocessing */
354 s
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL on output */
356 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
357 Some versions of GNU Hurd do not have FFDLY? */
359 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
|FFDLY
);
360 /* No output delays */
362 s
.main
.c_oflag
&= ~(NLDLY
|CRDLY
|TABDLY
|BSDLY
|VTDLY
);
363 /* No output delays */
366 s
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
367 s
.main
.c_lflag
|= ISIG
; /* Enable signals */
369 s
.main
.c_iflag
&= ~IUCLC
; /* Disable downcasing on input. */
372 s
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
375 s
.main
.c_oflag
&= ~OLCUC
; /* Disable upcasing on output. */
377 s
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
378 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CSIZE
) | CS8
; /* Don't strip 8th bit */
379 s
.main
.c_cc
[VERASE
] = CDISABLE
; /* disable erase processing */
380 s
.main
.c_cc
[VKILL
] = CDISABLE
; /* disable kill processing */
383 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
386 #ifdef SIGNALS_VIA_CHARACTERS
387 /* the QUIT and INTR character are used in process_send_signal
388 so set them here to something useful. */
389 if (s
.main
.c_cc
[VQUIT
] == CDISABLE
)
390 s
.main
.c_cc
[VQUIT
] = '\\'&037; /* Control-\ */
391 if (s
.main
.c_cc
[VINTR
] == CDISABLE
)
392 s
.main
.c_cc
[VINTR
] = 'C'&037; /* Control-C */
393 #endif /* not SIGNALS_VIA_CHARACTERS */
396 /* Also, PTY overloads NUL and BREAK.
397 don't ignore break, but don't signal either, so it looks like NUL. */
398 s
.main
.c_iflag
&= ~IGNBRK
;
399 s
.main
.c_iflag
&= ~BRKINT
;
400 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
401 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
402 would force it to 0377. That looks like duplicated code. */
403 s
.main
.c_cflag
= (s
.main
.c_cflag
& ~CBAUD
) | B9600
; /* baud rate sanity */
406 /* We originally enabled ICANON (and set VEOF to 04), and then had
407 process.c send additional EOF chars to flush the output when faced
408 with long lines, but this leads to weird effects when the
409 subprocess has disabled ICANON and ends up seeing those spurious
410 extra EOFs. So we don't send EOFs any more in
411 process.c:send_process. First we tried to disable ICANON by
412 default, so if a subsprocess sets up ICANON, it's his problem (or
413 the Elisp package that talks to it) to deal with lines that are
414 too long. But this disables some features, such as the ability
415 to send EOF signals. So we re-enabled ICANON but there is no
416 more "send eof to flush" going on (which is wrong and unportable
417 in itself). The correct way to handle too much output is to
418 buffer what could not be written and then write it again when
419 select returns ok for writing. This has it own set of
420 problems. Write is now asynchronous, is that a problem? How much
421 do we buffer, and what do we do when that limit is reached? */
423 s
.main
.c_lflag
|= ICANON
; /* Enable line editing and eof processing */
424 s
.main
.c_cc
[VEOF
] = 'D'&037; /* Control-D */
425 #if 0 /* These settings only apply to non-ICANON mode. */
426 s
.main
.c_cc
[VMIN
] = 1;
427 s
.main
.c_cc
[VTIME
] = 0;
430 emacs_set_tty (out
, &s
, 0);
431 #endif /* not WINDOWSNT */
433 #endif /* not MSDOS */
436 /* Record a signal code and the action for it. */
440 struct sigaction action
;
443 static void save_signal_handlers (struct save_signal
*);
444 static void restore_signal_handlers (struct save_signal
*);
446 /* Suspend the Emacs process; give terminal to its superior. */
454 /* On a system where suspending is not implemented,
455 instead fork a subshell and let it talk directly to the terminal
462 /* Fork a subshell. */
467 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
469 char oldwd
[MAXPATHLEN
+1]; /* Fixed length is safe on MSDOS. */
473 struct save_signal saved_handlers
[5];
475 unsigned char *volatile str_volatile
= 0;
479 saved_handlers
[0].code
= SIGINT
;
480 saved_handlers
[1].code
= SIGQUIT
;
481 saved_handlers
[2].code
= SIGTERM
;
483 saved_handlers
[3].code
= SIGIO
;
484 saved_handlers
[4].code
= 0;
486 saved_handlers
[3].code
= 0;
489 /* Mentioning current_buffer->buffer would mean including buffer.h,
490 which somehow wedges the hp compiler. So instead... */
492 dir
= intern ("default-directory");
493 if (NILP (Fboundp (dir
)))
495 dir
= Fsymbol_value (dir
);
499 dir
= expand_and_dir_to_file (Funhandled_file_name_directory (dir
), Qnil
);
500 str_volatile
= str
= alloca (SCHARS (dir
) + 2);
502 memcpy (str
, SDATA (dir
), len
);
503 if (str
[len
- 1] != '/') str
[len
++] = '/';
509 save_signal_handlers (saved_handlers
);
513 error ("Can't spawn subshell");
520 #ifdef DOS_NT /* MW, Aug 1993 */
521 getcwd (oldwd
, sizeof oldwd
);
523 sh
= egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
526 sh
= egetenv ("SHELL");
530 /* Use our buffer's default directory for the subshell. */
532 if (str
&& chdir ((char *) str
) != 0)
535 emacs_perror ((char *) str
);
536 _exit (EXIT_CANCELED
);
540 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
542 char *epwd
= getenv ("PWD");
543 char old_pwd
[MAXPATHLEN
+1+4];
545 /* If PWD is set, pass it with corrected value. */
548 strcpy (old_pwd
, epwd
);
549 if (str
[len
- 1] == '/')
551 setenv ("PWD", str
, 1);
554 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
556 putenv (old_pwd
); /* restore previous value */
558 #else /* not MSDOS */
560 /* Waits for process completion */
561 pid
= _spawnlp (_P_WAIT
, sh
, sh
, NULL
);
562 chdir (oldwd
); /* FIXME: Do the right thing on chdir failure. */
564 write (1, "Can't execute subshell", 22);
565 #else /* not WINDOWSNT */
566 execlp (sh
, sh
, (char *) 0);
568 _exit (errno
== ENOENT
? EXIT_ENOENT
: EXIT_CANNOT_INVOKE
);
569 #endif /* not WINDOWSNT */
570 #endif /* not MSDOS */
573 /* Do this now if we did not do it before. */
575 save_signal_handlers (saved_handlers
);
579 wait_for_termination (pid
, &status
, 0);
581 restore_signal_handlers (saved_handlers
);
585 save_signal_handlers (struct save_signal
*saved_handlers
)
587 while (saved_handlers
->code
)
589 struct sigaction action
;
590 emacs_sigaction_init (&action
, SIG_IGN
);
591 sigaction (saved_handlers
->code
, &action
, &saved_handlers
->action
);
597 restore_signal_handlers (struct save_signal
*saved_handlers
)
599 while (saved_handlers
->code
)
601 sigaction (saved_handlers
->code
, &saved_handlers
->action
, 0);
607 static int old_fcntl_flags
[MAXDESC
];
614 old_fcntl_flags
[fd
] = fcntl (fd
, F_GETFL
, 0) & ~FASYNC
;
615 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
] | FASYNC
);
616 interrupts_deferred
= 0;
624 fcntl (fd
, F_SETFL
, old_fcntl_flags
[fd
]);
637 sigemptyset (&unblocked
);
639 sigaddset (&unblocked
, SIGWINCH
);
641 sigaddset (&unblocked
, SIGIO
);
642 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
644 interrupts_deferred
= 0;
649 unrequest_sigio (void)
657 sigemptyset (&blocked
);
659 sigaddset (&blocked
, SIGWINCH
);
661 sigaddset (&blocked
, SIGIO
);
662 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
663 interrupts_deferred
= 1;
671 signal (SIGIO
, SIG_IGN
);
676 /* Saving and restoring the process group of Emacs's terminal. */
678 /* The process group of which Emacs was a member when it initially
681 If Emacs was in its own process group (i.e. inherited_pgroup ==
682 getpid ()), then we know we're running under a shell with job
683 control (Emacs would never be run as part of a pipeline).
686 If Emacs was not in its own process group, then we know we're
687 running under a shell (or a caller) that doesn't know how to
688 separate itself from Emacs (like sh). Emacs must be in its own
689 process group in order to receive SIGIO correctly. In this
690 situation, we put ourselves in our own pgroup, forcibly set the
691 tty's pgroup to our pgroup, and make sure to restore and reinstate
692 the tty's pgroup just like any other terminal setting. If
693 inherited_group was not the tty's pgroup, then we'll get a
694 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
695 it goes foreground in the future, which is what should happen. */
697 static pid_t inherited_pgroup
;
700 init_foreground_group (void)
702 pid_t pgrp
= getpgrp ();
703 inherited_pgroup
= getpid () == pgrp
? 0 : pgrp
;
706 /* Block and unblock SIGTTOU. */
709 block_tty_out_signal (void)
713 sigemptyset (&blocked
);
714 sigaddset (&blocked
, SIGTTOU
);
715 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
720 unblock_tty_out_signal (void)
723 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
727 /* Safely set a controlling terminal FD's process group to PGID.
728 If we are not in the foreground already, POSIX requires tcsetpgrp
729 to deliver a SIGTTOU signal, which would stop us. This is an
730 annoyance, so temporarily ignore the signal.
732 In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
733 skip all this unless SIGTTOU is defined. */
735 tcsetpgrp_without_stopping (int fd
, pid_t pgid
)
739 block_tty_out_signal ();
740 tcsetpgrp (fd
, pgid
);
741 unblock_tty_out_signal ();
746 /* Split off the foreground process group to Emacs alone. When we are
747 in the foreground, but not started in our own process group,
748 redirect the tty device handle FD to point to our own process
749 group. FD must be the file descriptor of the controlling tty. */
751 narrow_foreground_group (int fd
)
753 if (inherited_pgroup
&& setpgid (0, 0) == 0)
754 tcsetpgrp_without_stopping (fd
, getpid ());
757 /* Set the tty to our original foreground group. */
759 widen_foreground_group (int fd
)
761 if (inherited_pgroup
&& setpgid (0, inherited_pgroup
) == 0)
762 tcsetpgrp_without_stopping (fd
, inherited_pgroup
);
765 /* Getting and setting emacs_tty structures. */
767 /* Set *TC to the parameters associated with the terminal FD,
768 or clear it if the parameters are not available. */
770 emacs_get_tty (int fd
, struct emacs_tty
*settings
)
772 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
774 /* We have those nifty POSIX tcmumbleattr functions. */
775 memset (&settings
->main
, 0, sizeof (settings
->main
));
776 tcgetattr (fd
, &settings
->main
);
781 /* Set the parameters of the tty on FD according to the contents of
782 *SETTINGS. If FLUSHP, discard input.
783 Return 0 if all went well, and -1 (setting errno) if anything failed. */
786 emacs_set_tty (int fd
, struct emacs_tty
*settings
, bool flushp
)
788 /* Set the primary parameters - baud rate, character size, etcetera. */
791 /* We have those nifty POSIX tcmumbleattr functions.
792 William J. Smith <wjs@wiis.wang.com> writes:
793 "POSIX 1003.1 defines tcsetattr to return success if it was
794 able to perform any of the requested actions, even if some
795 of the requested actions could not be performed.
796 We must read settings back to ensure tty setup properly.
797 AIX requires this to keep tty from hanging occasionally." */
798 /* This make sure that we don't loop indefinitely in here. */
799 for (i
= 0 ; i
< 10 ; i
++)
800 if (tcsetattr (fd
, flushp
? TCSAFLUSH
: TCSADRAIN
, &settings
->main
) < 0)
811 memset (&new, 0, sizeof (new));
812 /* Get the current settings, and see if they're what we asked for. */
813 tcgetattr (fd
, &new);
814 /* We cannot use memcmp on the whole structure here because under
815 * aix386 the termios structure has some reserved field that may
818 if ( new.c_iflag
== settings
->main
.c_iflag
819 && new.c_oflag
== settings
->main
.c_oflag
820 && new.c_cflag
== settings
->main
.c_cflag
821 && new.c_lflag
== settings
->main
.c_lflag
822 && memcmp (new.c_cc
, settings
->main
.c_cc
, NCCS
) == 0)
829 /* We have survived the tempest. */
836 static int old_fcntl_owner
[MAXDESC
];
837 #endif /* F_SETOWN */
839 /* This may also be defined in stdio,
840 but if so, this does no harm,
841 and using the same name avoids wasting the other one's space. */
844 unsigned char _sobuf
[BUFSIZ
+8];
849 /* Initialize the terminal mode on all tty devices that are currently
853 init_all_sys_modes (void)
855 struct tty_display_info
*tty
;
856 for (tty
= tty_list
; tty
; tty
= tty
->next
)
857 init_sys_modes (tty
);
860 /* Initialize the terminal mode on the given tty device. */
863 init_sys_modes (struct tty_display_info
*tty_out
)
865 struct emacs_tty tty
;
866 Lisp_Object terminal
;
868 Vtty_erase_char
= Qnil
;
873 if (!tty_out
->output
)
874 return; /* The tty is suspended. */
876 narrow_foreground_group (fileno (tty_out
->input
));
878 if (! tty_out
->old_tty
)
879 tty_out
->old_tty
= xmalloc (sizeof *tty_out
->old_tty
);
881 emacs_get_tty (fileno (tty_out
->input
), tty_out
->old_tty
);
883 tty
= *tty_out
->old_tty
;
885 #if !defined (DOS_NT)
886 XSETINT (Vtty_erase_char
, tty
.main
.c_cc
[VERASE
]);
888 tty
.main
.c_iflag
|= (IGNBRK
); /* Ignore break condition */
889 tty
.main
.c_iflag
&= ~ICRNL
; /* Disable map of CR to NL on input */
890 #ifdef INLCR /* I'm just being cautious,
891 since I can't check how widespread INLCR is--rms. */
892 tty
.main
.c_iflag
&= ~INLCR
; /* Disable map of NL to CR on input */
895 tty
.main
.c_iflag
&= ~ISTRIP
; /* don't strip 8th bit on input */
897 tty
.main
.c_lflag
&= ~ECHO
; /* Disable echo */
898 tty
.main
.c_lflag
&= ~ICANON
; /* Disable erase/kill processing */
900 tty
.main
.c_lflag
&= ~IEXTEN
; /* Disable other editing characters. */
902 tty
.main
.c_lflag
|= ISIG
; /* Enable signals */
903 if (tty_out
->flow_control
)
905 tty
.main
.c_iflag
|= IXON
; /* Enable start/stop output control */
907 tty
.main
.c_iflag
&= ~IXANY
;
911 tty
.main
.c_iflag
&= ~IXON
; /* Disable start/stop output control */
912 tty
.main
.c_oflag
&= ~ONLCR
; /* Disable map of NL to CR-NL
914 tty
.main
.c_oflag
&= ~TAB3
; /* Disable tab expansion */
916 if (tty_out
->meta_key
)
918 tty
.main
.c_cflag
|= CS8
; /* allow 8th bit on input */
919 tty
.main
.c_cflag
&= ~PARENB
;/* Don't check parity */
923 XSETTERMINAL(terminal
, tty_out
->terminal
);
924 if (!NILP (Fcontrolling_tty_p (terminal
)))
926 tty
.main
.c_cc
[VINTR
] = quit_char
; /* C-g (usually) gives SIGINT */
927 /* Set up C-g for both SIGQUIT and SIGINT.
928 We don't know which we will get, but we handle both alike
929 so which one it really gives us does not matter. */
930 tty
.main
.c_cc
[VQUIT
] = quit_char
;
934 /* We normally don't get interrupt or quit signals from tty
935 devices other than our controlling terminal; therefore,
936 we must handle C-g as normal input. Unfortunately, this
937 means that the interrupt and quit feature must be
938 disabled on secondary ttys, or we would not even see the
941 Note that even though emacsclient could have special code
942 to pass SIGINT to Emacs, we should _not_ enable
943 interrupt/quit keys for emacsclient frames. This means
944 that we can't break out of loops in C code from a
945 secondary tty frame, but we can always decide what
946 display the C-g came from, which is more important from a
947 usability point of view. (Consider the case when two
948 people work together using the same Emacs instance.) */
949 tty
.main
.c_cc
[VINTR
] = CDISABLE
;
950 tty
.main
.c_cc
[VQUIT
] = CDISABLE
;
952 tty
.main
.c_cc
[VMIN
] = 1; /* Input should wait for at least 1 char */
953 tty
.main
.c_cc
[VTIME
] = 0; /* no matter how long that takes. */
955 tty
.main
.c_cc
[VSWTCH
] = CDISABLE
; /* Turn off shell layering use
960 tty
.main
.c_cc
[VSUSP
] = CDISABLE
; /* Turn off handling of C-z. */
963 tty
.main
.c_cc
[V_DSUSP
] = CDISABLE
; /* Turn off handling of C-y. */
965 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
966 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
969 tty
.main
.c_cc
[VLNEXT
] = CDISABLE
;
972 tty
.main
.c_cc
[VREPRINT
] = CDISABLE
;
973 #endif /* VREPRINT */
975 tty
.main
.c_cc
[VWERASE
] = CDISABLE
;
978 tty
.main
.c_cc
[VDISCARD
] = CDISABLE
;
979 #endif /* VDISCARD */
981 if (tty_out
->flow_control
)
984 tty
.main
.c_cc
[VSTART
] = '\021';
987 tty
.main
.c_cc
[VSTOP
] = '\023';
993 tty
.main
.c_cc
[VSTART
] = CDISABLE
;
996 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1001 tty
.main
.c_cc
[VSTRT
] = CDISABLE
;
1002 tty
.main
.c_cc
[VSTOP
] = CDISABLE
;
1003 tty
.main
.c_cc
[VSUSP
] = CDISABLE
;
1004 tty
.main
.c_cc
[VDSUSP
] = CDISABLE
;
1005 if (tty_out
->flow_control
)
1008 tty
.main
.c_cc
[VSTART
] = '\021';
1011 tty
.main
.c_cc
[VSTOP
] = '\023';
1014 /* Also, PTY overloads NUL and BREAK.
1015 don't ignore break, but don't signal either, so it looks like NUL.
1016 This really serves a purpose only if running in an XTERM window
1017 or via TELNET or the like, but does no harm elsewhere. */
1018 tty
.main
.c_iflag
&= ~IGNBRK
;
1019 tty
.main
.c_iflag
&= ~BRKINT
;
1021 #endif /* not DOS_NT */
1023 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1024 if (!tty_out
->term_initted
)
1025 internal_terminal_init ();
1026 dos_ttraw (tty_out
);
1029 emacs_set_tty (fileno (tty_out
->input
), &tty
, 0);
1031 /* This code added to insure that, if flow-control is not to be used,
1032 we have an unlocked terminal at the start. */
1035 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TCXONC
, 1);
1038 if (!tty_out
->flow_control
) ioctl (fileno (tty_out
->input
), TIOCSTART
, 0);
1041 #if !defined (DOS_NT)
1043 if (!tty_out
->flow_control
) tcflow (fileno (tty_out
->input
), TCOON
);
1048 if (interrupt_input
)
1050 old_fcntl_owner
[fileno (tty_out
->input
)] =
1051 fcntl (fileno (tty_out
->input
), F_GETOWN
, 0);
1052 fcntl (fileno (tty_out
->input
), F_SETOWN
, getpid ());
1053 init_sigio (fileno (tty_out
->input
));
1055 if (gpm_tty
== tty_out
)
1057 /* Arrange for mouse events to give us SIGIO signals. */
1058 fcntl (gpm_fd
, F_SETOWN
, getpid ());
1059 fcntl (gpm_fd
, F_SETFL
, fcntl (gpm_fd
, F_GETFL
, 0) | O_NONBLOCK
);
1060 init_sigio (gpm_fd
);
1062 #endif /* HAVE_GPM */
1064 #endif /* F_GETOWN */
1067 /* This symbol is defined on recent USG systems.
1068 Someone says without this call USG won't really buffer the file
1069 even with a call to setbuf. */
1070 setvbuf (tty_out
->output
, (char *) _sobuf
, _IOFBF
, sizeof _sobuf
);
1072 setbuf (tty_out
->output
, (char *) _sobuf
);
1075 if (tty_out
->terminal
->set_terminal_modes_hook
)
1076 tty_out
->terminal
->set_terminal_modes_hook (tty_out
->terminal
);
1078 if (!tty_out
->term_initted
)
1080 Lisp_Object tail
, frame
;
1081 FOR_EACH_FRAME (tail
, frame
)
1083 /* XXX This needs to be revised. */
1084 if (FRAME_TERMCAP_P (XFRAME (frame
))
1085 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1086 init_frame_faces (XFRAME (frame
));
1090 if (tty_out
->term_initted
&& no_redraw_on_reenter
)
1092 /* We used to call "direct_output_forward_char(0)" here,
1093 but it's not clear why, since it may not do anything anyway. */
1097 Lisp_Object tail
, frame
;
1099 FOR_EACH_FRAME (tail
, frame
)
1101 if ((FRAME_TERMCAP_P (XFRAME (frame
))
1102 || FRAME_MSDOS_P (XFRAME (frame
)))
1103 && FRAME_TTY (XFRAME (frame
)) == tty_out
)
1104 FRAME_GARBAGED_P (XFRAME (frame
)) = 1;
1108 tty_out
->term_initted
= 1;
1111 /* Return true if safe to use tabs in output.
1112 At the time this is called, init_sys_modes has not been done yet. */
1115 tabs_safe_p (int fd
)
1117 struct emacs_tty etty
;
1119 emacs_get_tty (fd
, &etty
);
1122 return ((etty
.main
.c_oflag
& TABDLY
) != TAB3
);
1123 #else /* not TABDLY */
1125 #endif /* not TABDLY */
1131 /* Get terminal size from system.
1132 Store number of lines into *HEIGHTP and width into *WIDTHP.
1133 We store 0 if there's no valid information. */
1136 get_tty_size (int fd
, int *widthp
, int *heightp
)
1138 #if defined TIOCGWINSZ
1141 struct winsize size
;
1143 if (ioctl (fd
, TIOCGWINSZ
, &size
) == -1)
1144 *widthp
= *heightp
= 0;
1147 *widthp
= size
.ws_col
;
1148 *heightp
= size
.ws_row
;
1151 #elif defined TIOCGSIZE
1153 /* SunOS - style. */
1154 struct ttysize size
;
1156 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1157 *widthp
= *heightp
= 0;
1160 *widthp
= size
.ts_cols
;
1161 *heightp
= size
.ts_lines
;
1164 #elif defined WINDOWSNT
1166 CONSOLE_SCREEN_BUFFER_INFO info
;
1167 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE
), &info
))
1169 *widthp
= info
.srWindow
.Right
- info
.srWindow
.Left
+ 1;
1170 *heightp
= info
.srWindow
.Bottom
- info
.srWindow
.Top
+ 1;
1173 *widthp
= *heightp
= 0;
1177 *widthp
= ScreenCols ();
1178 *heightp
= ScreenRows ();
1180 #else /* system doesn't know size */
1188 /* Set the logical window size associated with descriptor FD
1189 to HEIGHT and WIDTH. This is used mainly with ptys. */
1192 set_window_size (int fd
, int height
, int width
)
1197 struct winsize size
;
1198 size
.ws_row
= height
;
1199 size
.ws_col
= width
;
1201 if (ioctl (fd
, TIOCSWINSZ
, &size
) == -1)
1202 return 0; /* error */
1209 /* SunOS - style. */
1210 struct ttysize size
;
1211 size
.ts_lines
= height
;
1212 size
.ts_cols
= width
;
1214 if (ioctl (fd
, TIOCGSIZE
, &size
) == -1)
1220 #endif /* not SunOS-style */
1221 #endif /* not BSD-style */
1226 /* Prepare all terminal devices for exiting Emacs. */
1229 reset_all_sys_modes (void)
1231 struct tty_display_info
*tty
;
1232 for (tty
= tty_list
; tty
; tty
= tty
->next
)
1233 reset_sys_modes (tty
);
1236 /* Prepare the terminal for closing it; move the cursor to the
1237 bottom of the frame, turn off interrupt-driven I/O, etc. */
1240 reset_sys_modes (struct tty_display_info
*tty_out
)
1247 if (!tty_out
->term_initted
)
1250 if (!tty_out
->output
)
1251 return; /* The tty is suspended. */
1253 /* Go to and clear the last line of the terminal. */
1255 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1257 /* Code adapted from tty_clear_end_of_line. */
1258 if (tty_out
->TS_clr_line
)
1260 emacs_tputs (tty_out
, tty_out
->TS_clr_line
, 1, cmputc
);
1263 { /* have to do it the hard way */
1265 tty_turn_off_insert (tty_out
);
1267 for (i
= curX (tty_out
); i
< FrameCols (tty_out
) - 1; i
++)
1269 fputc (' ', tty_out
->output
);
1273 cmgoto (tty_out
, FrameRows (tty_out
) - 1, 0);
1274 fflush (tty_out
->output
);
1276 if (tty_out
->terminal
->reset_terminal_modes_hook
)
1277 tty_out
->terminal
->reset_terminal_modes_hook (tty_out
->terminal
);
1279 /* Avoid possible loss of output when changing terminal modes. */
1280 while (fdatasync (fileno (tty_out
->output
)) != 0 && errno
== EINTR
)
1285 if (interrupt_input
)
1287 reset_sigio (fileno (tty_out
->input
));
1288 fcntl (fileno (tty_out
->input
), F_SETOWN
,
1289 old_fcntl_owner
[fileno (tty_out
->input
)]);
1291 #endif /* F_SETOWN */
1292 fcntl (fileno (tty_out
->input
), F_SETFL
,
1293 fcntl (fileno (tty_out
->input
), F_GETFL
, 0) & ~O_NONBLOCK
);
1296 if (tty_out
->old_tty
)
1297 while (emacs_set_tty (fileno (tty_out
->input
),
1298 tty_out
->old_tty
, 0) < 0 && errno
== EINTR
)
1301 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1305 widen_foreground_group (fileno (tty_out
->input
));
1310 /* Set up the proper status flags for use of a pty. */
1315 /* I'm told that TOICREMOTE does not mean control chars
1316 "can't be sent" but rather that they don't have
1317 input-editing or signaling effects.
1318 That should be good, because we have other ways
1319 to do those things in Emacs.
1320 However, telnet mode seems not to work on 4.2.
1321 So TIOCREMOTE is turned off now. */
1323 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1324 will hang. In particular, the "timeout" feature (which
1325 causes a read to return if there is no data available)
1326 does this. Also it is known that telnet mode will hang
1327 in such a way that Emacs must be stopped (perhaps this
1328 is the same problem).
1330 If TIOCREMOTE is turned off, then there is a bug in
1331 hp-ux which sometimes loses data. Apparently the
1332 code which blocks the master process when the internal
1333 buffer fills up does not work. Other than this,
1334 though, everything else seems to work fine.
1336 Since the latter lossage is more benign, we may as well
1337 lose that way. -- cph */
1339 #if defined (UNIX98_PTYS)
1342 ioctl (fd
, FIONBIO
, &on
);
1347 #endif /* HAVE_PTYS */
1350 #include <sys/socket.h>
1352 #endif /* HAVE_SOCKETS */
1355 #ifndef HAVE_H_ERRNO
1358 #endif /* TRY_AGAIN */
1361 init_system_name (void)
1363 #ifndef HAVE_GETHOSTNAME
1366 Vsystem_name
= build_string (uts
.nodename
);
1367 #else /* HAVE_GETHOSTNAME */
1368 char *hostname_alloc
= NULL
;
1369 char hostname_buf
[256];
1370 ptrdiff_t hostname_size
= sizeof hostname_buf
;
1371 char *hostname
= hostname_buf
;
1373 /* Try to get the host name; if the buffer is too short, try
1374 again. Apparently, the only indication gethostname gives of
1375 whether the buffer was large enough is the presence or absence
1376 of a '\0' in the string. Eech. */
1379 gethostname (hostname
, hostname_size
- 1);
1380 hostname
[hostname_size
- 1] = '\0';
1382 /* Was the buffer large enough for the '\0'? */
1383 if (strlen (hostname
) < hostname_size
- 1)
1386 hostname
= hostname_alloc
= xpalloc (hostname_alloc
, &hostname_size
, 1,
1387 min (PTRDIFF_MAX
, SIZE_MAX
), 1);
1390 /* Turn the hostname into the official, fully-qualified hostname.
1391 Don't do this if we're going to dump; this can confuse system
1392 libraries on some machines and make the dumped emacs core dump. */
1395 #endif /* not CANNOT_DUMP */
1396 if (! strchr (hostname
, '.'))
1399 #ifdef HAVE_GETADDRINFO
1400 struct addrinfo
*res
;
1401 struct addrinfo hints
;
1404 memset (&hints
, 0, sizeof (hints
));
1405 hints
.ai_socktype
= SOCK_STREAM
;
1406 hints
.ai_flags
= AI_CANONNAME
;
1408 for (count
= 0;; count
++)
1410 if ((ret
= getaddrinfo (hostname
, NULL
, &hints
, &res
)) == 0
1411 || ret
!= EAI_AGAIN
)
1416 Fsleep_for (make_number (1), Qnil
);
1421 struct addrinfo
*it
= res
;
1424 char *fqdn
= it
->ai_canonname
;
1425 if (fqdn
&& strchr (fqdn
, '.')
1426 && strcmp (fqdn
, "localhost.localdomain") != 0)
1432 ptrdiff_t len
= strlen (it
->ai_canonname
);
1433 if (hostname_size
<= len
)
1435 hostname_size
= len
+ 1;
1436 hostname
= hostname_alloc
= xrealloc (hostname_alloc
,
1439 strcpy (hostname
, it
->ai_canonname
);
1443 #else /* !HAVE_GETADDRINFO */
1445 for (count
= 0;; count
++)
1451 hp
= gethostbyname (hostname
);
1453 if (! (hp
== 0 && h_errno
== TRY_AGAIN
))
1460 Fsleep_for (make_number (1), Qnil
);
1465 char *fqdn
= (char *) hp
->h_name
;
1467 if (!strchr (fqdn
, '.'))
1469 /* We still don't have a fully qualified domain name.
1470 Try to find one in the list of alternate names */
1471 char **alias
= hp
->h_aliases
;
1473 && (!strchr (*alias
, '.')
1474 || !strcmp (*alias
, "localhost.localdomain")))
1481 #endif /* !HAVE_GETADDRINFO */
1483 #endif /* HAVE_SOCKETS */
1484 Vsystem_name
= build_string (hostname
);
1485 xfree (hostname_alloc
);
1486 #endif /* HAVE_GETHOSTNAME */
1489 for (p
= SSDATA (Vsystem_name
); *p
; p
++)
1490 if (*p
== ' ' || *p
== '\t')
1495 sigset_t empty_mask
;
1497 static struct sigaction process_fatal_action
;
1500 emacs_sigaction_flags (void)
1503 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1504 'select') to reset their timeout on some platforms (e.g.,
1505 HP-UX 11), which is not what we want. Also, when Emacs is
1506 interactive, we don't want SA_RESTART because we need to poll
1507 for pending input so we need long-running syscalls to be interrupted
1508 after a signal that sets pending_signals.
1510 Non-interactive keyboard input goes through stdio, where we
1511 always want restartable system calls. */
1518 /* Store into *ACTION a signal action suitable for Emacs, with handler
1521 emacs_sigaction_init (struct sigaction
*action
, signal_handler_t handler
)
1523 sigemptyset (&action
->sa_mask
);
1525 /* When handling a signal, block nonfatal system signals that are caught
1526 by Emacs. This makes race conditions less likely. */
1527 sigaddset (&action
->sa_mask
, SIGALRM
);
1528 sigaddset (&action
->sa_mask
, SIGCHLD
);
1530 sigaddset (&action
->sa_mask
, SIGDANGER
);
1532 #ifdef PROFILER_CPU_SUPPORT
1533 sigaddset (&action
->sa_mask
, SIGPROF
);
1536 sigaddset (&action
->sa_mask
, SIGWINCH
);
1538 if (! noninteractive
)
1540 sigaddset (&action
->sa_mask
, SIGINT
);
1541 sigaddset (&action
->sa_mask
, SIGQUIT
);
1543 sigaddset (&action
->sa_mask
, SIGIO
);
1547 if (! IEEE_FLOATING_POINT
)
1548 sigaddset (&action
->sa_mask
, SIGFPE
);
1550 action
->sa_handler
= handler
;
1551 action
->sa_flags
= emacs_sigaction_flags ();
1554 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1555 static pthread_t main_thread
;
1558 /* SIG has arrived at the current process. Deliver it to the main
1559 thread, which should handle it with HANDLER.
1561 If we are on the main thread, handle the signal SIG with HANDLER.
1562 Otherwise, redirect the signal to the main thread, blocking it from
1563 this thread. POSIX says any thread can receive a signal that is
1564 associated with a process, process group, or asynchronous event.
1565 On GNU/Linux that is not true, but for other systems (FreeBSD at
1568 deliver_process_signal (int sig
, signal_handler_t handler
)
1570 /* Preserve errno, to avoid race conditions with signal handlers that
1571 might change errno. Races can occur even in single-threaded hosts. */
1572 int old_errno
= errno
;
1574 bool on_main_thread
= true;
1575 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1576 if (! pthread_equal (pthread_self (), main_thread
))
1579 sigemptyset (&blocked
);
1580 sigaddset (&blocked
, sig
);
1581 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1582 pthread_kill (main_thread
, sig
);
1583 on_main_thread
= false;
1592 /* Static location to save a fatal backtrace in a thread.
1593 FIXME: If two subsidiary threads fail simultaneously, the resulting
1594 backtrace may be garbage. */
1595 enum { BACKTRACE_LIMIT_MAX
= 500 };
1596 static void *thread_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
1597 static int thread_backtrace_npointers
;
1599 /* SIG has arrived at the current thread.
1600 If we are on the main thread, handle the signal SIG with HANDLER.
1601 Otherwise, this is a fatal error in the handling thread. */
1603 deliver_thread_signal (int sig
, signal_handler_t handler
)
1605 int old_errno
= errno
;
1607 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1608 if (! pthread_equal (pthread_self (), main_thread
))
1610 thread_backtrace_npointers
1611 = backtrace (thread_backtrace_buffer
, BACKTRACE_LIMIT_MAX
);
1612 sigaction (sig
, &process_fatal_action
, 0);
1613 pthread_kill (main_thread
, sig
);
1615 /* Avoid further damage while the main thread is exiting. */
1617 sigsuspend (&empty_mask
);
1625 #if !HAVE_DECL_SYS_SIGLIST
1627 # ifdef _sys_siglist
1628 # define sys_siglist _sys_siglist
1629 # elif HAVE_DECL___SYS_SIGLIST
1630 # define sys_siglist __sys_siglist
1632 # define sys_siglist my_sys_siglist
1633 static char const *sys_siglist
[NSIG
];
1638 # define sys_siglist_entries _sys_nsig
1640 # define sys_siglist_entries NSIG
1643 /* Handle bus errors, invalid instruction, etc. */
1645 handle_fatal_signal (int sig
)
1647 terminate_due_to_signal (sig
, 40);
1651 deliver_fatal_signal (int sig
)
1653 deliver_process_signal (sig
, handle_fatal_signal
);
1657 deliver_fatal_thread_signal (int sig
)
1659 deliver_thread_signal (sig
, handle_fatal_signal
);
1662 static _Noreturn
void
1663 handle_arith_signal (int sig
)
1665 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1666 xsignal0 (Qarith_error
);
1670 deliver_arith_signal (int sig
)
1672 deliver_thread_signal (sig
, handle_arith_signal
);
1677 /* Handler for SIGDANGER. */
1679 handle_danger_signal (int sig
)
1681 malloc_warning ("Operating system warns that virtual memory is running low.\n");
1683 /* It might be unsafe to call do_auto_save now. */
1684 force_auto_save_soon ();
1688 deliver_danger_signal (int sig
)
1690 deliver_process_signal (sig
, handle_danger_signal
);
1694 /* Treat SIG as a terminating signal, unless it is already ignored and
1695 we are in --batch mode. Among other things, this makes nohup work. */
1697 maybe_fatal_sig (int sig
)
1699 bool catch_sig
= !noninteractive
;
1702 struct sigaction old_action
;
1703 sigaction (sig
, 0, &old_action
);
1704 catch_sig
= old_action
.sa_handler
!= SIG_IGN
;
1707 sigaction (sig
, &process_fatal_action
, 0);
1711 init_signals (bool dumping
)
1713 struct sigaction thread_fatal_action
;
1714 struct sigaction action
;
1716 sigemptyset (&empty_mask
);
1718 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1719 main_thread
= pthread_self ();
1722 #if !HAVE_DECL_SYS_SIGLIST && !defined _sys_siglist
1725 sys_siglist
[SIGABRT
] = "Aborted";
1727 sys_siglist
[SIGAIO
] = "LAN I/O interrupt";
1729 sys_siglist
[SIGALRM
] = "Alarm clock";
1731 sys_siglist
[SIGBUS
] = "Bus error";
1733 sys_siglist
[SIGCHLD
] = "Child status changed";
1735 sys_siglist
[SIGCONT
] = "Continued";
1738 sys_siglist
[SIGDANGER
] = "Swap space dangerously low";
1741 sys_siglist
[SIGDGNOTIFY
] = "Notification message in queue";
1744 sys_siglist
[SIGEMT
] = "Emulation trap";
1746 sys_siglist
[SIGFPE
] = "Arithmetic exception";
1748 sys_siglist
[SIGFREEZE
] = "SIGFREEZE";
1751 sys_siglist
[SIGGRANT
] = "Monitor mode granted";
1753 sys_siglist
[SIGHUP
] = "Hangup";
1754 sys_siglist
[SIGILL
] = "Illegal instruction";
1755 sys_siglist
[SIGINT
] = "Interrupt";
1757 sys_siglist
[SIGIO
] = "I/O possible";
1760 sys_siglist
[SIGIOINT
] = "I/O intervention required";
1763 sys_siglist
[SIGIOT
] = "IOT trap";
1765 sys_siglist
[SIGKILL
] = "Killed";
1767 sys_siglist
[SIGLOST
] = "Resource lost";
1770 sys_siglist
[SIGLWP
] = "SIGLWP";
1773 sys_siglist
[SIGMSG
] = "Monitor mode data available";
1776 sys_siglist
[SIGWIND
] = "SIGPHONE";
1778 sys_siglist
[SIGPIPE
] = "Broken pipe";
1780 sys_siglist
[SIGPOLL
] = "Pollable event occurred";
1783 sys_siglist
[SIGPROF
] = "Profiling timer expired";
1786 sys_siglist
[SIGPTY
] = "PTY I/O interrupt";
1789 sys_siglist
[SIGPWR
] = "Power-fail restart";
1791 sys_siglist
[SIGQUIT
] = "Quit";
1793 sys_siglist
[SIGRETRACT
] = "Need to relinquish monitor mode";
1796 sys_siglist
[SIGSAK
] = "Secure attention";
1798 sys_siglist
[SIGSEGV
] = "Segmentation violation";
1800 sys_siglist
[SIGSOUND
] = "Sound completed";
1803 sys_siglist
[SIGSTOP
] = "Stopped (signal)";
1806 sys_siglist
[SIGSTP
] = "Stopped (user)";
1809 sys_siglist
[SIGSYS
] = "Bad argument to system call";
1811 sys_siglist
[SIGTERM
] = "Terminated";
1813 sys_siglist
[SIGTHAW
] = "SIGTHAW";
1816 sys_siglist
[SIGTRAP
] = "Trace/breakpoint trap";
1819 sys_siglist
[SIGTSTP
] = "Stopped (user)";
1822 sys_siglist
[SIGTTIN
] = "Stopped (tty input)";
1825 sys_siglist
[SIGTTOU
] = "Stopped (tty output)";
1828 sys_siglist
[SIGURG
] = "Urgent I/O condition";
1831 sys_siglist
[SIGUSR1
] = "User defined signal 1";
1834 sys_siglist
[SIGUSR2
] = "User defined signal 2";
1837 sys_siglist
[SIGVTALRM
] = "Virtual timer expired";
1840 sys_siglist
[SIGWAITING
] = "Process's LWPs are blocked";
1843 sys_siglist
[SIGWINCH
] = "Window size changed";
1846 sys_siglist
[SIGWIND
] = "SIGWIND";
1849 sys_siglist
[SIGXCPU
] = "CPU time limit exceeded";
1852 sys_siglist
[SIGXFSZ
] = "File size limit exceeded";
1855 #endif /* !HAVE_DECL_SYS_SIGLIST && !_sys_siglist */
1857 /* Don't alter signal handlers if dumping. On some machines,
1858 changing signal handlers sets static data that would make signals
1859 fail to work right when the dumped Emacs is run. */
1863 sigfillset (&process_fatal_action
.sa_mask
);
1864 process_fatal_action
.sa_handler
= deliver_fatal_signal
;
1865 process_fatal_action
.sa_flags
= emacs_sigaction_flags ();
1867 sigfillset (&thread_fatal_action
.sa_mask
);
1868 thread_fatal_action
.sa_handler
= deliver_fatal_thread_signal
;
1869 thread_fatal_action
.sa_flags
= process_fatal_action
.sa_flags
;
1871 /* SIGINT may need special treatment on MS-Windows. See
1872 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1873 Please update the doc of kill-emacs, kill-emacs-hook, and
1874 NEWS if you change this. */
1876 maybe_fatal_sig (SIGHUP
);
1877 maybe_fatal_sig (SIGINT
);
1878 maybe_fatal_sig (SIGTERM
);
1880 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1881 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1882 to behave more like typical batch applications do. */
1883 if (! noninteractive
)
1884 signal (SIGPIPE
, SIG_IGN
);
1886 sigaction (SIGQUIT
, &process_fatal_action
, 0);
1887 sigaction (SIGILL
, &thread_fatal_action
, 0);
1888 sigaction (SIGTRAP
, &thread_fatal_action
, 0);
1890 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1891 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1892 interpreter's floating point operations, so treat SIGFPE as an
1893 arith-error if it arises in the main thread. */
1894 if (IEEE_FLOATING_POINT
)
1895 sigaction (SIGFPE
, &thread_fatal_action
, 0);
1898 emacs_sigaction_init (&action
, deliver_arith_signal
);
1899 sigaction (SIGFPE
, &action
, 0);
1903 add_user_signal (SIGUSR1
, "sigusr1");
1906 add_user_signal (SIGUSR2
, "sigusr2");
1908 sigaction (SIGABRT
, &thread_fatal_action
, 0);
1910 sigaction (SIGPRE
, &thread_fatal_action
, 0);
1913 sigaction (SIGORE
, &thread_fatal_action
, 0);
1916 sigaction (SIGUME
, &thread_fatal_action
, 0);
1919 sigaction (SIGDLK
, &process_fatal_action
, 0);
1922 sigaction (SIGCPULIM
, &process_fatal_action
, 0);
1925 sigaction (SIGIOT
, &thread_fatal_action
, 0);
1928 sigaction (SIGEMT
, &thread_fatal_action
, 0);
1931 sigaction (SIGBUS
, &thread_fatal_action
, 0);
1933 sigaction (SIGSEGV
, &thread_fatal_action
, 0);
1935 sigaction (SIGSYS
, &thread_fatal_action
, 0);
1937 sigaction (SIGTERM
, &process_fatal_action
, 0);
1939 signal (SIGPROF
, SIG_IGN
);
1942 sigaction (SIGVTALRM
, &process_fatal_action
, 0);
1945 sigaction (SIGXCPU
, &process_fatal_action
, 0);
1948 sigaction (SIGXFSZ
, &process_fatal_action
, 0);
1952 /* This just means available memory is getting low. */
1953 emacs_sigaction_init (&action
, deliver_danger_signal
);
1954 sigaction (SIGDANGER
, &action
, 0);
1957 /* AIX-specific signals. */
1959 sigaction (SIGGRANT
, &process_fatal_action
, 0);
1962 sigaction (SIGMIGRATE
, &process_fatal_action
, 0);
1965 sigaction (SIGMSG
, &process_fatal_action
, 0);
1968 sigaction (SIGRETRACT
, &process_fatal_action
, 0);
1971 sigaction (SIGSAK
, &process_fatal_action
, 0);
1974 sigaction (SIGSOUND
, &process_fatal_action
, 0);
1977 sigaction (SIGTALRM
, &thread_fatal_action
, 0);
1987 /* Figure out how many bits the system's random number generator uses.
1988 `random' and `lrand48' are assumed to return 31 usable bits.
1989 BSD `rand' returns a 31 bit value but the low order bits are unusable;
1990 so we'll shift it and treat it like the 15-bit USG `rand'. */
1994 # define RAND_BITS 31
1995 # else /* !HAVE_RANDOM */
1996 # ifdef HAVE_LRAND48
1997 # define RAND_BITS 31
1998 # define random lrand48
1999 # else /* !HAVE_LRAND48 */
2000 # define RAND_BITS 15
2001 # if RAND_MAX == 32767
2002 # define random rand
2003 # else /* RAND_MAX != 32767 */
2004 # if RAND_MAX == 2147483647
2005 # define random() (rand () >> 16)
2006 # else /* RAND_MAX != 2147483647 */
2008 # define random rand
2010 # define random() (rand () >> 16)
2012 # endif /* RAND_MAX != 2147483647 */
2013 # endif /* RAND_MAX != 32767 */
2014 # endif /* !HAVE_LRAND48 */
2015 # endif /* !HAVE_RANDOM */
2016 #endif /* !RAND_BITS */
2019 seed_random (void *seed
, ptrdiff_t seed_size
)
2021 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
2022 unsigned int arg
= 0;
2026 unsigned char *argp
= (unsigned char *) &arg
;
2027 unsigned char *seedp
= seed
;
2029 for (i
= 0; i
< seed_size
; i
++)
2030 argp
[i
% sizeof arg
] ^= seedp
[i
];
2034 # ifdef HAVE_LRAND48
2045 EMACS_TIME t
= current_emacs_time ();
2046 uintmax_t v
= getpid () ^ EMACS_SECS (t
) ^ EMACS_NSECS (t
);
2047 seed_random (&v
, sizeof v
);
2051 * Return a nonnegative random integer out of whatever we've got.
2052 * It contains enough bits to make a random (signed) Emacs fixnum.
2053 * This suffices even for a 64-bit architecture with a 15-bit rand.
2060 for (i
= 0; i
< (FIXNUM_BITS
+ RAND_BITS
- 1) / RAND_BITS
; i
++)
2061 val
= (random () ^ (val
<< RAND_BITS
)
2062 ^ (val
>> (BITS_PER_EMACS_INT
- RAND_BITS
)));
2063 val
^= val
>> (BITS_PER_EMACS_INT
- FIXNUM_BITS
);
2064 return val
& INTMASK
;
2067 #ifndef HAVE_SNPRINTF
2068 /* Approximate snprintf as best we can on ancient hosts that lack it. */
2070 snprintf (char *buf
, size_t bufsize
, char const *format
, ...)
2072 ptrdiff_t size
= min (bufsize
, PTRDIFF_MAX
);
2073 ptrdiff_t nbytes
= size
- 1;
2078 va_start (ap
, format
);
2079 nbytes
= doprnt (buf
, size
, format
, 0, ap
);
2083 if (nbytes
== size
- 1)
2085 /* Calculate the length of the string that would have been created
2086 had the buffer been large enough. */
2087 char stackbuf
[4000];
2089 ptrdiff_t bsize
= sizeof stackbuf
;
2090 va_start (ap
, format
);
2091 nbytes
= evxprintf (&b
, &bsize
, stackbuf
, -1, format
, ap
);
2097 if (INT_MAX
< nbytes
)
2110 /* If a backtrace is available, output the top lines of it to stderr.
2111 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2112 This function may be called from a signal handler, so it should
2113 not invoke async-unsafe functions like malloc. */
2115 emacs_backtrace (int backtrace_limit
)
2117 void *main_backtrace_buffer
[BACKTRACE_LIMIT_MAX
+ 1];
2118 int bounded_limit
= min (backtrace_limit
, BACKTRACE_LIMIT_MAX
);
2122 if (thread_backtrace_npointers
)
2124 buffer
= thread_backtrace_buffer
;
2125 npointers
= thread_backtrace_npointers
;
2129 buffer
= main_backtrace_buffer
;
2130 npointers
= backtrace (buffer
, bounded_limit
+ 1);
2135 emacs_write (STDERR_FILENO
, "\nBacktrace:\n", 12);
2136 backtrace_symbols_fd (buffer
, npointers
, STDERR_FILENO
);
2137 if (bounded_limit
< npointers
)
2138 emacs_write (STDERR_FILENO
, "...\n", 4);
2146 terminate_due_to_signal (SIGABRT
, 40);
2150 /* Open FILE for Emacs use, using open flags OFLAG and mode MODE.
2151 Arrange for subprograms to not inherit the file descriptor.
2152 Prefer a method that is multithread-safe, if available.
2153 Do not fail merely because the open was interrupted by a signal.
2154 Allow the user to quit. */
2157 emacs_open (const char *file
, int oflags
, int mode
)
2160 oflags
|= O_CLOEXEC
;
2161 while ((fd
= open (file
, oflags
, mode
)) < 0 && errno
== EINTR
)
2163 if (! O_CLOEXEC
&& 0 <= fd
)
2164 fcntl (fd
, F_SETFD
, FD_CLOEXEC
);
2168 /* Open FILE as a stream for Emacs use, with mode MODE.
2169 Act like emacs_open with respect to threads, signals, and quits. */
2172 emacs_fopen (char const *file
, char const *mode
)
2174 int fd
, omode
, oflags
;
2176 char const *m
= mode
;
2180 case 'r': omode
= O_RDONLY
; oflags
= 0; break;
2181 case 'w': omode
= O_WRONLY
; oflags
= O_CREAT
| O_TRUNC
; break;
2182 case 'a': omode
= O_WRONLY
; oflags
= O_CREAT
| O_APPEND
; break;
2183 default: emacs_abort ();
2189 case '+': omode
= O_RDWR
; break;
2190 case 'b': bflag
= O_BINARY
; break;
2191 case 't': bflag
= O_TEXT
; break;
2192 default: /* Ignore. */ break;
2195 fd
= emacs_open (file
, omode
| oflags
| bflag
, 0666);
2196 return fd
< 0 ? 0 : fdopen (fd
, mode
);
2199 /* Create a pipe for Emacs use. */
2202 emacs_pipe (int fd
[2])
2204 int result
= pipe2 (fd
, O_CLOEXEC
);
2205 if (! O_CLOEXEC
&& result
== 0)
2207 fcntl (fd
[0], F_SETFD
, FD_CLOEXEC
);
2208 fcntl (fd
[1], F_SETFD
, FD_CLOEXEC
);
2213 /* Approximate posix_close and POSIX_CLOSE_RESTART well enough for Emacs.
2214 For the background behind this mess, please see Austin Group defect 529
2215 <http://austingroupbugs.net/view.php?id=529>. */
2217 #ifndef POSIX_CLOSE_RESTART
2218 # define POSIX_CLOSE_RESTART 1
2220 posix_close (int fd
, int flag
)
2222 /* Only the POSIX_CLOSE_RESTART case is emulated. */
2223 eassert (flag
== POSIX_CLOSE_RESTART
);
2225 /* Things are tricky if close (fd) returns -1 with errno == EINTR
2226 on a system that does not define POSIX_CLOSE_RESTART.
2228 In this case, in some systems (e.g., GNU/Linux, AIX) FD is
2229 closed, and retrying the close could inadvertently close a file
2230 descriptor allocated by some other thread. In other systems
2231 (e.g., HP/UX) FD is not closed. And in still other systems
2232 (e.g., OS X, Solaris), maybe FD is closed, maybe not, and in a
2233 multithreaded program there can be no way to tell.
2235 So, in this case, pretend that the close succeeded. This works
2236 well on systems like GNU/Linux that close FD. Although it may
2237 leak a file descriptor on other systems, the leak is unlikely and
2238 it's better to leak than to close a random victim. */
2239 return close (fd
) == 0 || errno
== EINTR
? 0 : -1;
2243 /* Close FD, retrying if interrupted. If successful, return 0;
2244 otherwise, return -1 and set errno to a non-EINTR value. Consider
2245 an EINPROGRESS error to be successful, as that's merely a signal
2246 arriving. FD is always closed when this function returns, even
2249 Do not call this function if FD is nonnegative and might already be closed,
2250 as that might close an innocent victim opened by some other thread. */
2253 emacs_close (int fd
)
2257 int r
= posix_close (fd
, POSIX_CLOSE_RESTART
);
2260 if (!POSIX_CLOSE_RESTART
|| errno
!= EINTR
)
2262 eassert (errno
!= EBADF
|| fd
< 0);
2263 return errno
== EINPROGRESS
? 0 : r
;
2268 /* Maximum number of bytes to read or write in a single system call.
2269 This works around a serious bug in Linux kernels before 2.6.16; see
2270 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2271 It's likely to work around similar bugs in other operating systems, so do it
2272 on all platforms. Round INT_MAX down to a page size, with the conservative
2273 assumption that page sizes are at most 2**18 bytes (any kernel with a
2274 page size larger than that shouldn't have the bug). */
2275 #ifndef MAX_RW_COUNT
2276 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2279 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2280 Return the number of bytes read, which might be less than NBYTE.
2281 On error, set errno and return -1. */
2283 emacs_read (int fildes
, char *buf
, ptrdiff_t nbyte
)
2285 register ssize_t rtnval
;
2287 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2288 passes a size that large to emacs_read. */
2290 while ((rtnval
= read (fildes
, buf
, nbyte
)) == -1
2291 && (errno
== EINTR
))
2296 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2297 or if a partial write occurs. If interrupted, process pending
2298 signals if PROCESS SIGNALS. Return the number of bytes written, setting
2299 errno if this is less than NBYTE. */
2301 emacs_full_write (int fildes
, char const *buf
, ptrdiff_t nbyte
,
2302 bool process_signals
)
2304 ptrdiff_t bytes_written
= 0;
2308 ssize_t n
= write (fildes
, buf
, min (nbyte
, MAX_RW_COUNT
));
2314 /* I originally used `QUIT' but that might causes files to
2315 be truncated if you hit C-g in the middle of it. --Stef */
2316 if (process_signals
&& pending_signals
)
2317 process_pending_signals ();
2329 return bytes_written
;
2332 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if
2333 interrupted or if a partial write occurs. Return the number of
2334 bytes written, setting errno if this is less than NBYTE. */
2336 emacs_write (int fildes
, char const *buf
, ptrdiff_t nbyte
)
2338 return emacs_full_write (fildes
, buf
, nbyte
, 0);
2341 /* Like emacs_write, but also process pending signals if interrupted. */
2343 emacs_write_sig (int fildes
, char const *buf
, ptrdiff_t nbyte
)
2345 return emacs_full_write (fildes
, buf
, nbyte
, 1);
2348 /* Write a diagnostic to standard error that contains MESSAGE and a
2349 string derived from errno. Preserve errno. Do not buffer stderr.
2350 Do not process pending signals if interrupted. */
2352 emacs_perror (char const *message
)
2355 char const *error_string
= strerror (err
);
2356 char const *command
= (initial_argv
&& initial_argv
[0]
2357 ? initial_argv
[0] : "emacs");
2358 /* Write it out all at once, if it's short; this is less likely to
2359 be interleaved with other output. */
2361 int nbytes
= snprintf (buf
, sizeof buf
, "%s: %s: %s\n",
2362 command
, message
, error_string
);
2363 if (0 <= nbytes
&& nbytes
< BUFSIZ
)
2364 emacs_write (STDERR_FILENO
, buf
, nbytes
);
2367 emacs_write (STDERR_FILENO
, command
, strlen (command
));
2368 emacs_write (STDERR_FILENO
, ": ", 2);
2369 emacs_write (STDERR_FILENO
, message
, strlen (message
));
2370 emacs_write (STDERR_FILENO
, ": ", 2);
2371 emacs_write (STDERR_FILENO
, error_string
, strlen (error_string
));
2372 emacs_write (STDERR_FILENO
, "\n", 1);
2377 /* Return a struct timeval that is roughly equivalent to T.
2378 Use the least timeval not less than T.
2379 Return an extremal value if the result would overflow. */
2381 make_timeval (EMACS_TIME t
)
2384 tv
.tv_sec
= t
.tv_sec
;
2385 tv
.tv_usec
= t
.tv_nsec
/ 1000;
2387 if (t
.tv_nsec
% 1000 != 0)
2389 if (tv
.tv_usec
< 999999)
2391 else if (tv
.tv_sec
< TYPE_MAXIMUM (time_t))
2401 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2402 ATIME and MTIME, respectively.
2403 FD must be either negative -- in which case it is ignored --
2404 or a file descriptor that is open on FILE.
2405 If FD is nonnegative, then FILE can be NULL. */
2407 set_file_times (int fd
, const char *filename
,
2408 EMACS_TIME atime
, EMACS_TIME mtime
)
2410 struct timespec timespec
[2];
2411 timespec
[0] = atime
;
2412 timespec
[1] = mtime
;
2413 return fdutimens (fd
, filename
, timespec
);
2416 /* Like strsignal, except async-signal-safe, and this function typically
2417 returns a string in the C locale rather than the current locale. */
2419 safe_strsignal (int code
)
2421 char const *signame
= 0;
2423 if (0 <= code
&& code
< sys_siglist_entries
)
2424 signame
= sys_siglist
[code
];
2426 signame
= "Unknown signal";
2432 /* For make-serial-process */
2434 serial_open (Lisp_Object port
)
2436 int fd
= emacs_open (SSDATA (port
), O_RDWR
| O_NOCTTY
| O_NONBLOCK
, 0);
2438 report_file_error ("Opening serial port", port
);
2440 ioctl (fd
, TIOCEXCL
, (char *) 0);
2446 #if !defined (HAVE_CFMAKERAW)
2447 /* Workaround for targets which are missing cfmakeraw. */
2448 /* Pasted from man page. */
2450 cfmakeraw (struct termios
*termios_p
)
2452 termios_p
->c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2453 termios_p
->c_oflag
&= ~OPOST
;
2454 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2455 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2456 termios_p
->c_cflag
|= CS8
;
2458 #endif /* !defined (HAVE_CFMAKERAW */
2460 #if !defined (HAVE_CFSETSPEED)
2461 /* Workaround for targets which are missing cfsetspeed. */
2463 cfsetspeed (struct termios
*termios_p
, speed_t vitesse
)
2465 return (cfsetispeed (termios_p
, vitesse
)
2466 + cfsetospeed (termios_p
, vitesse
));
2470 /* For serial-process-configure */
2472 serial_configure (struct Lisp_Process
*p
,
2473 Lisp_Object contact
)
2475 Lisp_Object childp2
= Qnil
;
2476 Lisp_Object tem
= Qnil
;
2477 struct termios attr
;
2479 char summary
[4] = "???"; /* This usually becomes "8N1". */
2481 childp2
= Fcopy_sequence (p
->childp
);
2483 /* Read port attributes and prepare default configuration. */
2484 err
= tcgetattr (p
->outfd
, &attr
);
2486 report_file_error ("Failed tcgetattr", Qnil
);
2488 #if defined (CLOCAL)
2489 attr
.c_cflag
|= CLOCAL
;
2492 attr
.c_cflag
|= CREAD
;
2495 /* Configure speed. */
2496 if (!NILP (Fplist_member (contact
, QCspeed
)))
2497 tem
= Fplist_get (contact
, QCspeed
);
2499 tem
= Fplist_get (p
->childp
, QCspeed
);
2501 err
= cfsetspeed (&attr
, XINT (tem
));
2503 report_file_error ("Failed cfsetspeed", tem
);
2504 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
2506 /* Configure bytesize. */
2507 if (!NILP (Fplist_member (contact
, QCbytesize
)))
2508 tem
= Fplist_get (contact
, QCbytesize
);
2510 tem
= Fplist_get (p
->childp
, QCbytesize
);
2512 tem
= make_number (8);
2514 if (XINT (tem
) != 7 && XINT (tem
) != 8)
2515 error (":bytesize must be nil (8), 7, or 8");
2516 summary
[0] = XINT (tem
) + '0';
2517 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2518 attr
.c_cflag
&= ~CSIZE
;
2519 attr
.c_cflag
|= ((XINT (tem
) == 7) ? CS7
: CS8
);
2521 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2522 if (XINT (tem
) != 8)
2523 error ("Bytesize cannot be changed");
2525 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
2527 /* Configure parity. */
2528 if (!NILP (Fplist_member (contact
, QCparity
)))
2529 tem
= Fplist_get (contact
, QCparity
);
2531 tem
= Fplist_get (p
->childp
, QCparity
);
2532 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
2533 error (":parity must be nil (no parity), `even', or `odd'");
2534 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2535 attr
.c_cflag
&= ~(PARENB
| PARODD
);
2536 attr
.c_iflag
&= ~(IGNPAR
| INPCK
);
2541 else if (EQ (tem
, Qeven
))
2544 attr
.c_cflag
|= PARENB
;
2545 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2547 else if (EQ (tem
, Qodd
))
2550 attr
.c_cflag
|= (PARENB
| PARODD
);
2551 attr
.c_iflag
|= (IGNPAR
| INPCK
);
2554 /* Don't error on no parity, which should be set by cfmakeraw. */
2556 error ("Parity cannot be configured");
2558 childp2
= Fplist_put (childp2
, QCparity
, tem
);
2560 /* Configure stopbits. */
2561 if (!NILP (Fplist_member (contact
, QCstopbits
)))
2562 tem
= Fplist_get (contact
, QCstopbits
);
2564 tem
= Fplist_get (p
->childp
, QCstopbits
);
2566 tem
= make_number (1);
2568 if (XINT (tem
) != 1 && XINT (tem
) != 2)
2569 error (":stopbits must be nil (1 stopbit), 1, or 2");
2570 summary
[2] = XINT (tem
) + '0';
2571 #if defined (CSTOPB)
2572 attr
.c_cflag
&= ~CSTOPB
;
2573 if (XINT (tem
) == 2)
2574 attr
.c_cflag
|= CSTOPB
;
2576 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2577 if (XINT (tem
) != 1)
2578 error ("Stopbits cannot be configured");
2580 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
2582 /* Configure flowcontrol. */
2583 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
2584 tem
= Fplist_get (contact
, QCflowcontrol
);
2586 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
2587 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
2588 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2589 #if defined (CRTSCTS)
2590 attr
.c_cflag
&= ~CRTSCTS
;
2592 #if defined (CNEW_RTSCTS)
2593 attr
.c_cflag
&= ~CNEW_RTSCTS
;
2595 #if defined (IXON) && defined (IXOFF)
2596 attr
.c_iflag
&= ~(IXON
| IXOFF
);
2600 /* Already configured. */
2602 else if (EQ (tem
, Qhw
))
2604 #if defined (CRTSCTS)
2605 attr
.c_cflag
|= CRTSCTS
;
2606 #elif defined (CNEW_RTSCTS)
2607 attr
.c_cflag
|= CNEW_RTSCTS
;
2609 error ("Hardware flowcontrol (RTS/CTS) not supported");
2612 else if (EQ (tem
, Qsw
))
2614 #if defined (IXON) && defined (IXOFF)
2615 attr
.c_iflag
|= (IXON
| IXOFF
);
2617 error ("Software flowcontrol (XON/XOFF) not supported");
2620 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
2622 /* Activate configuration. */
2623 err
= tcsetattr (p
->outfd
, TCSANOW
, &attr
);
2625 report_file_error ("Failed tcsetattr", Qnil
);
2627 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
2628 pset_childp (p
, childp2
);
2630 #endif /* not DOS_NT */
2632 /* System depended enumeration of and access to system processes a-la ps(1). */
2636 /* Process enumeration and access via /proc. */
2639 list_system_processes (void)
2641 Lisp_Object procdir
, match
, proclist
, next
;
2642 struct gcpro gcpro1
, gcpro2
;
2643 register Lisp_Object tail
;
2645 GCPRO2 (procdir
, match
);
2646 /* For every process on the system, there's a directory in the
2647 "/proc" pseudo-directory whose name is the numeric ID of that
2649 procdir
= build_string ("/proc");
2650 match
= build_string ("[0-9]+");
2651 proclist
= directory_files_internal (procdir
, Qnil
, match
, Qt
, 0, Qnil
);
2653 /* `proclist' gives process IDs as strings. Destructively convert
2654 each string into a number. */
2655 for (tail
= proclist
; CONSP (tail
); tail
= next
)
2658 XSETCAR (tail
, Fstring_to_number (XCAR (tail
), Qnil
));
2662 /* directory_files_internal returns the files in reverse order; undo
2664 proclist
= Fnreverse (proclist
);
2668 #elif defined DARWIN_OS || defined __FreeBSD__
2671 list_system_processes (void)
2674 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_ALL
};
2676 int mib
[] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PROC
};
2679 struct kinfo_proc
*procs
;
2682 struct gcpro gcpro1
;
2683 Lisp_Object proclist
= Qnil
;
2685 if (sysctl (mib
, 3, NULL
, &len
, NULL
, 0) != 0)
2688 procs
= xmalloc (len
);
2689 if (sysctl (mib
, 3, procs
, &len
, NULL
, 0) != 0)
2696 len
/= sizeof (struct kinfo_proc
);
2697 for (i
= 0; i
< len
; i
++)
2700 proclist
= Fcons (make_fixnum_or_float (procs
[i
].kp_proc
.p_pid
), proclist
);
2702 proclist
= Fcons (make_fixnum_or_float (procs
[i
].ki_pid
), proclist
);
2712 /* The WINDOWSNT implementation is in w32.c.
2713 The MSDOS implementation is in dosfns.c. */
2714 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2717 list_system_processes (void)
2722 #endif /* !defined (WINDOWSNT) */
2724 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
2726 time_from_jiffies (unsigned long long tval
, long hz
)
2728 unsigned long long s
= tval
/ hz
;
2729 unsigned long long frac
= tval
% hz
;
2732 if (TYPE_MAXIMUM (time_t) < s
)
2734 if (LONG_MAX
- 1 <= ULLONG_MAX
/ EMACS_TIME_RESOLUTION
2735 || frac
<= ULLONG_MAX
/ EMACS_TIME_RESOLUTION
)
2736 ns
= frac
* EMACS_TIME_RESOLUTION
/ hz
;
2739 /* This is reachable only in the unlikely case that HZ * HZ
2740 exceeds ULLONG_MAX. It calculates an approximation that is
2741 guaranteed to be in range. */
2742 long hz_per_ns
= (hz
/ EMACS_TIME_RESOLUTION
2743 + (hz
% EMACS_TIME_RESOLUTION
!= 0));
2744 ns
= frac
/ hz_per_ns
;
2747 return make_emacs_time (s
, ns
);
2751 ltime_from_jiffies (unsigned long long tval
, long hz
)
2753 EMACS_TIME t
= time_from_jiffies (tval
, hz
);
2754 return make_lisp_time (t
);
2761 EMACS_TIME up
= make_emacs_time (0, 0);
2764 fup
= emacs_fopen ("/proc/uptime", "r");
2768 unsigned long long upsec
, upfrac
, idlesec
, idlefrac
;
2769 int upfrac_start
, upfrac_end
, idlefrac_start
, idlefrac_end
;
2771 if (fscanf (fup
, "%llu.%n%llu%n %llu.%n%llu%n",
2772 &upsec
, &upfrac_start
, &upfrac
, &upfrac_end
,
2773 &idlesec
, &idlefrac_start
, &idlefrac
, &idlefrac_end
)
2776 if (TYPE_MAXIMUM (time_t) < upsec
)
2778 upsec
= TYPE_MAXIMUM (time_t);
2779 upfrac
= EMACS_TIME_RESOLUTION
- 1;
2783 int upfraclen
= upfrac_end
- upfrac_start
;
2784 for (; upfraclen
< LOG10_EMACS_TIME_RESOLUTION
; upfraclen
++)
2786 for (; LOG10_EMACS_TIME_RESOLUTION
< upfraclen
; upfraclen
--)
2788 upfrac
= min (upfrac
, EMACS_TIME_RESOLUTION
- 1);
2790 up
= make_emacs_time (upsec
, upfrac
);
2799 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2800 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2803 procfs_ttyname (int rdev
)
2806 char name
[PATH_MAX
];
2809 fdev
= emacs_fopen ("/proc/tty/drivers", "r");
2815 unsigned long minor_beg
, minor_end
;
2816 char minor
[25]; /* 2 32-bit numbers + dash */
2819 for (; !feof (fdev
) && !ferror (fdev
); name
[0] = 0)
2821 if (fscanf (fdev
, "%*s %s %u %s %*s\n", name
, &major
, minor
) >= 3
2822 && major
== MAJOR (rdev
))
2824 minor_beg
= strtoul (minor
, &endp
, 0);
2826 minor_end
= minor_beg
;
2827 else if (*endp
== '-')
2828 minor_end
= strtoul (endp
+ 1, &endp
, 0);
2832 if (MINOR (rdev
) >= minor_beg
&& MINOR (rdev
) <= minor_end
)
2834 sprintf (name
+ strlen (name
), "%u", MINOR (rdev
));
2842 return build_string (name
);
2845 static unsigned long
2846 procfs_get_total_memory (void)
2849 unsigned long retval
= 2 * 1024 * 1024; /* default: 2GB */
2852 fmem
= emacs_fopen ("/proc/meminfo", "r");
2856 unsigned long entry_value
;
2857 char entry_name
[20]; /* the longest I saw is 13+1 */
2859 while (!feof (fmem
) && !ferror (fmem
))
2861 if (fscanf (fmem
, "%s %lu kB\n", entry_name
, &entry_value
) >= 2
2862 && strcmp (entry_name
, "MemTotal:") == 0)
2864 retval
= entry_value
;
2875 system_process_attributes (Lisp_Object pid
)
2877 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
2881 long clocks_per_sec
;
2883 char procbuf
[1025], *p
, *q
;
2886 static char const default_cmd
[] = "???";
2887 const char *cmd
= default_cmd
;
2888 int cmdsize
= sizeof default_cmd
- 1;
2889 char *cmdline
= NULL
;
2890 ptrdiff_t cmdline_size
;
2893 int ppid
, pgrp
, sess
, tty
, tpgid
, thcount
;
2896 unsigned long long u_time
, s_time
, cutime
, cstime
, start
;
2897 long priority
, niceness
, rss
;
2898 unsigned long minflt
, majflt
, cminflt
, cmajflt
, vsize
;
2899 EMACS_TIME tnow
, tstart
, tboot
, telapsed
, us_time
;
2901 Lisp_Object attrs
= Qnil
;
2902 Lisp_Object cmd_str
, decoded_cmd
;
2904 struct gcpro gcpro1
, gcpro2
;
2906 CHECK_NUMBER_OR_FLOAT (pid
);
2907 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
2908 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
2909 if (stat (procfn
, &st
) < 0)
2912 GCPRO2 (attrs
, decoded_cmd
);
2916 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
2918 pw
= getpwuid (uid
);
2921 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
2924 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
2926 gr
= getgrgid (gid
);
2929 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
2931 count
= SPECPDL_INDEX ();
2932 strcpy (fn
, procfn
);
2933 procfn_end
= fn
+ strlen (fn
);
2934 strcpy (procfn_end
, "/stat");
2935 fd
= emacs_open (fn
, O_RDONLY
, 0);
2940 record_unwind_protect_int (close_file_unwind
, fd
);
2941 nread
= emacs_read (fd
, procbuf
, sizeof procbuf
- 1);
2945 procbuf
[nread
] = '\0';
2948 p
= strchr (p
, '(');
2951 q
= strrchr (p
+ 1, ')');
2961 /* Command name is encoded in locale-coding-system; decode it. */
2962 cmd_str
= make_unibyte_string (cmd
, cmdsize
);
2963 decoded_cmd
= code_convert_string_norecord (cmd_str
,
2964 Vlocale_coding_system
, 0);
2965 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
2967 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt
2968 utime stime cutime cstime priority nice thcount . start vsize rss */
2970 && (sscanf (q
+ 2, ("%c %d %d %d %d %d %*u %lu %lu %lu %lu "
2971 "%Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld"),
2972 &c
, &ppid
, &pgrp
, &sess
, &tty
, &tpgid
,
2973 &minflt
, &cminflt
, &majflt
, &cmajflt
,
2974 &u_time
, &s_time
, &cutime
, &cstime
,
2975 &priority
, &niceness
, &thcount
, &start
, &vsize
, &rss
)
2980 state_str
[1] = '\0';
2981 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
2982 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (ppid
)), attrs
);
2983 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pgrp
)), attrs
);
2984 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (sess
)), attrs
);
2985 attrs
= Fcons (Fcons (Qttname
, procfs_ttyname (tty
)), attrs
);
2986 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (tpgid
)), attrs
);
2987 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (minflt
)), attrs
);
2988 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (majflt
)), attrs
);
2989 attrs
= Fcons (Fcons (Qcminflt
, make_fixnum_or_float (cminflt
)),
2991 attrs
= Fcons (Fcons (Qcmajflt
, make_fixnum_or_float (cmajflt
)),
2993 clocks_per_sec
= sysconf (_SC_CLK_TCK
);
2994 if (clocks_per_sec
< 0)
2995 clocks_per_sec
= 100;
2996 attrs
= Fcons (Fcons (Qutime
,
2997 ltime_from_jiffies (u_time
, clocks_per_sec
)),
2999 attrs
= Fcons (Fcons (Qstime
,
3000 ltime_from_jiffies (s_time
, clocks_per_sec
)),
3002 attrs
= Fcons (Fcons (Qtime
,
3003 ltime_from_jiffies (s_time
+ u_time
,
3006 attrs
= Fcons (Fcons (Qcutime
,
3007 ltime_from_jiffies (cutime
, clocks_per_sec
)),
3009 attrs
= Fcons (Fcons (Qcstime
,
3010 ltime_from_jiffies (cstime
, clocks_per_sec
)),
3012 attrs
= Fcons (Fcons (Qctime
,
3013 ltime_from_jiffies (cstime
+ cutime
,
3016 attrs
= Fcons (Fcons (Qpri
, make_number (priority
)), attrs
);
3017 attrs
= Fcons (Fcons (Qnice
, make_number (niceness
)), attrs
);
3018 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (thcount
)),
3020 tnow
= current_emacs_time ();
3021 telapsed
= get_up_time ();
3022 tboot
= sub_emacs_time (tnow
, telapsed
);
3023 tstart
= time_from_jiffies (start
, clocks_per_sec
);
3024 tstart
= add_emacs_time (tboot
, tstart
);
3025 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (tstart
)), attrs
);
3026 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (vsize
/ 1024)),
3028 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (4 * rss
)), attrs
);
3029 telapsed
= sub_emacs_time (tnow
, tstart
);
3030 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (telapsed
)), attrs
);
3031 us_time
= time_from_jiffies (u_time
+ s_time
, clocks_per_sec
);
3032 pcpu
= (EMACS_TIME_TO_DOUBLE (us_time
)
3033 / EMACS_TIME_TO_DOUBLE (telapsed
));
3036 attrs
= Fcons (Fcons (Qpcpu
, make_float (100 * pcpu
)), attrs
);
3037 pmem
= 4.0 * 100 * rss
/ procfs_get_total_memory ();
3040 attrs
= Fcons (Fcons (Qpmem
, make_float (pmem
)), attrs
);
3043 unbind_to (count
, Qnil
);
3046 strcpy (procfn_end
, "/cmdline");
3047 fd
= emacs_open (fn
, O_RDONLY
, 0);
3050 ptrdiff_t readsize
, nread_incr
;
3051 record_unwind_protect_int (close_file_unwind
, fd
);
3052 record_unwind_protect_nothing ();
3053 nread
= cmdline_size
= 0;
3057 cmdline
= xpalloc (cmdline
, &cmdline_size
, 2, STRING_BYTES_BOUND
, 1);
3058 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3060 /* Leave room even if every byte needs escaping below. */
3061 readsize
= (cmdline_size
>> 1) - nread
;
3063 nread_incr
= emacs_read (fd
, cmdline
+ nread
, readsize
);
3064 nread
+= max (0, nread_incr
);
3066 while (nread_incr
== readsize
);
3070 /* We don't want trailing null characters. */
3071 for (p
= cmdline
+ nread
; cmdline
< p
&& !p
[-1]; p
--)
3074 /* Escape-quote whitespace and backslashes. */
3075 q
= cmdline
+ cmdline_size
;
3080 if (c_isspace (c
) || c
== '\\')
3084 nread
= cmdline
+ cmdline_size
- q
;
3089 nread
= cmdsize
+ 2;
3090 cmdline_size
= nread
+ 1;
3091 q
= cmdline
= xrealloc (cmdline
, cmdline_size
);
3092 set_unwind_protect_ptr (count
+ 1, xfree
, cmdline
);
3093 sprintf (cmdline
, "[%.*s]", cmdsize
, cmd
);
3095 /* Command line is encoded in locale-coding-system; decode it. */
3096 cmd_str
= make_unibyte_string (q
, nread
);
3097 decoded_cmd
= code_convert_string_norecord (cmd_str
,
3098 Vlocale_coding_system
, 0);
3099 unbind_to (count
, Qnil
);
3100 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3107 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
3109 /* The <procfs.h> header does not like to be included if _LP64 is defined and
3110 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
3111 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
3112 #define PROCFS_FILE_OFFSET_BITS_HACK 1
3113 #undef _FILE_OFFSET_BITS
3115 #define PROCFS_FILE_OFFSET_BITS_HACK 0
3120 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3121 #define _FILE_OFFSET_BITS 64
3122 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3124 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3127 system_process_attributes (Lisp_Object pid
)
3129 char procfn
[PATH_MAX
], fn
[PATH_MAX
];
3134 struct psinfo pinfo
;
3140 Lisp_Object attrs
= Qnil
;
3141 Lisp_Object decoded_cmd
;
3142 struct gcpro gcpro1
, gcpro2
;
3145 CHECK_NUMBER_OR_FLOAT (pid
);
3146 CONS_TO_INTEGER (pid
, pid_t
, proc_id
);
3147 sprintf (procfn
, "/proc/%"pMd
, proc_id
);
3148 if (stat (procfn
, &st
) < 0)
3151 GCPRO2 (attrs
, decoded_cmd
);
3155 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (uid
)), attrs
);
3157 pw
= getpwuid (uid
);
3160 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3163 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (gid
)), attrs
);
3165 gr
= getgrgid (gid
);
3168 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3170 count
= SPECPDL_INDEX ();
3171 strcpy (fn
, procfn
);
3172 procfn_end
= fn
+ strlen (fn
);
3173 strcpy (procfn_end
, "/psinfo");
3174 fd
= emacs_open (fn
, O_RDONLY
, 0);
3179 record_unwind_protect (close_file_unwind
, fd
);
3180 nread
= emacs_read (fd
, &pinfo
, sizeof pinfo
);
3183 if (nread
== sizeof pinfo
)
3185 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (pinfo
.pr_ppid
)), attrs
);
3186 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (pinfo
.pr_pgid
)), attrs
);
3187 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (pinfo
.pr_sid
)), attrs
);
3191 state_str
[0] = pinfo
.pr_lwp
.pr_sname
;
3192 state_str
[1] = '\0';
3193 attrs
= Fcons (Fcons (Qstate
, build_string (state_str
)), attrs
);
3196 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3197 need to get a string from it. */
3199 /* FIXME: missing: Qtpgid */
3211 Are they available? */
3213 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (pinfo
.pr_time
)), attrs
);
3214 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (pinfo
.pr_ctime
)), attrs
);
3215 attrs
= Fcons (Fcons (Qpri
, make_number (pinfo
.pr_lwp
.pr_pri
)), attrs
);
3216 attrs
= Fcons (Fcons (Qnice
, make_number (pinfo
.pr_lwp
.pr_nice
)), attrs
);
3217 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (pinfo
.pr_nlwp
)),
3220 attrs
= Fcons (Fcons (Qstart
, make_lisp_time (pinfo
.pr_start
)), attrs
);
3221 attrs
= Fcons (Fcons (Qvsize
, make_fixnum_or_float (pinfo
.pr_size
)),
3223 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (pinfo
.pr_rssize
)),
3226 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3227 range 0 .. 2**15, representing 0.0 .. 1.0. */
3228 attrs
= Fcons (Fcons (Qpcpu
,
3229 make_float (100.0 / 0x8000 * pinfo
.pr_pctcpu
)),
3231 attrs
= Fcons (Fcons (Qpmem
,
3232 make_float (100.0 / 0x8000 * pinfo
.pr_pctmem
)),
3235 decoded_cmd
= (code_convert_string_norecord
3236 (build_unibyte_string (pinfo
.pr_fname
),
3237 Vlocale_coding_system
, 0));
3238 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
3239 decoded_cmd
= (code_convert_string_norecord
3240 (build_unibyte_string (pinfo
.pr_psargs
),
3241 Vlocale_coding_system
, 0));
3242 attrs
= Fcons (Fcons (Qargs
, decoded_cmd
), attrs
);
3244 unbind_to (count
, Qnil
);
3249 #elif defined __FreeBSD__
3252 timeval_to_EMACS_TIME (struct timeval t
)
3254 return make_emacs_time (t
.tv_sec
, t
.tv_usec
* 1000);
3258 make_lisp_timeval (struct timeval t
)
3260 return make_lisp_time (timeval_to_EMACS_TIME (t
));
3264 system_process_attributes (Lisp_Object pid
)
3267 int pagesize
= getpagesize ();
3274 char args
[MAXPATHLEN
];
3277 int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PID
};
3278 struct kinfo_proc proc
;
3279 size_t proclen
= sizeof proc
;
3281 struct gcpro gcpro1
, gcpro2
;
3282 Lisp_Object attrs
= Qnil
;
3283 Lisp_Object decoded_comm
;
3285 CHECK_NUMBER_OR_FLOAT (pid
);
3286 CONS_TO_INTEGER (pid
, int, proc_id
);
3289 if (sysctl (mib
, 4, &proc
, &proclen
, NULL
, 0) != 0)
3292 GCPRO2 (attrs
, decoded_comm
);
3294 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (proc
.ki_uid
)), attrs
);
3297 pw
= getpwuid (proc
.ki_uid
);
3300 attrs
= Fcons (Fcons (Quser
, build_string (pw
->pw_name
)), attrs
);
3302 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (proc
.ki_svgid
)), attrs
);
3305 gr
= getgrgid (proc
.ki_svgid
);
3308 attrs
= Fcons (Fcons (Qgroup
, build_string (gr
->gr_name
)), attrs
);
3310 decoded_comm
= (code_convert_string_norecord
3311 (build_unibyte_string (proc
.ki_comm
),
3312 Vlocale_coding_system
, 0));
3314 attrs
= Fcons (Fcons (Qcomm
, decoded_comm
), attrs
);
3316 char state
[2] = {'\0', '\0'};
3317 switch (proc
.ki_stat
)
3339 attrs
= Fcons (Fcons (Qstate
, build_string (state
)), attrs
);
3342 attrs
= Fcons (Fcons (Qppid
, make_fixnum_or_float (proc
.ki_ppid
)), attrs
);
3343 attrs
= Fcons (Fcons (Qpgrp
, make_fixnum_or_float (proc
.ki_pgid
)), attrs
);
3344 attrs
= Fcons (Fcons (Qsess
, make_fixnum_or_float (proc
.ki_sid
)), attrs
);
3347 ttyname
= proc
.ki_tdev
== NODEV
? NULL
: devname (proc
.ki_tdev
, S_IFCHR
);
3350 attrs
= Fcons (Fcons (Qtty
, build_string (ttyname
)), attrs
);
3352 attrs
= Fcons (Fcons (Qtpgid
, make_fixnum_or_float (proc
.ki_tpgid
)), attrs
);
3353 attrs
= Fcons (Fcons (Qminflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_minflt
)), attrs
);
3354 attrs
= Fcons (Fcons (Qmajflt
, make_fixnum_or_float (proc
.ki_rusage
.ru_majflt
)), attrs
);
3355 attrs
= Fcons (Fcons (Qcminflt
, make_number (proc
.ki_rusage_ch
.ru_minflt
)), attrs
);
3356 attrs
= Fcons (Fcons (Qcmajflt
, make_number (proc
.ki_rusage_ch
.ru_majflt
)), attrs
);
3358 attrs
= Fcons (Fcons (Qutime
, make_lisp_timeval (proc
.ki_rusage
.ru_utime
)),
3360 attrs
= Fcons (Fcons (Qstime
, make_lisp_timeval (proc
.ki_rusage
.ru_stime
)),
3362 t
= add_emacs_time (timeval_to_EMACS_TIME (proc
.ki_rusage
.ru_utime
),
3363 timeval_to_EMACS_TIME (proc
.ki_rusage
.ru_stime
));
3364 attrs
= Fcons (Fcons (Qtime
, make_lisp_time (t
)), attrs
);
3366 attrs
= Fcons (Fcons (Qcutime
,
3367 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3369 attrs
= Fcons (Fcons (Qcstime
,
3370 make_lisp_timeval (proc
.ki_rusage_ch
.ru_utime
)),
3372 t
= add_emacs_time (timeval_to_EMACS_TIME (proc
.ki_rusage_ch
.ru_utime
),
3373 timeval_to_EMACS_TIME (proc
.ki_rusage_ch
.ru_stime
));
3374 attrs
= Fcons (Fcons (Qctime
, make_lisp_time (t
)), attrs
);
3376 attrs
= Fcons (Fcons (Qthcount
, make_fixnum_or_float (proc
.ki_numthreads
)),
3378 attrs
= Fcons (Fcons (Qpri
, make_number (proc
.ki_pri
.pri_native
)), attrs
);
3379 attrs
= Fcons (Fcons (Qnice
, make_number (proc
.ki_nice
)), attrs
);
3380 attrs
= Fcons (Fcons (Qstart
, make_lisp_timeval (proc
.ki_start
)), attrs
);
3381 attrs
= Fcons (Fcons (Qvsize
, make_number (proc
.ki_size
>> 10)), attrs
);
3382 attrs
= Fcons (Fcons (Qrss
, make_number (proc
.ki_rssize
* pagesize
>> 10)),
3385 now
= current_emacs_time ();
3386 t
= sub_emacs_time (now
, timeval_to_EMACS_TIME (proc
.ki_start
));
3387 attrs
= Fcons (Fcons (Qetime
, make_lisp_time (t
)), attrs
);
3389 len
= sizeof fscale
;
3390 if (sysctlbyname ("kern.fscale", &fscale
, &len
, NULL
, 0) == 0)
3395 if (sysctlbyname ("kern.ccpu", &ccpu
, &len
, NULL
, 0) == 0)
3397 pcpu
= (100.0 * proc
.ki_pctcpu
/ fscale
3398 / (1 - exp (proc
.ki_swtime
* log ((double) ccpu
/ fscale
))));
3399 attrs
= Fcons (Fcons (Qpcpu
, make_fixnum_or_float (pcpu
)), attrs
);
3403 len
= sizeof npages
;
3404 if (sysctlbyname ("hw.availpages", &npages
, &len
, NULL
, 0) == 0)
3406 double pmem
= (proc
.ki_flag
& P_INMEM
3407 ? 100.0 * proc
.ki_rssize
/ npages
3409 attrs
= Fcons (Fcons (Qpmem
, make_fixnum_or_float (pmem
)), attrs
);
3412 mib
[2] = KERN_PROC_ARGS
;
3414 if (sysctl (mib
, 4, args
, &len
, NULL
, 0) == 0)
3417 for (i
= 0; i
< len
; i
++)
3419 if (! args
[i
] && i
< len
- 1)
3424 (code_convert_string_norecord
3425 (build_unibyte_string (args
),
3426 Vlocale_coding_system
, 0));
3428 attrs
= Fcons (Fcons (Qargs
, decoded_comm
), attrs
);
3435 /* The WINDOWSNT implementation is in w32.c.
3436 The MSDOS implementation is in dosfns.c. */
3437 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3440 system_process_attributes (Lisp_Object pid
)
3445 #endif /* !defined (WINDOWSNT) */