HCoop / bpt / emacs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
file-attributes has a new optional arg FOLLOW-SYMLINKS.
[bpt/emacs.git] / src / sysdep.c
1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1993-1995, 1999-2012
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
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.
11
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.
16
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/>. */
19
20 #include <config.h>
21
22 #define SYSTIME_INLINE EXTERN_INLINE
23
24 #include <execinfo.h>
25 #include <stdio.h>
26 #ifdef HAVE_PWD_H
27 #include <pwd.h>
28 #include <grp.h>
29 #endif /* HAVE_PWD_H */
30 #include <limits.h>
31 #include <unistd.h>
32
33 #include <allocator.h>
34 #include <c-ctype.h>
35 #include <careadlinkat.h>
36 #include <ignore-value.h>
37 #include <utimens.h>
38
39 #include "lisp.h"
40 #include "sysselect.h"
41 #include "blockinput.h"
42
43 #ifdef BSD_SYSTEM
44 #include <sys/param.h>
45 #include <sys/sysctl.h>
46 #endif
47
48 #ifdef __FreeBSD__
49 #include <sys/user.h>
50 #include <sys/resource.h>
51 #include <math.h>
52 #endif
53
54 #ifdef WINDOWSNT
55 #define read sys_read
56 #define write sys_write
57 #include <windows.h>
58 #endif /* not WINDOWSNT */
59
60 #include <sys/types.h>
61 #include <sys/stat.h>
62 #include <errno.h>
63
64 /* Get SI_SRPC_DOMAIN, if it is available. */
65 #ifdef HAVE_SYS_SYSTEMINFO_H
66 #include <sys/systeminfo.h>
67 #endif
68
69 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
70 #include "msdos.h"
71 #include <sys/param.h>
72 #endif
73
74 #include <sys/file.h>
75 #include <fcntl.h>
76
77 #include "systty.h"
78 #include "syswait.h"
79
80 #ifdef HAVE_SYS_UTSNAME_H
81 #include <sys/utsname.h>
82 #include <memory.h>
83 #endif /* HAVE_SYS_UTSNAME_H */
84
85 #include "keyboard.h"
86 #include "frame.h"
87 #include "window.h"
88 #include "termhooks.h"
89 #include "termchar.h"
90 #include "termopts.h"
91 #include "dispextern.h"
92 #include "process.h"
93 #include "cm.h" /* for reset_sys_modes */
94
95 #ifdef WINDOWSNT
96 #include <direct.h>
97 /* In process.h which conflicts with the local copy. */
98 #define _P_WAIT 0
99 int _cdecl _spawnlp (int, const char *, const char *, ...);
100 int _cdecl _getpid (void);
101 extern char *getwd (char *);
102 #endif
103
104 #include "syssignal.h"
105 #include "systime.h"
106
107 static int emacs_get_tty (int, struct emacs_tty *);
108 static int emacs_set_tty (int, struct emacs_tty *, int);
109
110 /* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
111 #ifndef ULLONG_MAX
112 #define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
113 #endif
114
115 /* Declare here, including term.h is problematic on some systems. */
116 extern void tputs (const char *, int, int (*)(int));
117
118 static const int baud_convert[] =
119 {
120 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
121 1800, 2400, 4800, 9600, 19200, 38400
122 };
123
124
125 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
126
127 /* Return the current working directory. Returns NULL on errors.
128 Any other returned value must be freed with free. This is used
129 only when get_current_dir_name is not defined on the system. */
130 char*
131 get_current_dir_name (void)
132 {
133 char *buf;
134 char *pwd;
135 struct stat dotstat, pwdstat;
136 /* If PWD is accurate, use it instead of calling getwd. PWD is
137 sometimes a nicer name, and using it may avoid a fatal error if a
138 parent directory is searchable but not readable. */
139 if ((pwd = getenv ("PWD")) != 0
140 && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
141 && stat (pwd, &pwdstat) == 0
142 && stat (".", &dotstat) == 0
143 && dotstat.st_ino == pwdstat.st_ino
144 && dotstat.st_dev == pwdstat.st_dev
145 #ifdef MAXPATHLEN
146 && strlen (pwd) < MAXPATHLEN
147 #endif
148 )
149 {
150 buf = malloc (strlen (pwd) + 1);
151 if (!buf)
152 return NULL;
153 strcpy (buf, pwd);
154 }
155 #ifdef HAVE_GETCWD
156 else
157 {
158 size_t buf_size = 1024;
159 buf = malloc (buf_size);
160 if (!buf)
161 return NULL;
162 for (;;)
163 {
164 if (getcwd (buf, buf_size) == buf)
165 break;
166 if (errno != ERANGE)
167 {
168 int tmp_errno = errno;
169 free (buf);
170 errno = tmp_errno;
171 return NULL;
172 }
173 buf_size *= 2;
174 buf = realloc (buf, buf_size);
175 if (!buf)
176 return NULL;
177 }
178 }
179 #else
180 else
181 {
182 /* We need MAXPATHLEN here. */
183 buf = malloc (MAXPATHLEN + 1);
184 if (!buf)
185 return NULL;
186 if (getwd (buf) == NULL)
187 {
188 int tmp_errno = errno;
189 free (buf);
190 errno = tmp_errno;
191 return NULL;
192 }
193 }
194 #endif
195 return buf;
196 }
197 #endif
198
199 \f
200 /* Discard pending input on all input descriptors. */
201
202 void
203 discard_tty_input (void)
204 {
205 #ifndef WINDOWSNT
206 struct emacs_tty buf;
207
208 if (noninteractive)
209 return;
210
211 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
212 while (dos_keyread () != -1)
213 ;
214 #else /* not MSDOS */
215 {
216 struct tty_display_info *tty;
217 for (tty = tty_list; tty; tty = tty->next)
218 {
219 if (tty->input) /* Is the device suspended? */
220 {
221 emacs_get_tty (fileno (tty->input), &buf);
222 emacs_set_tty (fileno (tty->input), &buf, 0);
223 }
224 }
225 }
226 #endif /* not MSDOS */
227 #endif /* not WINDOWSNT */
228 }
229
230 \f
231 #ifdef SIGTSTP
232
233 /* Arrange for character C to be read as the next input from
234 the terminal.
235 XXX What if we have multiple ttys?
236 */
237
238 void
239 stuff_char (char c)
240 {
241 if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
242 return;
243
244 /* Should perhaps error if in batch mode */
245 #ifdef TIOCSTI
246 ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
247 #else /* no TIOCSTI */
248 error ("Cannot stuff terminal input characters in this version of Unix");
249 #endif /* no TIOCSTI */
250 }
251
252 #endif /* SIGTSTP */
253 \f
254 void
255 init_baud_rate (int fd)
256 {
257 int emacs_ospeed;
258
259 if (noninteractive)
260 emacs_ospeed = 0;
261 else
262 {
263 #ifdef DOS_NT
264 emacs_ospeed = 15;
265 #else /* not DOS_NT */
266 struct termios sg;
267
268 sg.c_cflag = B9600;
269 tcgetattr (fd, &sg);
270 emacs_ospeed = cfgetospeed (&sg);
271 #endif /* not DOS_NT */
272 }
273
274 baud_rate = (emacs_ospeed < sizeof baud_convert / sizeof baud_convert[0]
275 ? baud_convert[emacs_ospeed] : 9600);
276 if (baud_rate == 0)
277 baud_rate = 1200;
278 }
279
280 \f
281
282 #ifndef MSDOS
283
284 static void
285 wait_for_termination_1 (pid_t pid, int interruptible)
286 {
287 while (1)
288 {
289 #ifdef WINDOWSNT
290 wait (0);
291 break;
292 #else /* not WINDOWSNT */
293 int status;
294 int wait_result = waitpid (pid, &status, 0);
295 if (wait_result < 0)
296 {
297 if (errno != EINTR)
298 break;
299 }
300 else
301 {
302 record_child_status_change (wait_result, status);
303 break;
304 }
305
306 #endif /* not WINDOWSNT */
307 if (interruptible)
308 QUIT;
309 }
310 }
311
312 /* Wait for subprocess with process id `pid' to terminate and
313 make sure it will get eliminated (not remain forever as a zombie) */
314
315 void
316 wait_for_termination (pid_t pid)
317 {
318 wait_for_termination_1 (pid, 0);
319 }
320
321 /* Like the above, but allow keyboard interruption. */
322 void
323 interruptible_wait_for_termination (pid_t pid)
324 {
325 wait_for_termination_1 (pid, 1);
326 }
327
328 /*
329 * flush any pending output
330 * (may flush input as well; it does not matter the way we use it)
331 */
332
333 void
334 flush_pending_output (int channel)
335 {
336 /* FIXME: maybe this function should be removed */
337 }
338 \f
339 /* Set up the terminal at the other end of a pseudo-terminal that
340 we will be controlling an inferior through.
341 It should not echo or do line-editing, since that is done
342 in Emacs. No padding needed for insertion into an Emacs buffer. */
343
344 void
345 child_setup_tty (int out)
346 {
347 #ifndef WINDOWSNT
348 struct emacs_tty s;
349
350 emacs_get_tty (out, &s);
351 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
352 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
353 #ifdef NLDLY
354 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
355 Some versions of GNU Hurd do not have FFDLY? */
356 #ifdef FFDLY
357 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
358 /* No output delays */
359 #else
360 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY);
361 /* No output delays */
362 #endif
363 #endif
364 s.main.c_lflag &= ~ECHO; /* Disable echo */
365 s.main.c_lflag |= ISIG; /* Enable signals */
366 #ifdef IUCLC
367 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
368 #endif
369 #ifdef ISTRIP
370 s.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
371 #endif
372 #ifdef OLCUC
373 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
374 #endif
375 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
376 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
377 s.main.c_cc[VERASE] = CDISABLE; /* disable erase processing */
378 s.main.c_cc[VKILL] = CDISABLE; /* disable kill processing */
379
380 #ifdef HPUX
381 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
382 #endif /* HPUX */
383
384 #ifdef SIGNALS_VIA_CHARACTERS
385 /* the QUIT and INTR character are used in process_send_signal
386 so set them here to something useful. */
387 if (s.main.c_cc[VQUIT] == CDISABLE)
388 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
389 if (s.main.c_cc[VINTR] == CDISABLE)
390 s.main.c_cc[VINTR] = 'C'&037; /* Control-C */
391 #endif /* not SIGNALS_VIA_CHARACTERS */
392
393 #ifdef AIX
394 /* Also, PTY overloads NUL and BREAK.
395 don't ignore break, but don't signal either, so it looks like NUL. */
396 s.main.c_iflag &= ~IGNBRK;
397 s.main.c_iflag &= ~BRKINT;
398 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
399 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
400 would force it to 0377. That looks like duplicated code. */
401 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
402 #endif /* AIX */
403
404 /* We originally enabled ICANON (and set VEOF to 04), and then had
405 process.c send additional EOF chars to flush the output when faced
406 with long lines, but this leads to weird effects when the
407 subprocess has disabled ICANON and ends up seeing those spurious
408 extra EOFs. So we don't send EOFs any more in
409 process.c:send_process. First we tried to disable ICANON by
410 default, so if a subsprocess sets up ICANON, it's his problem (or
411 the Elisp package that talks to it) to deal with lines that are
412 too long. But this disables some features, such as the ability
413 to send EOF signals. So we re-enabled ICANON but there is no
414 more "send eof to flush" going on (which is wrong and unportable
415 in itself). The correct way to handle too much output is to
416 buffer what could not be written and then write it again when
417 select returns ok for writing. This has it own set of
418 problems. Write is now asynchronous, is that a problem? How much
419 do we buffer, and what do we do when that limit is reached? */
420
421 s.main.c_lflag |= ICANON; /* Enable line editing and eof processing */
422 s.main.c_cc[VEOF] = 'D'&037; /* Control-D */
423 #if 0 /* These settings only apply to non-ICANON mode. */
424 s.main.c_cc[VMIN] = 1;
425 s.main.c_cc[VTIME] = 0;
426 #endif
427
428 emacs_set_tty (out, &s, 0);
429 #endif /* not WINDOWSNT */
430 }
431 #endif /* not MSDOS */
432
433 \f
434 /* Record a signal code and the action for it. */
435 struct save_signal
436 {
437 int code;
438 struct sigaction action;
439 };
440
441 static void save_signal_handlers (struct save_signal *);
442 static void restore_signal_handlers (struct save_signal *);
443
444 /* Suspend the Emacs process; give terminal to its superior. */
445
446 void
447 sys_suspend (void)
448 {
449 #if defined (SIGTSTP) && !defined (MSDOS)
450
451 {
452 int pgrp = EMACS_GETPGRP (0);
453 EMACS_KILLPG (pgrp, SIGTSTP);
454 }
455
456 #else /* No SIGTSTP */
457 /* On a system where suspending is not implemented,
458 instead fork a subshell and let it talk directly to the terminal
459 while we wait. */
460 sys_subshell ();
461
462 #endif /* no SIGTSTP */
463 }
464
465 /* Fork a subshell. */
466
467 void
468 sys_subshell (void)
469 {
470 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
471 int st;
472 char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS. */
473 #endif
474 int pid;
475 struct save_signal saved_handlers[5];
476 Lisp_Object dir;
477 unsigned char *volatile str_volatile = 0;
478 unsigned char *str;
479 int len;
480
481 saved_handlers[0].code = SIGINT;
482 saved_handlers[1].code = SIGQUIT;
483 saved_handlers[2].code = SIGTERM;
484 #ifdef USABLE_SIGIO
485 saved_handlers[3].code = SIGIO;
486 saved_handlers[4].code = 0;
487 #else
488 saved_handlers[3].code = 0;
489 #endif
490
491 /* Mentioning current_buffer->buffer would mean including buffer.h,
492 which somehow wedges the hp compiler. So instead... */
493
494 dir = intern ("default-directory");
495 if (NILP (Fboundp (dir)))
496 goto xyzzy;
497 dir = Fsymbol_value (dir);
498 if (!STRINGP (dir))
499 goto xyzzy;
500
501 dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
502 str_volatile = str = alloca (SCHARS (dir) + 2);
503 len = SCHARS (dir);
504 memcpy (str, SDATA (dir), len);
505 if (str[len - 1] != '/') str[len++] = '/';
506 str[len] = 0;
507 xyzzy:
508
509 #ifdef DOS_NT
510 pid = 0;
511 save_signal_handlers (saved_handlers);
512 synch_process_alive = 1;
513 #else
514 pid = vfork ();
515 if (pid == -1)
516 error ("Can't spawn subshell");
517 #endif
518
519 if (pid == 0)
520 {
521 const char *sh = 0;
522
523 #ifdef DOS_NT /* MW, Aug 1993 */
524 getwd (oldwd);
525 if (sh == 0)
526 sh = (char *) egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
527 #endif
528 if (sh == 0)
529 sh = (char *) egetenv ("SHELL");
530 if (sh == 0)
531 sh = "sh";
532
533 /* Use our buffer's default directory for the subshell. */
534 str = str_volatile;
535 if (str && chdir ((char *) str) != 0)
536 {
537 #ifndef DOS_NT
538 ignore_value (write (1, "Can't chdir\n", 12));
539 _exit (1);
540 #endif
541 }
542
543 close_process_descs (); /* Close Emacs's pipes/ptys */
544
545 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
546 {
547 char *epwd = getenv ("PWD");
548 char old_pwd[MAXPATHLEN+1+4];
549
550 /* If PWD is set, pass it with corrected value. */
551 if (epwd)
552 {
553 strcpy (old_pwd, epwd);
554 if (str[len - 1] == '/')
555 str[len - 1] = '\0';
556 setenv ("PWD", str, 1);
557 }
558 st = system (sh);
559 chdir (oldwd); /* FIXME: Do the right thing on chdir failure. */
560 if (epwd)
561 putenv (old_pwd); /* restore previous value */
562 }
563 #else /* not MSDOS */
564 #ifdef WINDOWSNT
565 /* Waits for process completion */
566 pid = _spawnlp (_P_WAIT, sh, sh, NULL);
567 chdir (oldwd); /* FIXME: Do the right thing on chdir failure. */
568 if (pid == -1)
569 write (1, "Can't execute subshell", 22);
570 #else /* not WINDOWSNT */
571 execlp (sh, sh, (char *) 0);
572 ignore_value (write (1, "Can't execute subshell", 22));
573 _exit (1);
574 #endif /* not WINDOWSNT */
575 #endif /* not MSDOS */
576 }
577
578 /* Do this now if we did not do it before. */
579 #ifndef MSDOS
580 save_signal_handlers (saved_handlers);
581 synch_process_alive = 1;
582 #endif
583
584 #ifndef DOS_NT
585 wait_for_termination (pid);
586 #endif
587 restore_signal_handlers (saved_handlers);
588 synch_process_alive = 0;
589 }
590
591 static void
592 save_signal_handlers (struct save_signal *saved_handlers)
593 {
594 while (saved_handlers->code)
595 {
596 struct sigaction action;
597 emacs_sigaction_init (&action, SIG_IGN);
598 sigaction (saved_handlers->code, &action, &saved_handlers->action);
599 saved_handlers++;
600 }
601 }
602
603 static void
604 restore_signal_handlers (struct save_signal *saved_handlers)
605 {
606 while (saved_handlers->code)
607 {
608 sigaction (saved_handlers->code, &saved_handlers->action, 0);
609 saved_handlers++;
610 }
611 }
612 \f
613 #ifdef USABLE_SIGIO
614 static int old_fcntl_flags[MAXDESC];
615 #endif
616
617 void
618 init_sigio (int fd)
619 {
620 #ifdef USABLE_SIGIO
621 old_fcntl_flags[fd] = fcntl (fd, F_GETFL, 0) & ~FASYNC;
622 fcntl (fd, F_SETFL, old_fcntl_flags[fd] | FASYNC);
623 interrupts_deferred = 0;
624 #endif
625 }
626
627 static void
628 reset_sigio (int fd)
629 {
630 #ifdef USABLE_SIGIO
631 fcntl (fd, F_SETFL, old_fcntl_flags[fd]);
632 #endif
633 }
634
635 void
636 request_sigio (void)
637 {
638 #ifdef USABLE_SIGIO
639 sigset_t unblocked;
640
641 if (noninteractive)
642 return;
643
644 sigemptyset (&unblocked);
645 # ifdef SIGWINCH
646 sigaddset (&unblocked, SIGWINCH);
647 # endif
648 sigaddset (&unblocked, SIGIO);
649 pthread_sigmask (SIG_UNBLOCK, &unblocked, 0);
650
651 interrupts_deferred = 0;
652 #endif
653 }
654
655 void
656 unrequest_sigio (void)
657 {
658 #ifdef USABLE_SIGIO
659 sigset_t blocked;
660
661 if (noninteractive)
662 return;
663
664 sigemptyset (&blocked);
665 # ifdef SIGWINCH
666 sigaddset (&blocked, SIGWINCH);
667 # endif
668 sigaddset (&blocked, SIGIO);
669 pthread_sigmask (SIG_BLOCK, &blocked, 0);
670 interrupts_deferred = 1;
671 #endif
672 }
673
674 void
675 ignore_sigio (void)
676 {
677 #ifdef USABLE_SIGIO
678 signal (SIGIO, SIG_IGN);
679 #endif
680 }
681
682 \f
683 /* Getting and setting emacs_tty structures. */
684
685 /* Set *TC to the parameters associated with the terminal FD.
686 Return zero if all's well, or -1 if we ran into an error we
687 couldn't deal with. */
688 int
689 emacs_get_tty (int fd, struct emacs_tty *settings)
690 {
691 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
692 #ifndef DOS_NT
693 /* We have those nifty POSIX tcmumbleattr functions. */
694 memset (&settings->main, 0, sizeof (settings->main));
695 if (tcgetattr (fd, &settings->main) < 0)
696 return -1;
697 #endif
698
699 /* We have survived the tempest. */
700 return 0;
701 }
702
703
704 /* Set the parameters of the tty on FD according to the contents of
705 *SETTINGS. If FLUSHP is non-zero, we discard input.
706 Return 0 if all went well, and -1 if anything failed. */
707
708 int
709 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
710 {
711 /* Set the primary parameters - baud rate, character size, etcetera. */
712 #ifndef DOS_NT
713 int i;
714 /* We have those nifty POSIX tcmumbleattr functions.
715 William J. Smith <wjs@wiis.wang.com> writes:
716 "POSIX 1003.1 defines tcsetattr to return success if it was
717 able to perform any of the requested actions, even if some
718 of the requested actions could not be performed.
719 We must read settings back to ensure tty setup properly.
720 AIX requires this to keep tty from hanging occasionally." */
721 /* This make sure that we don't loop indefinitely in here. */
722 for (i = 0 ; i < 10 ; i++)
723 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
724 {
725 if (errno == EINTR)
726 continue;
727 else
728 return -1;
729 }
730 else
731 {
732 struct termios new;
733
734 memset (&new, 0, sizeof (new));
735 /* Get the current settings, and see if they're what we asked for. */
736 tcgetattr (fd, &new);
737 /* We cannot use memcmp on the whole structure here because under
738 * aix386 the termios structure has some reserved field that may
739 * not be filled in.
740 */
741 if ( new.c_iflag == settings->main.c_iflag
742 && new.c_oflag == settings->main.c_oflag
743 && new.c_cflag == settings->main.c_cflag
744 && new.c_lflag == settings->main.c_lflag
745 && memcmp (new.c_cc, settings->main.c_cc, NCCS) == 0)
746 break;
747 else
748 continue;
749 }
750 #endif
751
752 /* We have survived the tempest. */
753 return 0;
754 }
755
756 \f
757
758 #ifdef F_SETOWN
759 static int old_fcntl_owner[MAXDESC];
760 #endif /* F_SETOWN */
761
762 /* This may also be defined in stdio,
763 but if so, this does no harm,
764 and using the same name avoids wasting the other one's space. */
765
766 #if defined (USG)
767 unsigned char _sobuf[BUFSIZ+8];
768 #else
769 char _sobuf[BUFSIZ];
770 #endif
771
772 /* Initialize the terminal mode on all tty devices that are currently
773 open. */
774
775 void
776 init_all_sys_modes (void)
777 {
778 struct tty_display_info *tty;
779 for (tty = tty_list; tty; tty = tty->next)
780 init_sys_modes (tty);
781 }
782
783 /* Initialize the terminal mode on the given tty device. */
784
785 void
786 init_sys_modes (struct tty_display_info *tty_out)
787 {
788 struct emacs_tty tty;
789 Lisp_Object terminal;
790
791 Vtty_erase_char = Qnil;
792
793 if (noninteractive)
794 return;
795
796 if (!tty_out->output)
797 return; /* The tty is suspended. */
798
799 if (! tty_out->old_tty)
800 tty_out->old_tty = xmalloc (sizeof *tty_out->old_tty);
801
802 emacs_get_tty (fileno (tty_out->input), tty_out->old_tty);
803
804 tty = *tty_out->old_tty;
805
806 #if !defined (DOS_NT)
807 XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);
808
809 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
810 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
811 #ifdef INLCR /* I'm just being cautious,
812 since I can't check how widespread INLCR is--rms. */
813 tty.main.c_iflag &= ~INLCR; /* Disable map of NL to CR on input */
814 #endif
815 #ifdef ISTRIP
816 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
817 #endif
818 tty.main.c_lflag &= ~ECHO; /* Disable echo */
819 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
820 #ifdef IEXTEN
821 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
822 #endif
823 tty.main.c_lflag |= ISIG; /* Enable signals */
824 if (tty_out->flow_control)
825 {
826 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
827 #ifdef IXANY
828 tty.main.c_iflag &= ~IXANY;
829 #endif /* IXANY */
830 }
831 else
832 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
833 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
834 on output */
835 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
836 #ifdef CS8
837 if (tty_out->meta_key)
838 {
839 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
840 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
841 }
842 #endif
843
844 XSETTERMINAL(terminal, tty_out->terminal);
845 if (!NILP (Fcontrolling_tty_p (terminal)))
846 {
847 tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
848 /* Set up C-g for both SIGQUIT and SIGINT.
849 We don't know which we will get, but we handle both alike
850 so which one it really gives us does not matter. */
851 tty.main.c_cc[VQUIT] = quit_char;
852 }
853 else
854 {
855 /* We normally don't get interrupt or quit signals from tty
856 devices other than our controlling terminal; therefore,
857 we must handle C-g as normal input. Unfortunately, this
858 means that the interrupt and quit feature must be
859 disabled on secondary ttys, or we would not even see the
860 keypress.
861
862 Note that even though emacsclient could have special code
863 to pass SIGINT to Emacs, we should _not_ enable
864 interrupt/quit keys for emacsclient frames. This means
865 that we can't break out of loops in C code from a
866 secondary tty frame, but we can always decide what
867 display the C-g came from, which is more important from a
868 usability point of view. (Consider the case when two
869 people work together using the same Emacs instance.) */
870 tty.main.c_cc[VINTR] = CDISABLE;
871 tty.main.c_cc[VQUIT] = CDISABLE;
872 }
873 tty.main.c_cc[VMIN] = 1; /* Input should wait for at least 1 char */
874 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
875 #ifdef VSWTCH
876 tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
877 of C-z */
878 #endif /* VSWTCH */
879
880 #ifdef VSUSP
881 tty.main.c_cc[VSUSP] = CDISABLE; /* Turn off handling of C-z. */
882 #endif /* VSUSP */
883 #ifdef V_DSUSP
884 tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off handling of C-y. */
885 #endif /* V_DSUSP */
886 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
887 tty.main.c_cc[VDSUSP] = CDISABLE;
888 #endif /* VDSUSP */
889 #ifdef VLNEXT
890 tty.main.c_cc[VLNEXT] = CDISABLE;
891 #endif /* VLNEXT */
892 #ifdef VREPRINT
893 tty.main.c_cc[VREPRINT] = CDISABLE;
894 #endif /* VREPRINT */
895 #ifdef VWERASE
896 tty.main.c_cc[VWERASE] = CDISABLE;
897 #endif /* VWERASE */
898 #ifdef VDISCARD
899 tty.main.c_cc[VDISCARD] = CDISABLE;
900 #endif /* VDISCARD */
901
902 if (tty_out->flow_control)
903 {
904 #ifdef VSTART
905 tty.main.c_cc[VSTART] = '\021';
906 #endif /* VSTART */
907 #ifdef VSTOP
908 tty.main.c_cc[VSTOP] = '\023';
909 #endif /* VSTOP */
910 }
911 else
912 {
913 #ifdef VSTART
914 tty.main.c_cc[VSTART] = CDISABLE;
915 #endif /* VSTART */
916 #ifdef VSTOP
917 tty.main.c_cc[VSTOP] = CDISABLE;
918 #endif /* VSTOP */
919 }
920
921 #ifdef AIX
922 tty.main.c_cc[VSTRT] = CDISABLE;
923 tty.main.c_cc[VSTOP] = CDISABLE;
924 tty.main.c_cc[VSUSP] = CDISABLE;
925 tty.main.c_cc[VDSUSP] = CDISABLE;
926 if (tty_out->flow_control)
927 {
928 #ifdef VSTART
929 tty.main.c_cc[VSTART] = '\021';
930 #endif /* VSTART */
931 #ifdef VSTOP
932 tty.main.c_cc[VSTOP] = '\023';
933 #endif /* VSTOP */
934 }
935 /* Also, PTY overloads NUL and BREAK.
936 don't ignore break, but don't signal either, so it looks like NUL.
937 This really serves a purpose only if running in an XTERM window
938 or via TELNET or the like, but does no harm elsewhere. */
939 tty.main.c_iflag &= ~IGNBRK;
940 tty.main.c_iflag &= ~BRKINT;
941 #endif
942 #endif /* not DOS_NT */
943
944 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
945 if (!tty_out->term_initted)
946 internal_terminal_init ();
947 dos_ttraw (tty_out);
948 #endif
949
950 emacs_set_tty (fileno (tty_out->input), &tty, 0);
951
952 /* This code added to insure that, if flow-control is not to be used,
953 we have an unlocked terminal at the start. */
954
955 #ifdef TCXONC
956 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TCXONC, 1);
957 #endif
958 #ifdef TIOCSTART
959 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
960 #endif
961
962 #if !defined (DOS_NT)
963 #ifdef TCOON
964 if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
965 #endif
966 #endif
967
968 #ifdef F_SETFL
969 #ifdef F_GETOWN /* F_SETFL does not imply existence of F_GETOWN */
970 if (interrupt_input)
971 {
972 old_fcntl_owner[fileno (tty_out->input)] =
973 fcntl (fileno (tty_out->input), F_GETOWN, 0);
974 fcntl (fileno (tty_out->input), F_SETOWN, getpid ());
975 init_sigio (fileno (tty_out->input));
976 #ifdef HAVE_GPM
977 if (gpm_tty == tty_out)
978 {
979 /* Arrange for mouse events to give us SIGIO signals. */
980 fcntl (gpm_fd, F_SETOWN, getpid ());
981 fcntl (gpm_fd, F_SETFL, fcntl (gpm_fd, F_GETFL, 0) | O_NONBLOCK);
982 init_sigio (gpm_fd);
983 }
984 #endif /* HAVE_GPM */
985 }
986 #endif /* F_GETOWN */
987 #endif /* F_SETFL */
988
989 #ifdef _IOFBF
990 /* This symbol is defined on recent USG systems.
991 Someone says without this call USG won't really buffer the file
992 even with a call to setbuf. */
993 setvbuf (tty_out->output, (char *) _sobuf, _IOFBF, sizeof _sobuf);
994 #else
995 setbuf (tty_out->output, (char *) _sobuf);
996 #endif
997
998 if (tty_out->terminal->set_terminal_modes_hook)
999 tty_out->terminal->set_terminal_modes_hook (tty_out->terminal);
1000
1001 if (!tty_out->term_initted)
1002 {
1003 Lisp_Object tail, frame;
1004 FOR_EACH_FRAME (tail, frame)
1005 {
1006 /* XXX This needs to be revised. */
1007 if (FRAME_TERMCAP_P (XFRAME (frame))
1008 && FRAME_TTY (XFRAME (frame)) == tty_out)
1009 init_frame_faces (XFRAME (frame));
1010 }
1011 }
1012
1013 if (tty_out->term_initted && no_redraw_on_reenter)
1014 {
1015 /* We used to call "direct_output_forward_char(0)" here,
1016 but it's not clear why, since it may not do anything anyway. */
1017 }
1018 else
1019 {
1020 Lisp_Object tail, frame;
1021 frame_garbaged = 1;
1022 FOR_EACH_FRAME (tail, frame)
1023 {
1024 if ((FRAME_TERMCAP_P (XFRAME (frame))
1025 || FRAME_MSDOS_P (XFRAME (frame)))
1026 && FRAME_TTY (XFRAME (frame)) == tty_out)
1027 FRAME_GARBAGED_P (XFRAME (frame)) = 1;
1028 }
1029 }
1030
1031 tty_out->term_initted = 1;
1032 }
1033
1034 /* Return nonzero if safe to use tabs in output.
1035 At the time this is called, init_sys_modes has not been done yet. */
1036
1037 int
1038 tabs_safe_p (int fd)
1039 {
1040 struct emacs_tty etty;
1041
1042 emacs_get_tty (fd, &etty);
1043 #ifndef DOS_NT
1044 #ifdef TABDLY
1045 return ((etty.main.c_oflag & TABDLY) != TAB3);
1046 #else /* not TABDLY */
1047 return 1;
1048 #endif /* not TABDLY */
1049 #else /* DOS_NT */
1050 return 0;
1051 #endif /* DOS_NT */
1052 }
1053 \f
1054 /* Get terminal size from system.
1055 Store number of lines into *HEIGHTP and width into *WIDTHP.
1056 We store 0 if there's no valid information. */
1057
1058 void
1059 get_tty_size (int fd, int *widthp, int *heightp)
1060 {
1061 #if defined TIOCGWINSZ
1062
1063 /* BSD-style. */
1064 struct winsize size;
1065
1066 if (ioctl (fd, TIOCGWINSZ, &size) == -1)
1067 *widthp = *heightp = 0;
1068 else
1069 {
1070 *widthp = size.ws_col;
1071 *heightp = size.ws_row;
1072 }
1073
1074 #elif defined TIOCGSIZE
1075
1076 /* SunOS - style. */
1077 struct ttysize size;
1078
1079 if (ioctl (fd, TIOCGSIZE, &size) == -1)
1080 *widthp = *heightp = 0;
1081 else
1082 {
1083 *widthp = size.ts_cols;
1084 *heightp = size.ts_lines;
1085 }
1086
1087 #elif defined WINDOWSNT
1088
1089 CONSOLE_SCREEN_BUFFER_INFO info;
1090 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info))
1091 {
1092 *widthp = info.srWindow.Right - info.srWindow.Left + 1;
1093 *heightp = info.srWindow.Bottom - info.srWindow.Top + 1;
1094 }
1095 else
1096 *widthp = *heightp = 0;
1097
1098 #elif defined MSDOS
1099
1100 *widthp = ScreenCols ();
1101 *heightp = ScreenRows ();
1102
1103 #else /* system doesn't know size */
1104
1105 *widthp = 0;
1106 *heightp = 0;
1107
1108 #endif
1109 }
1110
1111 /* Set the logical window size associated with descriptor FD
1112 to HEIGHT and WIDTH. This is used mainly with ptys. */
1113
1114 int
1115 set_window_size (int fd, int height, int width)
1116 {
1117 #ifdef TIOCSWINSZ
1118
1119 /* BSD-style. */
1120 struct winsize size;
1121 size.ws_row = height;
1122 size.ws_col = width;
1123
1124 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
1125 return 0; /* error */
1126 else
1127 return 1;
1128
1129 #else
1130 #ifdef TIOCSSIZE
1131
1132 /* SunOS - style. */
1133 struct ttysize size;
1134 size.ts_lines = height;
1135 size.ts_cols = width;
1136
1137 if (ioctl (fd, TIOCGSIZE, &size) == -1)
1138 return 0;
1139 else
1140 return 1;
1141 #else
1142 return -1;
1143 #endif /* not SunOS-style */
1144 #endif /* not BSD-style */
1145 }
1146
1147 \f
1148
1149 /* Prepare all terminal devices for exiting Emacs. */
1150
1151 void
1152 reset_all_sys_modes (void)
1153 {
1154 struct tty_display_info *tty;
1155 for (tty = tty_list; tty; tty = tty->next)
1156 reset_sys_modes (tty);
1157 }
1158
1159 /* Prepare the terminal for closing it; move the cursor to the
1160 bottom of the frame, turn off interrupt-driven I/O, etc. */
1161
1162 void
1163 reset_sys_modes (struct tty_display_info *tty_out)
1164 {
1165 if (noninteractive)
1166 {
1167 fflush (stdout);
1168 return;
1169 }
1170 if (!tty_out->term_initted)
1171 return;
1172
1173 if (!tty_out->output)
1174 return; /* The tty is suspended. */
1175
1176 /* Go to and clear the last line of the terminal. */
1177
1178 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
1179
1180 /* Code adapted from tty_clear_end_of_line. */
1181 if (tty_out->TS_clr_line)
1182 {
1183 emacs_tputs (tty_out, tty_out->TS_clr_line, 1, cmputc);
1184 }
1185 else
1186 { /* have to do it the hard way */
1187 int i;
1188 tty_turn_off_insert (tty_out);
1189
1190 for (i = curX (tty_out); i < FrameCols (tty_out) - 1; i++)
1191 {
1192 fputc (' ', tty_out->output);
1193 }
1194 }
1195
1196 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
1197 fflush (tty_out->output);
1198
1199 if (tty_out->terminal->reset_terminal_modes_hook)
1200 tty_out->terminal->reset_terminal_modes_hook (tty_out->terminal);
1201
1202 #ifdef BSD_SYSTEM
1203 /* Avoid possible loss of output when changing terminal modes. */
1204 fsync (fileno (tty_out->output));
1205 #endif
1206
1207 #ifdef F_SETFL
1208 #ifdef F_SETOWN /* F_SETFL does not imply existence of F_SETOWN */
1209 if (interrupt_input)
1210 {
1211 reset_sigio (fileno (tty_out->input));
1212 fcntl (fileno (tty_out->input), F_SETOWN,
1213 old_fcntl_owner[fileno (tty_out->input)]);
1214 }
1215 #endif /* F_SETOWN */
1216 #ifdef O_NDELAY
1217 fcntl (fileno (tty_out->input), F_SETFL,
1218 fcntl (fileno (tty_out->input), F_GETFL, 0) & ~O_NDELAY);
1219 #endif
1220 #endif /* F_SETFL */
1221
1222 if (tty_out->old_tty)
1223 while (emacs_set_tty (fileno (tty_out->input),
1224 tty_out->old_tty, 0) < 0 && errno == EINTR)
1225 ;
1226
1227 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1228 dos_ttcooked ();
1229 #endif
1230
1231 }
1232 \f
1233 #ifdef HAVE_PTYS
1234
1235 /* Set up the proper status flags for use of a pty. */
1236
1237 void
1238 setup_pty (int fd)
1239 {
1240 /* I'm told that TOICREMOTE does not mean control chars
1241 "can't be sent" but rather that they don't have
1242 input-editing or signaling effects.
1243 That should be good, because we have other ways
1244 to do those things in Emacs.
1245 However, telnet mode seems not to work on 4.2.
1246 So TIOCREMOTE is turned off now. */
1247
1248 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1249 will hang. In particular, the "timeout" feature (which
1250 causes a read to return if there is no data available)
1251 does this. Also it is known that telnet mode will hang
1252 in such a way that Emacs must be stopped (perhaps this
1253 is the same problem).
1254
1255 If TIOCREMOTE is turned off, then there is a bug in
1256 hp-ux which sometimes loses data. Apparently the
1257 code which blocks the master process when the internal
1258 buffer fills up does not work. Other than this,
1259 though, everything else seems to work fine.
1260
1261 Since the latter lossage is more benign, we may as well
1262 lose that way. -- cph */
1263 #ifdef FIONBIO
1264 #if defined (UNIX98_PTYS)
1265 {
1266 int on = 1;
1267 ioctl (fd, FIONBIO, &on);
1268 }
1269 #endif
1270 #endif
1271 }
1272 #endif /* HAVE_PTYS */
1273 \f
1274 #ifdef HAVE_SOCKETS
1275 #include <sys/socket.h>
1276 #include <netdb.h>
1277 #endif /* HAVE_SOCKETS */
1278
1279 #ifdef TRY_AGAIN
1280 #ifndef HAVE_H_ERRNO
1281 extern int h_errno;
1282 #endif
1283 #endif /* TRY_AGAIN */
1284
1285 void
1286 init_system_name (void)
1287 {
1288 #ifndef HAVE_GETHOSTNAME
1289 struct utsname uts;
1290 uname (&uts);
1291 Vsystem_name = build_string (uts.nodename);
1292 #else /* HAVE_GETHOSTNAME */
1293 unsigned int hostname_size = 256;
1294 char *hostname = alloca (hostname_size);
1295
1296 /* Try to get the host name; if the buffer is too short, try
1297 again. Apparently, the only indication gethostname gives of
1298 whether the buffer was large enough is the presence or absence
1299 of a '\0' in the string. Eech. */
1300 for (;;)
1301 {
1302 gethostname (hostname, hostname_size - 1);
1303 hostname[hostname_size - 1] = '\0';
1304
1305 /* Was the buffer large enough for the '\0'? */
1306 if (strlen (hostname) < hostname_size - 1)
1307 break;
1308
1309 hostname_size <<= 1;
1310 hostname = alloca (hostname_size);
1311 }
1312 #ifdef HAVE_SOCKETS
1313 /* Turn the hostname into the official, fully-qualified hostname.
1314 Don't do this if we're going to dump; this can confuse system
1315 libraries on some machines and make the dumped emacs core dump. */
1316 #ifndef CANNOT_DUMP
1317 if (initialized)
1318 #endif /* not CANNOT_DUMP */
1319 if (! strchr (hostname, '.'))
1320 {
1321 int count;
1322 #ifdef HAVE_GETADDRINFO
1323 struct addrinfo *res;
1324 struct addrinfo hints;
1325 int ret;
1326
1327 memset (&hints, 0, sizeof (hints));
1328 hints.ai_socktype = SOCK_STREAM;
1329 hints.ai_flags = AI_CANONNAME;
1330
1331 for (count = 0;; count++)
1332 {
1333 if ((ret = getaddrinfo (hostname, NULL, &hints, &res)) == 0
1334 || ret != EAI_AGAIN)
1335 break;
1336
1337 if (count >= 5)
1338 break;
1339 Fsleep_for (make_number (1), Qnil);
1340 }
1341
1342 if (ret == 0)
1343 {
1344 struct addrinfo *it = res;
1345 while (it)
1346 {
1347 char *fqdn = it->ai_canonname;
1348 if (fqdn && strchr (fqdn, '.')
1349 && strcmp (fqdn, "localhost.localdomain") != 0)
1350 break;
1351 it = it->ai_next;
1352 }
1353 if (it)
1354 {
1355 hostname = alloca (strlen (it->ai_canonname) + 1);
1356 strcpy (hostname, it->ai_canonname);
1357 }
1358 freeaddrinfo (res);
1359 }
1360 #else /* !HAVE_GETADDRINFO */
1361 struct hostent *hp;
1362 for (count = 0;; count++)
1363 {
1364
1365 #ifdef TRY_AGAIN
1366 h_errno = 0;
1367 #endif
1368 hp = gethostbyname (hostname);
1369 #ifdef TRY_AGAIN
1370 if (! (hp == 0 && h_errno == TRY_AGAIN))
1371 #endif
1372
1373 break;
1374
1375 if (count >= 5)
1376 break;
1377 Fsleep_for (make_number (1), Qnil);
1378 }
1379
1380 if (hp)
1381 {
1382 char *fqdn = (char *) hp->h_name;
1383
1384 if (!strchr (fqdn, '.'))
1385 {
1386 /* We still don't have a fully qualified domain name.
1387 Try to find one in the list of alternate names */
1388 char **alias = hp->h_aliases;
1389 while (*alias
1390 && (!strchr (*alias, '.')
1391 || !strcmp (*alias, "localhost.localdomain")))
1392 alias++;
1393 if (*alias)
1394 fqdn = *alias;
1395 }
1396 hostname = fqdn;
1397 }
1398 #endif /* !HAVE_GETADDRINFO */
1399 }
1400 #endif /* HAVE_SOCKETS */
1401 Vsystem_name = build_string (hostname);
1402 #endif /* HAVE_GETHOSTNAME */
1403 {
1404 unsigned char *p;
1405 for (p = SDATA (Vsystem_name); *p; p++)
1406 if (*p == ' ' || *p == '\t')
1407 *p = '-';
1408 }
1409 }
1410 \f
1411 sigset_t empty_mask;
1412
1413 static struct sigaction process_fatal_action;
1414
1415 static int
1416 emacs_sigaction_flags (void)
1417 {
1418 #ifdef SA_RESTART
1419 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1420 'select') to reset their timeout on some platforms (e.g.,
1421 HP-UX 11), which is not what we want. Also, when Emacs is
1422 interactive, we don't want SA_RESTART because we need to poll
1423 for pending input so we need long-running syscalls to be interrupted
1424 after a signal that sets pending_signals.
1425
1426 Non-interactive keyboard input goes through stdio, where we
1427 always want restartable system calls. */
1428 if (noninteractive)
1429 return SA_RESTART;
1430 #endif
1431 return 0;
1432 }
1433
1434 /* Store into *ACTION a signal action suitable for Emacs, with handler
1435 HANDLER. */
1436 void
1437 emacs_sigaction_init (struct sigaction *action, signal_handler_t handler)
1438 {
1439 sigemptyset (&action->sa_mask);
1440
1441 /* When handling a signal, block nonfatal system signals that are caught
1442 by Emacs. This makes race conditions less likely. */
1443 sigaddset (&action->sa_mask, SIGALRM);
1444 #ifdef SIGCHLD
1445 sigaddset (&action->sa_mask, SIGCHLD);
1446 #endif
1447 #ifdef SIGDANGER
1448 sigaddset (&action->sa_mask, SIGDANGER);
1449 #endif
1450 #ifdef PROFILER_CPU_SUPPORT
1451 sigaddset (&action->sa_mask, SIGPROF);
1452 #endif
1453 #ifdef SIGWINCH
1454 sigaddset (&action->sa_mask, SIGWINCH);
1455 #endif
1456 if (! noninteractive)
1457 {
1458 sigaddset (&action->sa_mask, SIGINT);
1459 sigaddset (&action->sa_mask, SIGQUIT);
1460 #ifdef USABLE_SIGIO
1461 sigaddset (&action->sa_mask, SIGIO);
1462 #endif
1463 }
1464
1465 if (! IEEE_FLOATING_POINT)
1466 sigaddset (&action->sa_mask, SIGFPE);
1467
1468 action->sa_handler = handler;
1469 action->sa_flags = emacs_sigaction_flags ();
1470 }
1471
1472 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1473 static pthread_t main_thread;
1474 #endif
1475
1476 /* SIG has arrived at the current process. Deliver it to the main
1477 thread, which should handle it with HANDLER.
1478
1479 If we are on the main thread, handle the signal SIG with HANDLER.
1480 Otherwise, redirect the signal to the main thread, blocking it from
1481 this thread. POSIX says any thread can receive a signal that is
1482 associated with a process, process group, or asynchronous event.
1483 On GNU/Linux that is not true, but for other systems (FreeBSD at
1484 least) it is. */
1485 void
1486 deliver_process_signal (int sig, signal_handler_t handler)
1487 {
1488 /* Preserve errno, to avoid race conditions with signal handlers that
1489 might change errno. Races can occur even in single-threaded hosts. */
1490 int old_errno = errno;
1491
1492 bool on_main_thread = true;
1493 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1494 if (! pthread_equal (pthread_self (), main_thread))
1495 {
1496 sigset_t blocked;
1497 sigemptyset (&blocked);
1498 sigaddset (&blocked, sig);
1499 pthread_sigmask (SIG_BLOCK, &blocked, 0);
1500 pthread_kill (main_thread, sig);
1501 on_main_thread = false;
1502 }
1503 #endif
1504 if (on_main_thread)
1505 handler (sig);
1506
1507 errno = old_errno;
1508 }
1509
1510 /* Static location to save a fatal backtrace in a thread.
1511 FIXME: If two subsidiary threads fail simultaneously, the resulting
1512 backtrace may be garbage. */
1513 enum { BACKTRACE_LIMIT_MAX = 500 };
1514 static void *thread_backtrace_buffer[BACKTRACE_LIMIT_MAX + 1];
1515 static int thread_backtrace_npointers;
1516
1517 /* SIG has arrived at the current thread.
1518 If we are on the main thread, handle the signal SIG with HANDLER.
1519 Otherwise, this is a fatal error in the handling thread. */
1520 static void
1521 deliver_thread_signal (int sig, signal_handler_t handler)
1522 {
1523 int old_errno = errno;
1524
1525 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1526 if (! pthread_equal (pthread_self (), main_thread))
1527 {
1528 thread_backtrace_npointers
1529 = backtrace (thread_backtrace_buffer, BACKTRACE_LIMIT_MAX);
1530 sigaction (sig, &process_fatal_action, 0);
1531 pthread_kill (main_thread, sig);
1532
1533 /* Avoid further damage while the main thread is exiting. */
1534 while (1)
1535 sigsuspend (&empty_mask);
1536 }
1537 #endif
1538
1539 handler (sig);
1540 errno = old_errno;
1541 }
1542 \f
1543 #if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
1544 static char *my_sys_siglist[NSIG];
1545 # ifdef sys_siglist
1546 # undef sys_siglist
1547 # endif
1548 # define sys_siglist my_sys_siglist
1549 #endif
1550
1551 /* Handle bus errors, invalid instruction, etc. */
1552 static void
1553 handle_fatal_signal (int sig)
1554 {
1555 terminate_due_to_signal (sig, 40);
1556 }
1557
1558 static void
1559 deliver_fatal_signal (int sig)
1560 {
1561 deliver_process_signal (sig, handle_fatal_signal);
1562 }
1563
1564 static void
1565 deliver_fatal_thread_signal (int sig)
1566 {
1567 deliver_thread_signal (sig, handle_fatal_signal);
1568 }
1569
1570 static _Noreturn void
1571 handle_arith_signal (int sig)
1572 {
1573 pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
1574 xsignal0 (Qarith_error);
1575 }
1576
1577 static void
1578 deliver_arith_signal (int sig)
1579 {
1580 deliver_thread_signal (sig, handle_arith_signal);
1581 }
1582
1583 /* Treat SIG as a terminating signal, unless it is already ignored and
1584 we are in --batch mode. Among other things, this makes nohup work. */
1585 static void
1586 maybe_fatal_sig (int sig)
1587 {
1588 bool catch_sig = !noninteractive;
1589 if (!catch_sig)
1590 {
1591 struct sigaction old_action;
1592 sigaction (sig, 0, &old_action);
1593 catch_sig = old_action.sa_handler != SIG_IGN;
1594 }
1595 if (catch_sig)
1596 sigaction (sig, &process_fatal_action, 0);
1597 }
1598
1599 void
1600 init_signals (bool dumping)
1601 {
1602 struct sigaction thread_fatal_action;
1603 struct sigaction action;
1604
1605 sigemptyset (&empty_mask);
1606
1607 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1608 main_thread = pthread_self ();
1609 #endif
1610
1611 #if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
1612 if (! initialized)
1613 {
1614 sys_siglist[SIGABRT] = "Aborted";
1615 # ifdef SIGAIO
1616 sys_siglist[SIGAIO] = "LAN I/O interrupt";
1617 # endif
1618 # ifdef SIGALRM
1619 sys_siglist[SIGALRM] = "Alarm clock";
1620 # endif
1621 # ifdef SIGBUS
1622 sys_siglist[SIGBUS] = "Bus error";
1623 # endif
1624 # ifdef SIGCLD
1625 sys_siglist[SIGCLD] = "Child status changed";
1626 # endif
1627 # ifdef SIGCHLD
1628 sys_siglist[SIGCHLD] = "Child status changed";
1629 # endif
1630 # ifdef SIGCONT
1631 sys_siglist[SIGCONT] = "Continued";
1632 # endif
1633 # ifdef SIGDANGER
1634 sys_siglist[SIGDANGER] = "Swap space dangerously low";
1635 # endif
1636 # ifdef SIGDGNOTIFY
1637 sys_siglist[SIGDGNOTIFY] = "Notification message in queue";
1638 # endif
1639 # ifdef SIGEMT
1640 sys_siglist[SIGEMT] = "Emulation trap";
1641 # endif
1642 sys_siglist[SIGFPE] = "Arithmetic exception";
1643 # ifdef SIGFREEZE
1644 sys_siglist[SIGFREEZE] = "SIGFREEZE";
1645 # endif
1646 # ifdef SIGGRANT
1647 sys_siglist[SIGGRANT] = "Monitor mode granted";
1648 # endif
1649 # ifdef SIGHUP
1650 sys_siglist[SIGHUP] = "Hangup";
1651 # endif
1652 sys_siglist[SIGILL] = "Illegal instruction";
1653 sys_siglist[SIGINT] = "Interrupt";
1654 # ifdef SIGIO
1655 sys_siglist[SIGIO] = "I/O possible";
1656 # endif
1657 # ifdef SIGIOINT
1658 sys_siglist[SIGIOINT] = "I/O intervention required";
1659 # endif
1660 # ifdef SIGIOT
1661 sys_siglist[SIGIOT] = "IOT trap";
1662 # endif
1663 # ifdef SIGKILL
1664 sys_siglist[SIGKILL] = "Killed";
1665 # endif
1666 # ifdef SIGLOST
1667 sys_siglist[SIGLOST] = "Resource lost";
1668 # endif
1669 # ifdef SIGLWP
1670 sys_siglist[SIGLWP] = "SIGLWP";
1671 # endif
1672 # ifdef SIGMSG
1673 sys_siglist[SIGMSG] = "Monitor mode data available";
1674 # endif
1675 # ifdef SIGPHONE
1676 sys_siglist[SIGWIND] = "SIGPHONE";
1677 # endif
1678 # ifdef SIGPIPE
1679 sys_siglist[SIGPIPE] = "Broken pipe";
1680 # endif
1681 # ifdef SIGPOLL
1682 sys_siglist[SIGPOLL] = "Pollable event occurred";
1683 # endif
1684 # ifdef SIGPROF
1685 sys_siglist[SIGPROF] = "Profiling timer expired";
1686 # endif
1687 # ifdef SIGPTY
1688 sys_siglist[SIGPTY] = "PTY I/O interrupt";
1689 # endif
1690 # ifdef SIGPWR
1691 sys_siglist[SIGPWR] = "Power-fail restart";
1692 # endif
1693 # ifdef SIGQUIT
1694 sys_siglist[SIGQUIT] = "Quit";
1695 # endif
1696 # ifdef SIGRETRACT
1697 sys_siglist[SIGRETRACT] = "Need to relinquish monitor mode";
1698 # endif
1699 # ifdef SIGSAK
1700 sys_siglist[SIGSAK] = "Secure attention";
1701 # endif
1702 sys_siglist[SIGSEGV] = "Segmentation violation";
1703 # ifdef SIGSOUND
1704 sys_siglist[SIGSOUND] = "Sound completed";
1705 # endif
1706 # ifdef SIGSTOP
1707 sys_siglist[SIGSTOP] = "Stopped (signal)";
1708 # endif
1709 # ifdef SIGSTP
1710 sys_siglist[SIGSTP] = "Stopped (user)";
1711 # endif
1712 # ifdef SIGSYS
1713 sys_siglist[SIGSYS] = "Bad argument to system call";
1714 # endif
1715 sys_siglist[SIGTERM] = "Terminated";
1716 # ifdef SIGTHAW
1717 sys_siglist[SIGTHAW] = "SIGTHAW";
1718 # endif
1719 # ifdef SIGTRAP
1720 sys_siglist[SIGTRAP] = "Trace/breakpoint trap";
1721 # endif
1722 # ifdef SIGTSTP
1723 sys_siglist[SIGTSTP] = "Stopped (user)";
1724 # endif
1725 # ifdef SIGTTIN
1726 sys_siglist[SIGTTIN] = "Stopped (tty input)";
1727 # endif
1728 # ifdef SIGTTOU
1729 sys_siglist[SIGTTOU] = "Stopped (tty output)";
1730 # endif
1731 # ifdef SIGURG
1732 sys_siglist[SIGURG] = "Urgent I/O condition";
1733 # endif
1734 # ifdef SIGUSR1
1735 sys_siglist[SIGUSR1] = "User defined signal 1";
1736 # endif
1737 # ifdef SIGUSR2
1738 sys_siglist[SIGUSR2] = "User defined signal 2";
1739 # endif
1740 # ifdef SIGVTALRM
1741 sys_siglist[SIGVTALRM] = "Virtual timer expired";
1742 # endif
1743 # ifdef SIGWAITING
1744 sys_siglist[SIGWAITING] = "Process's LWPs are blocked";
1745 # endif
1746 # ifdef SIGWINCH
1747 sys_siglist[SIGWINCH] = "Window size changed";
1748 # endif
1749 # ifdef SIGWIND
1750 sys_siglist[SIGWIND] = "SIGWIND";
1751 # endif
1752 # ifdef SIGXCPU
1753 sys_siglist[SIGXCPU] = "CPU time limit exceeded";
1754 # endif
1755 # ifdef SIGXFSZ
1756 sys_siglist[SIGXFSZ] = "File size limit exceeded";
1757 # endif
1758 }
1759 #endif /* !defined HAVE_STRSIGNAL && !defined HAVE_DECL_SYS_SIGLIST */
1760
1761 /* Don't alter signal handlers if dumping. On some machines,
1762 changing signal handlers sets static data that would make signals
1763 fail to work right when the dumped Emacs is run. */
1764 if (dumping)
1765 return;
1766
1767 sigfillset (&process_fatal_action.sa_mask);
1768 process_fatal_action.sa_handler = deliver_fatal_signal;
1769 process_fatal_action.sa_flags = emacs_sigaction_flags ();
1770
1771 sigfillset (&thread_fatal_action.sa_mask);
1772 thread_fatal_action.sa_handler = deliver_fatal_thread_signal;
1773 thread_fatal_action.sa_flags = process_fatal_action.sa_flags;
1774
1775 /* SIGINT may need special treatment on MS-Windows. See
1776 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1777 Please update the doc of kill-emacs, kill-emacs-hook, and
1778 NEWS if you change this. */
1779
1780 maybe_fatal_sig (SIGHUP);
1781 maybe_fatal_sig (SIGINT);
1782 maybe_fatal_sig (SIGTERM);
1783
1784 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1785 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1786 to behave more like typical batch applications do. */
1787 if (! noninteractive)
1788 signal (SIGPIPE, SIG_IGN);
1789
1790 sigaction (SIGQUIT, &process_fatal_action, 0);
1791 sigaction (SIGILL, &thread_fatal_action, 0);
1792 sigaction (SIGTRAP, &thread_fatal_action, 0);
1793
1794 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1795 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1796 interpreter's floating point operations, so treat SIGFPE as an
1797 arith-error if it arises in the main thread. */
1798 if (IEEE_FLOATING_POINT)
1799 sigaction (SIGFPE, &thread_fatal_action, 0);
1800 else
1801 {
1802 emacs_sigaction_init (&action, deliver_arith_signal);
1803 sigaction (SIGFPE, &action, 0);
1804 }
1805
1806 #ifdef SIGUSR1
1807 add_user_signal (SIGUSR1, "sigusr1");
1808 #endif
1809 #ifdef SIGUSR2
1810 add_user_signal (SIGUSR2, "sigusr2");
1811 #endif
1812 sigaction (SIGABRT, &thread_fatal_action, 0);
1813 #ifdef SIGPRE
1814 sigaction (SIGPRE, &thread_fatal_action, 0);
1815 #endif
1816 #ifdef SIGORE
1817 sigaction (SIGORE, &thread_fatal_action, 0);
1818 #endif
1819 #ifdef SIGUME
1820 sigaction (SIGUME, &thread_fatal_action, 0);
1821 #endif
1822 #ifdef SIGDLK
1823 sigaction (SIGDLK, &process_fatal_action, 0);
1824 #endif
1825 #ifdef SIGCPULIM
1826 sigaction (SIGCPULIM, &process_fatal_action, 0);
1827 #endif
1828 #ifdef SIGIOT
1829 sigaction (SIGIOT, &thread_fatal_action, 0);
1830 #endif
1831 #ifdef SIGEMT
1832 sigaction (SIGEMT, &thread_fatal_action, 0);
1833 #endif
1834 #ifdef SIGBUS
1835 sigaction (SIGBUS, &thread_fatal_action, 0);
1836 #endif
1837 sigaction (SIGSEGV, &thread_fatal_action, 0);
1838 #ifdef SIGSYS
1839 sigaction (SIGSYS, &thread_fatal_action, 0);
1840 #endif
1841 sigaction (SIGTERM, &process_fatal_action, 0);
1842 #ifdef SIGPROF
1843 signal (SIGPROF, SIG_IGN);
1844 #endif
1845 #ifdef SIGVTALRM
1846 sigaction (SIGVTALRM, &process_fatal_action, 0);
1847 #endif
1848 #ifdef SIGXCPU
1849 sigaction (SIGXCPU, &process_fatal_action, 0);
1850 #endif
1851 #ifdef SIGXFSZ
1852 sigaction (SIGXFSZ, &process_fatal_action, 0);
1853 #endif
1854
1855 #ifdef SIGDANGER
1856 /* This just means available memory is getting low. */
1857 emacs_sigaction_init (&action, deliver_danger_signal);
1858 sigaction (SIGDANGER, &action, 0);
1859 #endif
1860
1861 /* AIX-specific signals. */
1862 #ifdef SIGGRANT
1863 sigaction (SIGGRANT, &process_fatal_action, 0);
1864 #endif
1865 #ifdef SIGMIGRATE
1866 sigaction (SIGMIGRATE, &process_fatal_action, 0);
1867 #endif
1868 #ifdef SIGMSG
1869 sigaction (SIGMSG, &process_fatal_action, 0);
1870 #endif
1871 #ifdef SIGRETRACT
1872 sigaction (SIGRETRACT, &process_fatal_action, 0);
1873 #endif
1874 #ifdef SIGSAK
1875 sigaction (SIGSAK, &process_fatal_action, 0);
1876 #endif
1877 #ifdef SIGSOUND
1878 sigaction (SIGSOUND, &process_fatal_action, 0);
1879 #endif
1880 #ifdef SIGTALRM
1881 sigaction (SIGTALRM, &thread_fatal_action, 0);
1882 #endif
1883 }
1884 \f
1885 #ifndef HAVE_RANDOM
1886 #ifdef random
1887 #define HAVE_RANDOM
1888 #endif
1889 #endif
1890
1891 /* Figure out how many bits the system's random number generator uses.
1892 `random' and `lrand48' are assumed to return 31 usable bits.
1893 BSD `rand' returns a 31 bit value but the low order bits are unusable;
1894 so we'll shift it and treat it like the 15-bit USG `rand'. */
1895
1896 #ifndef RAND_BITS
1897 # ifdef HAVE_RANDOM
1898 # define RAND_BITS 31
1899 # else /* !HAVE_RANDOM */
1900 # ifdef HAVE_LRAND48
1901 # define RAND_BITS 31
1902 # define random lrand48
1903 # else /* !HAVE_LRAND48 */
1904 # define RAND_BITS 15
1905 # if RAND_MAX == 32767
1906 # define random rand
1907 # else /* RAND_MAX != 32767 */
1908 # if RAND_MAX == 2147483647
1909 # define random() (rand () >> 16)
1910 # else /* RAND_MAX != 2147483647 */
1911 # ifdef USG
1912 # define random rand
1913 # else
1914 # define random() (rand () >> 16)
1915 # endif /* !USG */
1916 # endif /* RAND_MAX != 2147483647 */
1917 # endif /* RAND_MAX != 32767 */
1918 # endif /* !HAVE_LRAND48 */
1919 # endif /* !HAVE_RANDOM */
1920 #endif /* !RAND_BITS */
1921
1922 void
1923 seed_random (void *seed, ptrdiff_t seed_size)
1924 {
1925 #if defined HAVE_RANDOM || ! defined HAVE_LRAND48
1926 unsigned int arg = 0;
1927 #else
1928 long int arg = 0;
1929 #endif
1930 unsigned char *argp = (unsigned char *) &arg;
1931 unsigned char *seedp = seed;
1932 ptrdiff_t i;
1933 for (i = 0; i < seed_size; i++)
1934 argp[i % sizeof arg] ^= seedp[i];
1935 #ifdef HAVE_RANDOM
1936 srandom (arg);
1937 #else
1938 # ifdef HAVE_LRAND48
1939 srand48 (arg);
1940 # else
1941 srand (arg);
1942 # endif
1943 #endif
1944 }
1945
1946 void
1947 init_random (void)
1948 {
1949 EMACS_TIME t = current_emacs_time ();
1950 uintmax_t v = getpid () ^ EMACS_SECS (t) ^ EMACS_NSECS (t);
1951 seed_random (&v, sizeof v);
1952 }
1953
1954 /*
1955 * Return a nonnegative random integer out of whatever we've got.
1956 * It contains enough bits to make a random (signed) Emacs fixnum.
1957 * This suffices even for a 64-bit architecture with a 15-bit rand.
1958 */
1959 EMACS_INT
1960 get_random (void)
1961 {
1962 EMACS_UINT val = 0;
1963 int i;
1964 for (i = 0; i < (FIXNUM_BITS + RAND_BITS - 1) / RAND_BITS; i++)
1965 val = (random () ^ (val << RAND_BITS)
1966 ^ (val >> (BITS_PER_EMACS_INT - RAND_BITS)));
1967 val ^= val >> (BITS_PER_EMACS_INT - FIXNUM_BITS);
1968 return val & INTMASK;
1969 }
1970
1971 #ifndef HAVE_SNPRINTF
1972 /* Approximate snprintf as best we can on ancient hosts that lack it. */
1973 int
1974 snprintf (char *buf, size_t bufsize, char const *format, ...)
1975 {
1976 ptrdiff_t size = min (bufsize, PTRDIFF_MAX);
1977 ptrdiff_t nbytes = size - 1;
1978 va_list ap;
1979
1980 if (size)
1981 {
1982 va_start (ap, format);
1983 nbytes = doprnt (buf, size, format, 0, ap);
1984 va_end (ap);
1985 }
1986
1987 if (nbytes == size - 1)
1988 {
1989 /* Calculate the length of the string that would have been created
1990 had the buffer been large enough. */
1991 char stackbuf[4000];
1992 char *b = stackbuf;
1993 ptrdiff_t bsize = sizeof stackbuf;
1994 va_start (ap, format);
1995 nbytes = evxprintf (&b, &bsize, stackbuf, -1, format, ap);
1996 va_end (ap);
1997 if (b != stackbuf)
1998 xfree (b);
1999 }
2000
2001 if (INT_MAX < nbytes)
2002 {
2003 #ifdef EOVERFLOW
2004 errno = EOVERFLOW;
2005 #else
2006 errno = EDOM;
2007 #endif
2008 return -1;
2009 }
2010 return nbytes;
2011 }
2012 #endif
2013 \f
2014 /* If a backtrace is available, output the top lines of it to stderr.
2015 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2016 This function may be called from a signal handler, so it should
2017 not invoke async-unsafe functions like malloc. */
2018 void
2019 emacs_backtrace (int backtrace_limit)
2020 {
2021 void *main_backtrace_buffer[BACKTRACE_LIMIT_MAX + 1];
2022 int bounded_limit = min (backtrace_limit, BACKTRACE_LIMIT_MAX);
2023 void *buffer;
2024 int npointers;
2025
2026 if (thread_backtrace_npointers)
2027 {
2028 buffer = thread_backtrace_buffer;
2029 npointers = thread_backtrace_npointers;
2030 }
2031 else
2032 {
2033 buffer = main_backtrace_buffer;
2034 npointers = backtrace (buffer, bounded_limit + 1);
2035 }
2036
2037 if (npointers)
2038 {
2039 ignore_value (write (STDERR_FILENO, "\nBacktrace:\n", 12));
2040 backtrace_symbols_fd (buffer, npointers, STDERR_FILENO);
2041 if (bounded_limit < npointers)
2042 ignore_value (write (STDERR_FILENO, "...\n", 4));
2043 }
2044 }
2045 \f
2046 #ifndef HAVE_NTGUI
2047 void
2048 emacs_abort (void)
2049 {
2050 terminate_due_to_signal (SIGABRT, 10);
2051 }
2052 #endif
2053
2054 int
2055 emacs_open (const char *path, int oflag, int mode)
2056 {
2057 register int rtnval;
2058
2059 while ((rtnval = open (path, oflag, mode)) == -1
2060 && (errno == EINTR))
2061 QUIT;
2062 return (rtnval);
2063 }
2064
2065 int
2066 emacs_close (int fd)
2067 {
2068 int did_retry = 0;
2069 register int rtnval;
2070
2071 while ((rtnval = close (fd)) == -1
2072 && (errno == EINTR))
2073 did_retry = 1;
2074
2075 /* If close is interrupted SunOS 4.1 may or may not have closed the
2076 file descriptor. If it did the second close will fail with
2077 errno = EBADF. That means we have succeeded. */
2078 if (rtnval == -1 && did_retry && errno == EBADF)
2079 return 0;
2080
2081 return rtnval;
2082 }
2083
2084 /* Maximum number of bytes to read or write in a single system call.
2085 This works around a serious bug in Linux kernels before 2.6.16; see
2086 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2087 It's likely to work around similar bugs in other operating systems, so do it
2088 on all platforms. Round INT_MAX down to a page size, with the conservative
2089 assumption that page sizes are at most 2**18 bytes (any kernel with a
2090 page size larger than that shouldn't have the bug). */
2091 #ifndef MAX_RW_COUNT
2092 #define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2093 #endif
2094
2095 /* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2096 Return the number of bytes read, which might be less than NBYTE.
2097 On error, set errno and return -1. */
2098 ptrdiff_t
2099 emacs_read (int fildes, char *buf, ptrdiff_t nbyte)
2100 {
2101 register ssize_t rtnval;
2102
2103 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2104 passes a size that large to emacs_read. */
2105
2106 while ((rtnval = read (fildes, buf, nbyte)) == -1
2107 && (errno == EINTR))
2108 QUIT;
2109 return (rtnval);
2110 }
2111
2112 /* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2113 or if a partial write occurs. Return the number of bytes written, setting
2114 errno if this is less than NBYTE. */
2115 ptrdiff_t
2116 emacs_write (int fildes, const char *buf, ptrdiff_t nbyte)
2117 {
2118 ssize_t rtnval;
2119 ptrdiff_t bytes_written;
2120
2121 bytes_written = 0;
2122
2123 while (nbyte > 0)
2124 {
2125 rtnval = write (fildes, buf, min (nbyte, MAX_RW_COUNT));
2126
2127 if (rtnval < 0)
2128 {
2129 if (errno == EINTR)
2130 {
2131 /* I originally used `QUIT' but that might causes files to
2132 be truncated if you hit C-g in the middle of it. --Stef */
2133 if (pending_signals)
2134 process_pending_signals ();
2135 continue;
2136 }
2137 else
2138 break;
2139 }
2140
2141 buf += rtnval;
2142 nbyte -= rtnval;
2143 bytes_written += rtnval;
2144 }
2145
2146 return (bytes_written);
2147 }
2148
2149 static struct allocator const emacs_norealloc_allocator =
2150 { xmalloc, NULL, xfree, memory_full };
2151
2152 /* Get the symbolic link value of FILENAME. Return a pointer to a
2153 NUL-terminated string. If readlink fails, return NULL and set
2154 errno. If the value fits in INITIAL_BUF, return INITIAL_BUF.
2155 Otherwise, allocate memory and return a pointer to that memory. If
2156 memory allocation fails, diagnose and fail without returning. If
2157 successful, store the length of the symbolic link into *LINKLEN. */
2158 char *
2159 emacs_readlink (char const *filename, char initial_buf[READLINK_BUFSIZE])
2160 {
2161 return careadlinkat (AT_FDCWD, filename, initial_buf, READLINK_BUFSIZE,
2162 &emacs_norealloc_allocator, careadlinkatcwd);
2163 }
2164 \f
2165 #ifdef USG
2166 /*
2167 * All of the following are for USG.
2168 *
2169 * On USG systems the system calls are INTERRUPTIBLE by signals
2170 * that the user program has elected to catch. Thus the system call
2171 * must be retried in these cases. To handle this without massive
2172 * changes in the source code, we remap the standard system call names
2173 * to names for our own functions in sysdep.c that do the system call
2174 * with retries. Actually, for portability reasons, it is good
2175 * programming practice, as this example shows, to limit all actual
2176 * system calls to a single occurrence in the source. Sure, this
2177 * adds an extra level of function call overhead but it is almost
2178 * always negligible. Fred Fish, Unisoft Systems Inc.
2179 */
2180
2181 /*
2182 * Warning, this function may not duplicate 4.2 action properly
2183 * under error conditions.
2184 */
2185
2186 #if !defined (HAVE_GETWD) || defined (BROKEN_GETWD)
2187
2188 #ifndef MAXPATHLEN
2189 /* In 4.1, param.h fails to define this. */
2190 #define MAXPATHLEN 1024
2191 #endif
2192
2193 char *
2194 getwd (char *pathname)
2195 {
2196 char *npath, *spath;
2197 extern char *getcwd (char *, size_t);
2198
2199 block_input (); /* getcwd uses malloc */
2200 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
2201 if (spath == 0)
2202 {
2203 unblock_input ();
2204 return spath;
2205 }
2206 /* On Altos 3068, getcwd can return @hostname/dir, so discard
2207 up to first slash. Should be harmless on other systems. */
2208 while (*npath && *npath != '/')
2209 npath++;
2210 strcpy (pathname, npath);
2211 free (spath); /* getcwd uses malloc */
2212 unblock_input ();
2213 return pathname;
2214 }
2215
2216 #endif /* !defined (HAVE_GETWD) || defined (BROKEN_GETWD) */
2217 #endif /* USG */
2218 \f
2219 /* Directory routines for systems that don't have them. */
2220
2221 #ifdef HAVE_DIRENT_H
2222
2223 #include <dirent.h>
2224
2225 #if !defined (HAVE_CLOSEDIR)
2226
2227 int
2228 closedir (DIR *dirp /* stream from opendir */)
2229 {
2230 int rtnval;
2231
2232 rtnval = emacs_close (dirp->dd_fd);
2233 xfree (dirp);
2234
2235 return rtnval;
2236 }
2237 #endif /* not HAVE_CLOSEDIR */
2238 #endif /* HAVE_DIRENT_H */
2239
2240 \f
2241 /* Return a struct timeval that is roughly equivalent to T.
2242 Use the least timeval not less than T.
2243 Return an extremal value if the result would overflow. */
2244 struct timeval
2245 make_timeval (EMACS_TIME t)
2246 {
2247 struct timeval tv;
2248 tv.tv_sec = t.tv_sec;
2249 tv.tv_usec = t.tv_nsec / 1000;
2250
2251 if (t.tv_nsec % 1000 != 0)
2252 {
2253 if (tv.tv_usec < 999999)
2254 tv.tv_usec++;
2255 else if (tv.tv_sec < TYPE_MAXIMUM (time_t))
2256 {
2257 tv.tv_sec++;
2258 tv.tv_usec = 0;
2259 }
2260 }
2261
2262 return tv;
2263 }
2264
2265 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2266 ATIME and MTIME, respectively.
2267 FD must be either negative -- in which case it is ignored --
2268 or a file descriptor that is open on FILE.
2269 If FD is nonnegative, then FILE can be NULL. */
2270 int
2271 set_file_times (int fd, const char *filename,
2272 EMACS_TIME atime, EMACS_TIME mtime)
2273 {
2274 struct timespec timespec[2];
2275 timespec[0] = atime;
2276 timespec[1] = mtime;
2277 return fdutimens (fd, filename, timespec);
2278 }
2279 \f
2280 #ifndef HAVE_STRSIGNAL
2281 char *
2282 strsignal (int code)
2283 {
2284 char *signame = 0;
2285
2286 if (0 <= code && code < NSIG)
2287 {
2288 /* Cast to suppress warning if the table has const char *. */
2289 signame = (char *) sys_siglist[code];
2290 }
2291
2292 return signame;
2293 }
2294 #endif /* HAVE_STRSIGNAL */
2295 \f
2296 #ifndef DOS_NT
2297 /* For make-serial-process */
2298 int
2299 serial_open (char *port)
2300 {
2301 int fd = -1;
2302
2303 fd = emacs_open ((char*) port,
2304 O_RDWR
2305 #ifdef O_NONBLOCK
2306 | O_NONBLOCK
2307 #else
2308 | O_NDELAY
2309 #endif
2310 #ifdef O_NOCTTY
2311 | O_NOCTTY
2312 #endif
2313 , 0);
2314 if (fd < 0)
2315 {
2316 error ("Could not open %s: %s",
2317 port, emacs_strerror (errno));
2318 }
2319 #ifdef TIOCEXCL
2320 ioctl (fd, TIOCEXCL, (char *) 0);
2321 #endif
2322
2323 return fd;
2324 }
2325
2326 #if !defined (HAVE_CFMAKERAW)
2327 /* Workaround for targets which are missing cfmakeraw. */
2328 /* Pasted from man page. */
2329 static void
2330 cfmakeraw (struct termios *termios_p)
2331 {
2332 termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2333 termios_p->c_oflag &= ~OPOST;
2334 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2335 termios_p->c_cflag &= ~(CSIZE|PARENB);
2336 termios_p->c_cflag |= CS8;
2337 }
2338 #endif /* !defined (HAVE_CFMAKERAW */
2339
2340 #if !defined (HAVE_CFSETSPEED)
2341 /* Workaround for targets which are missing cfsetspeed. */
2342 static int
2343 cfsetspeed (struct termios *termios_p, speed_t vitesse)
2344 {
2345 return (cfsetispeed (termios_p, vitesse)
2346 + cfsetospeed (termios_p, vitesse));
2347 }
2348 #endif
2349
2350 /* For serial-process-configure */
2351 void
2352 serial_configure (struct Lisp_Process *p,
2353 Lisp_Object contact)
2354 {
2355 Lisp_Object childp2 = Qnil;
2356 Lisp_Object tem = Qnil;
2357 struct termios attr;
2358 int err = -1;
2359 char summary[4] = "???"; /* This usually becomes "8N1". */
2360
2361 childp2 = Fcopy_sequence (p->childp);
2362
2363 /* Read port attributes and prepare default configuration. */
2364 err = tcgetattr (p->outfd, &attr);
2365 if (err != 0)
2366 error ("tcgetattr() failed: %s", emacs_strerror (errno));
2367 cfmakeraw (&attr);
2368 #if defined (CLOCAL)
2369 attr.c_cflag |= CLOCAL;
2370 #endif
2371 #if defined (CREAD)
2372 attr.c_cflag |= CREAD;
2373 #endif
2374
2375 /* Configure speed. */
2376 if (!NILP (Fplist_member (contact, QCspeed)))
2377 tem = Fplist_get (contact, QCspeed);
2378 else
2379 tem = Fplist_get (p->childp, QCspeed);
2380 CHECK_NUMBER (tem);
2381 err = cfsetspeed (&attr, XINT (tem));
2382 if (err != 0)
2383 error ("cfsetspeed(%"pI"d) failed: %s", XINT (tem),
2384 emacs_strerror (errno));
2385 childp2 = Fplist_put (childp2, QCspeed, tem);
2386
2387 /* Configure bytesize. */
2388 if (!NILP (Fplist_member (contact, QCbytesize)))
2389 tem = Fplist_get (contact, QCbytesize);
2390 else
2391 tem = Fplist_get (p->childp, QCbytesize);
2392 if (NILP (tem))
2393 tem = make_number (8);
2394 CHECK_NUMBER (tem);
2395 if (XINT (tem) != 7 && XINT (tem) != 8)
2396 error (":bytesize must be nil (8), 7, or 8");
2397 summary[0] = XINT (tem) + '0';
2398 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2399 attr.c_cflag &= ~CSIZE;
2400 attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
2401 #else
2402 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
2403 if (XINT (tem) != 8)
2404 error ("Bytesize cannot be changed");
2405 #endif
2406 childp2 = Fplist_put (childp2, QCbytesize, tem);
2407
2408 /* Configure parity. */
2409 if (!NILP (Fplist_member (contact, QCparity)))
2410 tem = Fplist_get (contact, QCparity);
2411 else
2412 tem = Fplist_get (p->childp, QCparity);
2413 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
2414 error (":parity must be nil (no parity), `even', or `odd'");
2415 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2416 attr.c_cflag &= ~(PARENB | PARODD);
2417 attr.c_iflag &= ~(IGNPAR | INPCK);
2418 if (NILP (tem))
2419 {
2420 summary[1] = 'N';
2421 }
2422 else if (EQ (tem, Qeven))
2423 {
2424 summary[1] = 'E';
2425 attr.c_cflag |= PARENB;
2426 attr.c_iflag |= (IGNPAR | INPCK);
2427 }
2428 else if (EQ (tem, Qodd))
2429 {
2430 summary[1] = 'O';
2431 attr.c_cflag |= (PARENB | PARODD);
2432 attr.c_iflag |= (IGNPAR | INPCK);
2433 }
2434 #else
2435 /* Don't error on no parity, which should be set by cfmakeraw. */
2436 if (!NILP (tem))
2437 error ("Parity cannot be configured");
2438 #endif
2439 childp2 = Fplist_put (childp2, QCparity, tem);
2440
2441 /* Configure stopbits. */
2442 if (!NILP (Fplist_member (contact, QCstopbits)))
2443 tem = Fplist_get (contact, QCstopbits);
2444 else
2445 tem = Fplist_get (p->childp, QCstopbits);
2446 if (NILP (tem))
2447 tem = make_number (1);
2448 CHECK_NUMBER (tem);
2449 if (XINT (tem) != 1 && XINT (tem) != 2)
2450 error (":stopbits must be nil (1 stopbit), 1, or 2");
2451 summary[2] = XINT (tem) + '0';
2452 #if defined (CSTOPB)
2453 attr.c_cflag &= ~CSTOPB;
2454 if (XINT (tem) == 2)
2455 attr.c_cflag |= CSTOPB;
2456 #else
2457 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
2458 if (XINT (tem) != 1)
2459 error ("Stopbits cannot be configured");
2460 #endif
2461 childp2 = Fplist_put (childp2, QCstopbits, tem);
2462
2463 /* Configure flowcontrol. */
2464 if (!NILP (Fplist_member (contact, QCflowcontrol)))
2465 tem = Fplist_get (contact, QCflowcontrol);
2466 else
2467 tem = Fplist_get (p->childp, QCflowcontrol);
2468 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
2469 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2470 #if defined (CRTSCTS)
2471 attr.c_cflag &= ~CRTSCTS;
2472 #endif
2473 #if defined (CNEW_RTSCTS)
2474 attr.c_cflag &= ~CNEW_RTSCTS;
2475 #endif
2476 #if defined (IXON) && defined (IXOFF)
2477 attr.c_iflag &= ~(IXON | IXOFF);
2478 #endif
2479 if (NILP (tem))
2480 {
2481 /* Already configured. */
2482 }
2483 else if (EQ (tem, Qhw))
2484 {
2485 #if defined (CRTSCTS)
2486 attr.c_cflag |= CRTSCTS;
2487 #elif defined (CNEW_RTSCTS)
2488 attr.c_cflag |= CNEW_RTSCTS;
2489 #else
2490 error ("Hardware flowcontrol (RTS/CTS) not supported");
2491 #endif
2492 }
2493 else if (EQ (tem, Qsw))
2494 {
2495 #if defined (IXON) && defined (IXOFF)
2496 attr.c_iflag |= (IXON | IXOFF);
2497 #else
2498 error ("Software flowcontrol (XON/XOFF) not supported");
2499 #endif
2500 }
2501 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
2502
2503 /* Activate configuration. */
2504 err = tcsetattr (p->outfd, TCSANOW, &attr);
2505 if (err != 0)
2506 error ("tcsetattr() failed: %s", emacs_strerror (errno));
2507
2508 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
2509 pset_childp (p, childp2);
2510 }
2511 #endif /* not DOS_NT */
2512 \f
2513 /* System depended enumeration of and access to system processes a-la ps(1). */
2514
2515 #ifdef HAVE_PROCFS
2516
2517 /* Process enumeration and access via /proc. */
2518
2519 Lisp_Object
2520 list_system_processes (void)
2521 {
2522 Lisp_Object procdir, match, proclist, next;
2523 struct gcpro gcpro1, gcpro2;
2524 register Lisp_Object tail;
2525
2526 GCPRO2 (procdir, match);
2527 /* For every process on the system, there's a directory in the
2528 "/proc" pseudo-directory whose name is the numeric ID of that
2529 process. */
2530 procdir = build_string ("/proc");
2531 match = build_string ("[0-9]+");
2532 proclist = directory_files_internal (procdir, Qnil, match, Qt, 0,
2533 Qnil, Qnil);
2534
2535 /* `proclist' gives process IDs as strings. Destructively convert
2536 each string into a number. */
2537 for (tail = proclist; CONSP (tail); tail = next)
2538 {
2539 next = XCDR (tail);
2540 XSETCAR (tail, Fstring_to_number (XCAR (tail), Qnil));
2541 }
2542 UNGCPRO;
2543
2544 /* directory_files_internal returns the files in reverse order; undo
2545 that. */
2546 proclist = Fnreverse (proclist);
2547 return proclist;
2548 }
2549
2550 #elif defined BSD_SYSTEM
2551
2552 Lisp_Object
2553 list_system_processes (void)
2554 {
2555 #if defined DARWIN_OS || defined __NetBSD__ || defined __OpenBSD__
2556 int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
2557 #else
2558 int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PROC};
2559 #endif
2560 size_t len;
2561 struct kinfo_proc *procs;
2562 size_t i;
2563
2564 struct gcpro gcpro1;
2565 Lisp_Object proclist = Qnil;
2566
2567 if (sysctl (mib, 3, NULL, &len, NULL, 0) != 0)
2568 return proclist;
2569
2570 procs = xmalloc (len);
2571 if (sysctl (mib, 3, procs, &len, NULL, 0) != 0)
2572 {
2573 xfree (procs);
2574 return proclist;
2575 }
2576
2577 GCPRO1 (proclist);
2578 len /= sizeof (struct kinfo_proc);
2579 for (i = 0; i < len; i++)
2580 {
2581 #if defined DARWIN_OS || defined __NetBSD__
2582 proclist = Fcons (make_fixnum_or_float (procs[i].kp_proc.p_pid), proclist);
2583 #elif defined __OpenBSD__
2584 proclist = Fcons (make_fixnum_or_float (procs[i].p_pid), proclist);
2585 #else
2586 proclist = Fcons (make_fixnum_or_float (procs[i].ki_pid), proclist);
2587 #endif
2588 }
2589 UNGCPRO;
2590
2591 xfree (procs);
2592
2593 return proclist;
2594 }
2595
2596 /* The WINDOWSNT implementation is in w32.c.
2597 The MSDOS implementation is in dosfns.c. */
2598 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2599
2600 Lisp_Object
2601 list_system_processes (void)
2602 {
2603 return Qnil;
2604 }
2605
2606 #endif /* !defined (WINDOWSNT) */
2607
2608 #ifdef GNU_LINUX
2609 static EMACS_TIME
2610 time_from_jiffies (unsigned long long tval, long hz)
2611 {
2612 unsigned long long s = tval / hz;
2613 unsigned long long frac = tval % hz;
2614 int ns;
2615
2616 if (TYPE_MAXIMUM (time_t) < s)
2617 time_overflow ();
2618 if (LONG_MAX - 1 <= ULLONG_MAX / EMACS_TIME_RESOLUTION
2619 || frac <= ULLONG_MAX / EMACS_TIME_RESOLUTION)
2620 ns = frac * EMACS_TIME_RESOLUTION / hz;
2621 else
2622 {
2623 /* This is reachable only in the unlikely case that HZ * HZ
2624 exceeds ULLONG_MAX. It calculates an approximation that is
2625 guaranteed to be in range. */
2626 long hz_per_ns = (hz / EMACS_TIME_RESOLUTION
2627 + (hz % EMACS_TIME_RESOLUTION != 0));
2628 ns = frac / hz_per_ns;
2629 }
2630
2631 return make_emacs_time (s, ns);
2632 }
2633
2634 static Lisp_Object
2635 ltime_from_jiffies (unsigned long long tval, long hz)
2636 {
2637 EMACS_TIME t = time_from_jiffies (tval, hz);
2638 return make_lisp_time (t);
2639 }
2640
2641 static EMACS_TIME
2642 get_up_time (void)
2643 {
2644 FILE *fup;
2645 EMACS_TIME up = make_emacs_time (0, 0);
2646
2647 block_input ();
2648 fup = fopen ("/proc/uptime", "r");
2649
2650 if (fup)
2651 {
2652 unsigned long long upsec, upfrac, idlesec, idlefrac;
2653 int upfrac_start, upfrac_end, idlefrac_start, idlefrac_end;
2654
2655 if (fscanf (fup, "%llu.%n%llu%n %llu.%n%llu%n",
2656 &upsec, &upfrac_start, &upfrac, &upfrac_end,
2657 &idlesec, &idlefrac_start, &idlefrac, &idlefrac_end)
2658 == 4)
2659 {
2660 if (TYPE_MAXIMUM (time_t) < upsec)
2661 {
2662 upsec = TYPE_MAXIMUM (time_t);
2663 upfrac = EMACS_TIME_RESOLUTION - 1;
2664 }
2665 else
2666 {
2667 int upfraclen = upfrac_end - upfrac_start;
2668 for (; upfraclen < LOG10_EMACS_TIME_RESOLUTION; upfraclen++)
2669 upfrac *= 10;
2670 for (; LOG10_EMACS_TIME_RESOLUTION < upfraclen; upfraclen--)
2671 upfrac /= 10;
2672 upfrac = min (upfrac, EMACS_TIME_RESOLUTION - 1);
2673 }
2674 up = make_emacs_time (upsec, upfrac);
2675 }
2676 fclose (fup);
2677 }
2678 unblock_input ();
2679
2680 return up;
2681 }
2682
2683 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2684 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2685
2686 static Lisp_Object
2687 procfs_ttyname (int rdev)
2688 {
2689 FILE *fdev = NULL;
2690 char name[PATH_MAX];
2691
2692 block_input ();
2693 fdev = fopen ("/proc/tty/drivers", "r");
2694
2695 if (fdev)
2696 {
2697 unsigned major;
2698 unsigned long minor_beg, minor_end;
2699 char minor[25]; /* 2 32-bit numbers + dash */
2700 char *endp;
2701
2702 while (!feof (fdev) && !ferror (fdev))
2703 {
2704 if (3 <= fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor)
2705 && major == MAJOR (rdev))
2706 {
2707 minor_beg = strtoul (minor, &endp, 0);
2708 if (*endp == '\0')
2709 minor_end = minor_beg;
2710 else if (*endp == '-')
2711 minor_end = strtoul (endp + 1, &endp, 0);
2712 else
2713 continue;
2714
2715 if (MINOR (rdev) >= minor_beg && MINOR (rdev) <= minor_end)
2716 {
2717 sprintf (name + strlen (name), "%u", MINOR (rdev));
2718 break;
2719 }
2720 }
2721 }
2722 fclose (fdev);
2723 }
2724 unblock_input ();
2725 return build_string (name);
2726 }
2727
2728 static unsigned long
2729 procfs_get_total_memory (void)
2730 {
2731 FILE *fmem = NULL;
2732 unsigned long retval = 2 * 1024 * 1024; /* default: 2GB */
2733
2734 block_input ();
2735 fmem = fopen ("/proc/meminfo", "r");
2736
2737 if (fmem)
2738 {
2739 unsigned long entry_value;
2740 char entry_name[20]; /* the longest I saw is 13+1 */
2741
2742 while (!feof (fmem) && !ferror (fmem))
2743 {
2744 if (2 <= fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value)
2745 && strcmp (entry_name, "MemTotal:") == 0)
2746 {
2747 retval = entry_value;
2748 break;
2749 }
2750 }
2751 fclose (fmem);
2752 }
2753 unblock_input ();
2754 return retval;
2755 }
2756
2757 Lisp_Object
2758 system_process_attributes (Lisp_Object pid)
2759 {
2760 char procfn[PATH_MAX], fn[PATH_MAX];
2761 struct stat st;
2762 struct passwd *pw;
2763 struct group *gr;
2764 long clocks_per_sec;
2765 char *procfn_end;
2766 char procbuf[1025], *p, *q;
2767 int fd;
2768 ssize_t nread;
2769 static char const default_cmd[] = "???";
2770 const char *cmd = default_cmd;
2771 int cmdsize = sizeof default_cmd - 1;
2772 char *cmdline = NULL;
2773 ptrdiff_t cmdline_size;
2774 unsigned char c;
2775 printmax_t proc_id;
2776 int ppid, pgrp, sess, tty, tpgid, thcount;
2777 uid_t uid;
2778 gid_t gid;
2779 unsigned long long u_time, s_time, cutime, cstime, start;
2780 long priority, niceness, rss;
2781 unsigned long minflt, majflt, cminflt, cmajflt, vsize;
2782 EMACS_TIME tnow, tstart, tboot, telapsed, us_time;
2783 double pcpu, pmem;
2784 Lisp_Object attrs = Qnil;
2785 Lisp_Object cmd_str, decoded_cmd, tem;
2786 struct gcpro gcpro1, gcpro2;
2787
2788 CHECK_NUMBER_OR_FLOAT (pid);
2789 CONS_TO_INTEGER (pid, pid_t, proc_id);
2790 sprintf (procfn, "/proc/%"pMd, proc_id);
2791 if (stat (procfn, &st) < 0)
2792 return attrs;
2793
2794 GCPRO2 (attrs, decoded_cmd);
2795
2796 /* euid egid */
2797 uid = st.st_uid;
2798 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid)), attrs);
2799 block_input ();
2800 pw = getpwuid (uid);
2801 unblock_input ();
2802 if (pw)
2803 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
2804
2805 gid = st.st_gid;
2806 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid)), attrs);
2807 block_input ();
2808 gr = getgrgid (gid);
2809 unblock_input ();
2810 if (gr)
2811 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
2812
2813 strcpy (fn, procfn);
2814 procfn_end = fn + strlen (fn);
2815 strcpy (procfn_end, "/stat");
2816 fd = emacs_open (fn, O_RDONLY, 0);
2817 if (fd >= 0 && (nread = emacs_read (fd, procbuf, sizeof (procbuf) - 1)) > 0)
2818 {
2819 procbuf[nread] = '\0';
2820 p = procbuf;
2821
2822 p = strchr (p, '(');
2823 if (p != NULL)
2824 {
2825 q = strrchr (p + 1, ')');
2826 /* comm */
2827 if (q != NULL)
2828 {
2829 cmd = p + 1;
2830 cmdsize = q - cmd;
2831 }
2832 }
2833 else
2834 q = NULL;
2835 /* Command name is encoded in locale-coding-system; decode it. */
2836 cmd_str = make_unibyte_string (cmd, cmdsize);
2837 decoded_cmd = code_convert_string_norecord (cmd_str,
2838 Vlocale_coding_system, 0);
2839 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
2840
2841 if (q)
2842 {
2843 EMACS_INT ppid_eint, pgrp_eint, sess_eint, tpgid_eint, thcount_eint;
2844 p = q + 2;
2845 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt utime stime cutime cstime priority nice thcount . start vsize rss */
2846 sscanf (p, "%c %d %d %d %d %d %*u %lu %lu %lu %lu %Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld",
2847 &c, &ppid, &pgrp, &sess, &tty, &tpgid,
2848 &minflt, &cminflt, &majflt, &cmajflt,
2849 &u_time, &s_time, &cutime, &cstime,
2850 &priority, &niceness, &thcount, &start, &vsize, &rss);
2851 {
2852 char state_str[2];
2853
2854 state_str[0] = c;
2855 state_str[1] = '\0';
2856 tem = build_string (state_str);
2857 attrs = Fcons (Fcons (Qstate, tem), attrs);
2858 }
2859 /* Stops GCC whining about limited range of data type. */
2860 ppid_eint = ppid;
2861 pgrp_eint = pgrp;
2862 sess_eint = sess;
2863 tpgid_eint = tpgid;
2864 thcount_eint = thcount;
2865 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (ppid_eint)), attrs);
2866 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pgrp_eint)), attrs);
2867 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (sess_eint)), attrs);
2868 attrs = Fcons (Fcons (Qttname, procfs_ttyname (tty)), attrs);
2869 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (tpgid_eint)), attrs);
2870 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (minflt)), attrs);
2871 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (majflt)), attrs);
2872 attrs = Fcons (Fcons (Qcminflt, make_fixnum_or_float (cminflt)), attrs);
2873 attrs = Fcons (Fcons (Qcmajflt, make_fixnum_or_float (cmajflt)), attrs);
2874 clocks_per_sec = sysconf (_SC_CLK_TCK);
2875 if (clocks_per_sec < 0)
2876 clocks_per_sec = 100;
2877 attrs = Fcons (Fcons (Qutime,
2878 ltime_from_jiffies (u_time, clocks_per_sec)),
2879 attrs);
2880 attrs = Fcons (Fcons (Qstime,
2881 ltime_from_jiffies (s_time, clocks_per_sec)),
2882 attrs);
2883 attrs = Fcons (Fcons (Qtime,
2884 ltime_from_jiffies (s_time + u_time,
2885 clocks_per_sec)),
2886 attrs);
2887 attrs = Fcons (Fcons (Qcutime,
2888 ltime_from_jiffies (cutime, clocks_per_sec)),
2889 attrs);
2890 attrs = Fcons (Fcons (Qcstime,
2891 ltime_from_jiffies (cstime, clocks_per_sec)),
2892 attrs);
2893 attrs = Fcons (Fcons (Qctime,
2894 ltime_from_jiffies (cstime+cutime, clocks_per_sec)),
2895 attrs);
2896 attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs);
2897 attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
2898 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs);
2899 tnow = current_emacs_time ();
2900 telapsed = get_up_time ();
2901 tboot = sub_emacs_time (tnow, telapsed);
2902 tstart = time_from_jiffies (start, clocks_per_sec);
2903 tstart = add_emacs_time (tboot, tstart);
2904 attrs = Fcons (Fcons (Qstart, make_lisp_time (tstart)), attrs);
2905 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs);
2906 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs);
2907 telapsed = sub_emacs_time (tnow, tstart);
2908 attrs = Fcons (Fcons (Qetime, make_lisp_time (telapsed)), attrs);
2909 us_time = time_from_jiffies (u_time + s_time, clocks_per_sec);
2910 pcpu = (EMACS_TIME_TO_DOUBLE (us_time)
2911 / EMACS_TIME_TO_DOUBLE (telapsed));
2912 if (pcpu > 1.0)
2913 pcpu = 1.0;
2914 attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
2915 pmem = 4.0 * 100 * rss / procfs_get_total_memory ();
2916 if (pmem > 100)
2917 pmem = 100;
2918 attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs);
2919 }
2920 }
2921 if (fd >= 0)
2922 emacs_close (fd);
2923
2924 /* args */
2925 strcpy (procfn_end, "/cmdline");
2926 fd = emacs_open (fn, O_RDONLY, 0);
2927 if (fd >= 0)
2928 {
2929 char ch;
2930 for (cmdline_size = 0; cmdline_size < STRING_BYTES_BOUND; cmdline_size++)
2931 {
2932 if (emacs_read (fd, &ch, 1) != 1)
2933 break;
2934 c = ch;
2935 if (c_isspace (c) || c == '\\')
2936 cmdline_size++; /* for later quoting, see below */
2937 }
2938 if (cmdline_size)
2939 {
2940 cmdline = xmalloc (cmdline_size + 1);
2941 lseek (fd, 0L, SEEK_SET);
2942 cmdline[0] = '\0';
2943 if ((nread = read (fd, cmdline, cmdline_size)) >= 0)
2944 cmdline[nread++] = '\0';
2945 else
2946 {
2947 /* Assigning zero to `nread' makes us skip the following
2948 two loops, assign zero to cmdline_size, and enter the
2949 following `if' clause that handles unknown command
2950 lines. */
2951 nread = 0;
2952 }
2953 /* We don't want trailing null characters. */
2954 for (p = cmdline + nread; p > cmdline + 1 && !p[-1]; p--)
2955 nread--;
2956 for (p = cmdline; p < cmdline + nread; p++)
2957 {
2958 /* Escape-quote whitespace and backslashes. */
2959 if (c_isspace (*p) || *p == '\\')
2960 {
2961 memmove (p + 1, p, nread - (p - cmdline));
2962 nread++;
2963 *p++ = '\\';
2964 }
2965 else if (*p == '\0')
2966 *p = ' ';
2967 }
2968 cmdline_size = nread;
2969 }
2970 if (!cmdline_size)
2971 {
2972 cmdline_size = cmdsize + 2;
2973 cmdline = xmalloc (cmdline_size + 1);
2974 sprintf (cmdline, "[%.*s]", cmdsize, cmd);
2975 }
2976 emacs_close (fd);
2977 /* Command line is encoded in locale-coding-system; decode it. */
2978 cmd_str = make_unibyte_string (cmdline, cmdline_size);
2979 decoded_cmd = code_convert_string_norecord (cmd_str,
2980 Vlocale_coding_system, 0);
2981 xfree (cmdline);
2982 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
2983 }
2984
2985 UNGCPRO;
2986 return attrs;
2987 }
2988
2989 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
2990
2991 /* The <procfs.h> header does not like to be included if _LP64 is defined and
2992 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
2993 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
2994 #define PROCFS_FILE_OFFSET_BITS_HACK 1
2995 #undef _FILE_OFFSET_BITS
2996 #else
2997 #define PROCFS_FILE_OFFSET_BITS_HACK 0
2998 #endif
2999
3000 #include <procfs.h>
3001
3002 #if PROCFS_FILE_OFFSET_BITS_HACK == 1
3003 #define _FILE_OFFSET_BITS 64
3004 #ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3005 #endif
3006 #endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3007
3008 Lisp_Object
3009 system_process_attributes (Lisp_Object pid)
3010 {
3011 char procfn[PATH_MAX], fn[PATH_MAX];
3012 struct stat st;
3013 struct passwd *pw;
3014 struct group *gr;
3015 char *procfn_end;
3016 struct psinfo pinfo;
3017 int fd;
3018 ssize_t nread;
3019 printmax_t proc_id;
3020 uid_t uid;
3021 gid_t gid;
3022 Lisp_Object attrs = Qnil;
3023 Lisp_Object decoded_cmd, tem;
3024 struct gcpro gcpro1, gcpro2;
3025
3026 CHECK_NUMBER_OR_FLOAT (pid);
3027 CONS_TO_INTEGER (pid, pid_t, proc_id);
3028 sprintf (procfn, "/proc/%"pMd, proc_id);
3029 if (stat (procfn, &st) < 0)
3030 return attrs;
3031
3032 GCPRO2 (attrs, decoded_cmd);
3033
3034 /* euid egid */
3035 uid = st.st_uid;
3036 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid)), attrs);
3037 block_input ();
3038 pw = getpwuid (uid);
3039 unblock_input ();
3040 if (pw)
3041 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
3042
3043 gid = st.st_gid;
3044 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid)), attrs);
3045 block_input ();
3046 gr = getgrgid (gid);
3047 unblock_input ();
3048 if (gr)
3049 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
3050
3051 strcpy (fn, procfn);
3052 procfn_end = fn + strlen (fn);
3053 strcpy (procfn_end, "/psinfo");
3054 fd = emacs_open (fn, O_RDONLY, 0);
3055 if (fd >= 0
3056 && (nread = read (fd, (char*)&pinfo, sizeof (struct psinfo)) > 0))
3057 {
3058 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (pinfo.pr_ppid)), attrs);
3059 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pinfo.pr_pgid)), attrs);
3060 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (pinfo.pr_sid)), attrs);
3061
3062 {
3063 char state_str[2];
3064 state_str[0] = pinfo.pr_lwp.pr_sname;
3065 state_str[1] = '\0';
3066 tem = build_string (state_str);
3067 attrs = Fcons (Fcons (Qstate, tem), attrs);
3068 }
3069
3070 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3071 need to get a string from it. */
3072
3073 /* FIXME: missing: Qtpgid */
3074
3075 /* FIXME: missing:
3076 Qminflt
3077 Qmajflt
3078 Qcminflt
3079 Qcmajflt
3080
3081 Qutime
3082 Qcutime
3083 Qstime
3084 Qcstime
3085 Are they available? */
3086
3087 attrs = Fcons (Fcons (Qtime, make_lisp_time (pinfo.pr_time)), attrs);
3088 attrs = Fcons (Fcons (Qctime, make_lisp_time (pinfo.pr_ctime)), attrs);
3089 attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs);
3090 attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs);
3091 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)), attrs);
3092
3093 attrs = Fcons (Fcons (Qstart, make_lisp_time (pinfo.pr_start)), attrs);
3094 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)), attrs);
3095 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)), attrs);
3096
3097 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3098 range 0 .. 2**15, representing 0.0 .. 1.0. */
3099 attrs = Fcons (Fcons (Qpcpu, make_float (100.0 / 0x8000 * pinfo.pr_pctcpu)), attrs);
3100 attrs = Fcons (Fcons (Qpmem, make_float (100.0 / 0x8000 * pinfo.pr_pctmem)), attrs);
3101
3102 decoded_cmd
3103 = code_convert_string_norecord (make_unibyte_string (pinfo.pr_fname,
3104 strlen (pinfo.pr_fname)),
3105 Vlocale_coding_system, 0);
3106 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
3107 decoded_cmd
3108 = code_convert_string_norecord (make_unibyte_string (pinfo.pr_psargs,
3109 strlen (pinfo.pr_psargs)),
3110 Vlocale_coding_system, 0);
3111 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
3112 }
3113
3114 if (fd >= 0)
3115 emacs_close (fd);
3116
3117 UNGCPRO;
3118 return attrs;
3119 }
3120
3121 #elif defined __FreeBSD__
3122
3123 static EMACS_TIME
3124 timeval_to_EMACS_TIME (struct timeval t)
3125 {
3126 return make_emacs_time (t.tv_sec, t.tv_usec * 1000);
3127 }
3128
3129 static Lisp_Object
3130 make_lisp_timeval (struct timeval t)
3131 {
3132 return make_lisp_time (timeval_to_EMACS_TIME (t));
3133 }
3134
3135 Lisp_Object
3136 system_process_attributes (Lisp_Object pid)
3137 {
3138 int proc_id;
3139 int pagesize = getpagesize ();
3140 int npages;
3141 int fscale;
3142 struct passwd *pw;
3143 struct group *gr;
3144 char *ttyname;
3145 size_t len;
3146 char args[MAXPATHLEN];
3147 EMACS_TIME t, now;
3148
3149 int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID};
3150 struct kinfo_proc proc;
3151 size_t proclen = sizeof proc;
3152
3153 struct gcpro gcpro1, gcpro2;
3154 Lisp_Object attrs = Qnil;
3155 Lisp_Object decoded_comm;
3156
3157 CHECK_NUMBER_OR_FLOAT (pid);
3158 CONS_TO_INTEGER (pid, int, proc_id);
3159 mib[3] = proc_id;
3160
3161 if (sysctl (mib, 4, &proc, &proclen, NULL, 0) != 0)
3162 return attrs;
3163
3164 GCPRO2 (attrs, decoded_comm);
3165
3166 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (proc.ki_uid)), attrs);
3167
3168 block_input ();
3169 pw = getpwuid (proc.ki_uid);
3170 unblock_input ();
3171 if (pw)
3172 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
3173
3174 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (proc.ki_svgid)), attrs);
3175
3176 block_input ();
3177 gr = getgrgid (proc.ki_svgid);
3178 unblock_input ();
3179 if (gr)
3180 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
3181
3182 decoded_comm = code_convert_string_norecord
3183 (make_unibyte_string (proc.ki_comm, strlen (proc.ki_comm)),
3184 Vlocale_coding_system, 0);
3185
3186 attrs = Fcons (Fcons (Qcomm, decoded_comm), attrs);
3187 {
3188 char state[2] = {'\0', '\0'};
3189 switch (proc.ki_stat)
3190 {
3191 case SRUN:
3192 state[0] = 'R';
3193 break;
3194
3195 case SSLEEP:
3196 state[0] = 'S';
3197 break;
3198
3199 case SLOCK:
3200 state[0] = 'D';
3201 break;
3202
3203 case SZOMB:
3204 state[0] = 'Z';
3205 break;
3206
3207 case SSTOP:
3208 state[0] = 'T';
3209 break;
3210 }
3211 attrs = Fcons (Fcons (Qstate, build_string (state)), attrs);
3212 }
3213
3214 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (proc.ki_ppid)), attrs);
3215 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (proc.ki_pgid)), attrs);
3216 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (proc.ki_sid)), attrs);
3217
3218 block_input ();
3219 ttyname = proc.ki_tdev == NODEV ? NULL : devname (proc.ki_tdev, S_IFCHR);
3220 unblock_input ();
3221 if (ttyname)
3222 attrs = Fcons (Fcons (Qtty, build_string (ttyname)), attrs);
3223
3224 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (proc.ki_tpgid)), attrs);
3225 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (proc.ki_rusage.ru_minflt)), attrs);
3226 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (proc.ki_rusage.ru_majflt)), attrs);
3227 attrs = Fcons (Fcons (Qcminflt, make_number (proc.ki_rusage_ch.ru_minflt)), attrs);
3228 attrs = Fcons (Fcons (Qcmajflt, make_number (proc.ki_rusage_ch.ru_majflt)), attrs);
3229
3230 attrs = Fcons (Fcons (Qutime, make_lisp_timeval (proc.ki_rusage.ru_utime)),
3231 attrs);
3232 attrs = Fcons (Fcons (Qstime, make_lisp_timeval (proc.ki_rusage.ru_stime)),
3233 attrs);
3234 t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage.ru_utime),
3235 timeval_to_EMACS_TIME (proc.ki_rusage.ru_stime));
3236 attrs = Fcons (Fcons (Qtime, make_lisp_time (t)), attrs);
3237
3238 attrs = Fcons (Fcons (Qcutime,
3239 make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
3240 attrs);
3241 attrs = Fcons (Fcons (Qcstime,
3242 make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
3243 attrs);
3244 t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_utime),
3245 timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_stime));
3246 attrs = Fcons (Fcons (Qctime, make_lisp_time (t)), attrs);
3247
3248 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (proc.ki_numthreads)),
3249 attrs);
3250 attrs = Fcons (Fcons (Qpri, make_number (proc.ki_pri.pri_native)), attrs);
3251 attrs = Fcons (Fcons (Qnice, make_number (proc.ki_nice)), attrs);
3252 attrs = Fcons (Fcons (Qstart, make_lisp_timeval (proc.ki_start)), attrs);
3253 attrs = Fcons (Fcons (Qvsize, make_number (proc.ki_size >> 10)), attrs);
3254 attrs = Fcons (Fcons (Qrss, make_number (proc.ki_rssize * pagesize >> 10)),
3255 attrs);
3256
3257 now = current_emacs_time ();
3258 t = sub_emacs_time (now, timeval_to_EMACS_TIME (proc.ki_start));
3259 attrs = Fcons (Fcons (Qetime, make_lisp_time (t)), attrs);
3260
3261 len = sizeof fscale;
3262 if (sysctlbyname ("kern.fscale", &fscale, &len, NULL, 0) == 0)
3263 {
3264 double pcpu;
3265 fixpt_t ccpu;
3266 len = sizeof ccpu;
3267 if (sysctlbyname ("kern.ccpu", &ccpu, &len, NULL, 0) == 0)
3268 {
3269 pcpu = (100.0 * proc.ki_pctcpu / fscale
3270 / (1 - exp (proc.ki_swtime * log ((double) ccpu / fscale))));
3271 attrs = Fcons (Fcons (Qpcpu, make_fixnum_or_float (pcpu)), attrs);
3272 }
3273 }
3274
3275 len = sizeof npages;
3276 if (sysctlbyname ("hw.availpages", &npages, &len, NULL, 0) == 0)
3277 {
3278 double pmem = (proc.ki_flag & P_INMEM
3279 ? 100.0 * proc.ki_rssize / npages
3280 : 0);
3281 attrs = Fcons (Fcons (Qpmem, make_fixnum_or_float (pmem)), attrs);
3282 }
3283
3284 mib[2] = KERN_PROC_ARGS;
3285 len = MAXPATHLEN;
3286 if (sysctl (mib, 4, args, &len, NULL, 0) == 0)
3287 {
3288 int i;
3289 for (i = 0; i < len; i++)
3290 {
3291 if (! args[i] && i < len - 1)
3292 args[i] = ' ';
3293 }
3294
3295 decoded_comm =
3296 (code_convert_string_norecord
3297 (build_unibyte_string (args),
3298 Vlocale_coding_system, 0));
3299
3300 attrs = Fcons (Fcons (Qargs, decoded_comm), attrs);
3301 }
3302
3303 UNGCPRO;
3304 return attrs;
3305 }
3306
3307 /* The WINDOWSNT implementation is in w32.c.
3308 The MSDOS implementation is in dosfns.c. */
3309 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3310
3311 Lisp_Object
3312 system_process_attributes (Lisp_Object pid)
3313 {
3314 return Qnil;
3315 }
3316
3317 #endif /* !defined (WINDOWSNT) */
Unnamed repository; edit this file 'description' to name the repository.