1 /* Low level interface to ptrace, for GDB when running under Unix.
2 Copyright (C) 1986-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdbthread.h"
30 #include "gdb_select.h"
35 #ifdef HAVE_SYS_IOCTL_H
36 #include <sys/ioctl.h>
43 extern void _initialize_inflow (void);
45 static void pass_signal (int);
47 static void child_terminal_ours_1 (int);
49 /* Record terminal status separately for debugger and inferior. */
51 static struct serial
*stdin_serial
;
53 /* Terminal related info we need to keep track of. Each inferior
54 holds an instance of this structure --- we save it whenever the
55 corresponding inferior stops, and restore it to the foreground
56 inferior when it resumes. */
59 /* The name of the tty (from the `tty' command) that we gave to the
60 inferior when it was started. */
63 /* TTY state. We save it whenever the inferior stops, and restore
64 it when it resumes. */
65 serial_ttystate ttystate
;
67 #ifdef PROCESS_GROUP_TYPE
68 /* Process group. Saved and restored just like ttystate. */
69 PROCESS_GROUP_TYPE process_group
;
72 /* fcntl flags. Saved and restored just like ttystate. */
76 /* Our own tty state, which we restore every time we need to deal with
77 the terminal. This is only set once, when GDB first starts. The
78 settings of flags which readline saves and restores and
80 static struct terminal_info our_terminal_info
;
82 static struct terminal_info
*get_inflow_inferior_data (struct inferior
*);
84 #ifdef PROCESS_GROUP_TYPE
86 /* Return the process group of the current inferior. */
89 inferior_process_group (void)
91 return get_inflow_inferior_data (current_inferior ())->process_group
;
95 /* While the inferior is running, we want SIGINT and SIGQUIT to go to the
96 inferior only. If we have job control, that takes care of it. If not,
97 we save our handlers in these two variables and set SIGINT and SIGQUIT
100 static void (*sigint_ours
) ();
101 static void (*sigquit_ours
) ();
103 /* The name of the tty (from the `tty' command) that we're giving to
104 the inferior when starting it up. This is only (and should only
105 be) used as a transient global by new_tty_prefork,
106 create_tty_session, new_tty and new_tty_postfork, all called from
107 fork_inferior, while forking a new child. */
108 static const char *inferior_thisrun_terminal
;
110 /* Nonzero if our terminal settings are in effect. Zero if the
111 inferior's settings are in effect. Ignored if !gdb_has_a_terminal
114 int terminal_is_ours
;
116 #ifdef PROCESS_GROUP_TYPE
117 static PROCESS_GROUP_TYPE
120 int process_group
= -1;
123 process_group
= tcgetpgrp (0);
126 process_group
= getpgrp ();
129 ioctl (0, TIOCGPGRP
, &process_group
);
131 return process_group
;
137 yes
, no
, have_not_checked
139 gdb_has_a_terminal_flag
= have_not_checked
;
141 /* The value of the "interactive-mode" setting. */
142 static enum auto_boolean interactive_mode
= AUTO_BOOLEAN_AUTO
;
144 /* Implement the "show interactive-mode" option. */
147 show_interactive_mode (struct ui_file
*file
, int from_tty
,
148 struct cmd_list_element
*c
,
151 if (interactive_mode
== AUTO_BOOLEAN_AUTO
)
152 fprintf_filtered (file
, "Debugger's interactive mode "
153 "is %s (currently %s).\n",
154 value
, gdb_has_a_terminal () ? "on" : "off");
156 fprintf_filtered (file
, "Debugger's interactive mode is %s.\n", value
);
159 /* Does GDB have a terminal (on stdin)? */
161 gdb_has_a_terminal (void)
163 if (interactive_mode
!= AUTO_BOOLEAN_AUTO
)
164 return interactive_mode
== AUTO_BOOLEAN_TRUE
;
166 switch (gdb_has_a_terminal_flag
)
172 case have_not_checked
:
173 /* Get all the current tty settings (including whether we have a
174 tty at all!). Can't do this in _initialize_inflow because
175 serial_fdopen() won't work until the serial_ops_list is
179 our_terminal_info
.tflags
= fcntl (0, F_GETFL
, 0);
182 gdb_has_a_terminal_flag
= no
;
183 if (stdin_serial
!= NULL
)
185 our_terminal_info
.ttystate
= serial_get_tty_state (stdin_serial
);
187 if (our_terminal_info
.ttystate
!= NULL
)
189 gdb_has_a_terminal_flag
= yes
;
190 #ifdef PROCESS_GROUP_TYPE
191 our_terminal_info
.process_group
= gdb_getpgrp ();
196 return gdb_has_a_terminal_flag
== yes
;
198 /* "Can't happen". */
203 /* Macro for printing errors from ioctl operations */
205 #define OOPSY(what) \
207 fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
208 what, safe_strerror (errno))
210 /* Initialize the terminal settings we record for the inferior,
211 before we actually run the inferior. */
214 child_terminal_init_with_pgrp (int pgrp
)
216 struct inferior
*inf
= current_inferior ();
217 struct terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
219 #ifdef PROCESS_GROUP_TYPE
220 /* Store the process group even without a terminal as it is used not
221 only to reset the tty foreground process group, but also to
222 interrupt the inferior. */
223 tinfo
->process_group
= pgrp
;
226 if (gdb_has_a_terminal ())
228 xfree (tinfo
->ttystate
);
229 tinfo
->ttystate
= serial_copy_tty_state (stdin_serial
,
230 our_terminal_info
.ttystate
);
232 /* Make sure that next time we call terminal_inferior (which will be
233 before the program runs, as it needs to be), we install the new
235 terminal_is_ours
= 1;
239 /* Save the terminal settings again. This is necessary for the TUI
240 when it switches to TUI or non-TUI mode; curses changes the terminal
241 and gdb must be able to restore it correctly. */
244 gdb_save_tty_state (void)
246 if (gdb_has_a_terminal ())
248 xfree (our_terminal_info
.ttystate
);
249 our_terminal_info
.ttystate
= serial_get_tty_state (stdin_serial
);
254 child_terminal_init (struct target_ops
*self
)
256 #ifdef PROCESS_GROUP_TYPE
257 /* This is for Lynx, and should be cleaned up by having Lynx be a
258 separate debugging target with a version of target_terminal_init
259 which passes in the process group to a generic routine which does
260 all the work (and the non-threaded child_terminal_init can just
261 pass in inferior_ptid to the same routine). */
262 /* We assume INFERIOR_PID is also the child's process group. */
263 child_terminal_init_with_pgrp (ptid_get_pid (inferior_ptid
));
264 #endif /* PROCESS_GROUP_TYPE */
267 /* Put the inferior's terminal settings into effect.
268 This is preparation for starting or resuming the inferior.
270 N.B. Targets that want to use this with async support must build that
271 support on top of this (e.g., the caller still needs to remove stdin
272 from the event loop). E.g., see linux_nat_terminal_inferior. */
275 child_terminal_inferior (struct target_ops
*self
)
277 struct inferior
*inf
;
278 struct terminal_info
*tinfo
;
280 if (!terminal_is_ours
)
283 inf
= current_inferior ();
284 tinfo
= get_inflow_inferior_data (inf
);
286 if (gdb_has_a_terminal ()
287 && tinfo
->ttystate
!= NULL
288 && tinfo
->run_terminal
== NULL
)
293 /* Is there a reason this is being done twice? It happens both
294 places we use F_SETFL, so I'm inclined to think perhaps there
295 is some reason, however perverse. Perhaps not though... */
296 result
= fcntl (0, F_SETFL
, tinfo
->tflags
);
297 result
= fcntl (0, F_SETFL
, tinfo
->tflags
);
298 OOPSY ("fcntl F_SETFL");
301 /* Because we were careful to not change in or out of raw mode in
302 terminal_ours, we will not change in our out of raw mode with
303 this call, so we don't flush any input. */
304 result
= serial_set_tty_state (stdin_serial
,
306 OOPSY ("setting tty state");
310 sigint_ours
= (void (*)()) signal (SIGINT
, SIG_IGN
);
312 sigquit_ours
= (void (*)()) signal (SIGQUIT
, SIG_IGN
);
316 /* If attach_flag is set, we don't know whether we are sharing a
317 terminal with the inferior or not. (attaching a process
318 without a terminal is one case where we do not; attaching a
319 process which we ran from the same shell as GDB via `&' is
320 one case where we do, I think (but perhaps this is not
321 `sharing' in the sense that we need to save and restore tty
322 state)). I don't know if there is any way to tell whether we
323 are sharing a terminal. So what we do is to go through all
324 the saving and restoring of the tty state, but ignore errors
325 setting the process group, which will happen if we are not
326 sharing a terminal). */
331 result
= tcsetpgrp (0, tinfo
->process_group
);
332 if (!inf
->attach_flag
)
337 result
= ioctl (0, TIOCSPGRP
, &tinfo
->process_group
);
338 if (!inf
->attach_flag
)
344 terminal_is_ours
= 0;
347 /* Put some of our terminal settings into effect,
348 enough to get proper results from our output,
349 but do not change into or out of RAW mode
350 so that no input is discarded.
352 After doing this, either terminal_ours or terminal_inferior
353 should be called to get back to a normal state of affairs.
355 N.B. The implementation is (currently) no different than
356 child_terminal_ours. See child_terminal_ours_1. */
359 child_terminal_ours_for_output (struct target_ops
*self
)
361 child_terminal_ours_1 (1);
364 /* Put our terminal settings into effect.
365 First record the inferior's terminal settings
366 so they can be restored properly later.
368 N.B. Targets that want to use this with async support must build that
369 support on top of this (e.g., the caller still needs to add stdin to the
370 event loop). E.g., see linux_nat_terminal_ours. */
373 child_terminal_ours (struct target_ops
*self
)
375 child_terminal_ours_1 (0);
378 /* output_only is not used, and should not be used unless we introduce
379 separate terminal_is_ours and terminal_is_ours_for_output
383 child_terminal_ours_1 (int output_only
)
385 struct inferior
*inf
;
386 struct terminal_info
*tinfo
;
388 if (terminal_is_ours
)
391 terminal_is_ours
= 1;
393 /* Checking inferior->run_terminal is necessary so that
394 if GDB is running in the background, it won't block trying
395 to do the ioctl()'s below. Checking gdb_has_a_terminal
396 avoids attempting all the ioctl's when running in batch. */
398 inf
= current_inferior ();
399 tinfo
= get_inflow_inferior_data (inf
);
401 if (tinfo
->run_terminal
!= NULL
|| gdb_has_a_terminal () == 0)
406 /* Ignore this signal since it will happen when we try to set the
408 void (*osigttou
) () = NULL
;
414 osigttou
= (void (*)()) signal (SIGTTOU
, SIG_IGN
);
417 xfree (tinfo
->ttystate
);
418 tinfo
->ttystate
= serial_get_tty_state (stdin_serial
);
420 #ifdef PROCESS_GROUP_TYPE
421 if (!inf
->attach_flag
)
422 /* If setpgrp failed in terminal_inferior, this would give us
423 our process group instead of the inferior's. See
424 terminal_inferior for details. */
425 tinfo
->process_group
= gdb_getpgrp ();
428 /* Here we used to set ICANON in our ttystate, but I believe this
429 was an artifact from before when we used readline. Readline sets
430 the tty state when it needs to.
431 FIXME-maybe: However, query() expects non-raw mode and doesn't
432 use readline. Maybe query should use readline (on the other hand,
433 this only matters for HAVE_SGTTY, not termio or termios, I think). */
435 /* Set tty state to our_ttystate. We don't change in our out of raw
436 mode, to avoid flushing input. We need to do the same thing
437 regardless of output_only, because we don't have separate
438 terminal_is_ours and terminal_is_ours_for_output flags. It's OK,
439 though, since readline will deal with raw mode when/if it needs
442 serial_noflush_set_tty_state (stdin_serial
, our_terminal_info
.ttystate
,
448 result
= tcsetpgrp (0, our_terminal_info
.process_group
);
450 /* This fails on Ultrix with EINVAL if you run the testsuite
451 in the background with nohup, and then log out. GDB never
452 used to check for an error here, so perhaps there are other
453 such situations as well. */
455 fprintf_unfiltered (gdb_stderr
,
456 "[tcsetpgrp failed in child_terminal_ours: %s]\n",
457 safe_strerror (errno
));
462 result
= ioctl (0, TIOCSPGRP
, &our_terminal_info
.process_group
);
468 signal (SIGTTOU
, osigttou
);
473 signal (SIGINT
, sigint_ours
);
475 signal (SIGQUIT
, sigquit_ours
);
480 tinfo
->tflags
= fcntl (0, F_GETFL
, 0);
482 /* Is there a reason this is being done twice? It happens both
483 places we use F_SETFL, so I'm inclined to think perhaps there
484 is some reason, however perverse. Perhaps not though... */
485 result
= fcntl (0, F_SETFL
, our_terminal_info
.tflags
);
486 result
= fcntl (0, F_SETFL
, our_terminal_info
.tflags
);
491 /* Per-inferior data key. */
492 static const struct inferior_data
*inflow_inferior_data
;
495 inflow_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
497 struct terminal_info
*info
= arg
;
499 xfree (info
->run_terminal
);
500 xfree (info
->ttystate
);
504 /* Get the current svr4 data. If none is found yet, add it now. This
505 function always returns a valid object. */
507 static struct terminal_info
*
508 get_inflow_inferior_data (struct inferior
*inf
)
510 struct terminal_info
*info
;
512 info
= inferior_data (inf
, inflow_inferior_data
);
515 info
= XCNEW (struct terminal_info
);
516 set_inferior_data (inf
, inflow_inferior_data
, info
);
522 /* This is a "inferior_exit" observer. Releases the TERMINAL_INFO member
523 of the inferior structure. This field is private to inflow.c, and
524 its type is opaque to the rest of GDB. PID is the target pid of
525 the inferior that is about to be removed from the inferior
529 inflow_inferior_exit (struct inferior
*inf
)
531 struct terminal_info
*info
;
533 info
= inferior_data (inf
, inflow_inferior_data
);
536 xfree (info
->run_terminal
);
537 xfree (info
->ttystate
);
539 set_inferior_data (inf
, inflow_inferior_data
, NULL
);
544 copy_terminal_info (struct inferior
*to
, struct inferior
*from
)
546 struct terminal_info
*tinfo_to
, *tinfo_from
;
548 tinfo_to
= get_inflow_inferior_data (to
);
549 tinfo_from
= get_inflow_inferior_data (from
);
551 xfree (tinfo_to
->run_terminal
);
552 xfree (tinfo_to
->ttystate
);
554 *tinfo_to
= *tinfo_from
;
556 if (tinfo_from
->run_terminal
)
557 tinfo_to
->run_terminal
558 = xstrdup (tinfo_from
->run_terminal
);
560 if (tinfo_from
->ttystate
)
562 = serial_copy_tty_state (stdin_serial
, tinfo_from
->ttystate
);
566 term_info (char *arg
, int from_tty
)
568 target_terminal_info (arg
, from_tty
);
572 child_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
574 struct inferior
*inf
;
575 struct terminal_info
*tinfo
;
577 if (!gdb_has_a_terminal ())
579 printf_filtered (_("This GDB does not control a terminal.\n"));
583 if (ptid_equal (inferior_ptid
, null_ptid
))
586 inf
= current_inferior ();
587 tinfo
= get_inflow_inferior_data (inf
);
589 printf_filtered (_("Inferior's terminal status "
590 "(currently saved by GDB):\n"));
592 /* First the fcntl flags. */
596 flags
= tinfo
->tflags
;
598 printf_filtered ("File descriptor flags = ");
601 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
603 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
604 switch (flags
& (O_ACCMODE
))
607 printf_filtered ("O_RDONLY");
610 printf_filtered ("O_WRONLY");
613 printf_filtered ("O_RDWR");
616 flags
&= ~(O_ACCMODE
);
619 if (flags
& O_NONBLOCK
)
620 printf_filtered (" | O_NONBLOCK");
621 flags
&= ~O_NONBLOCK
;
624 #if defined (O_NDELAY)
625 /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
626 print it as O_NONBLOCK, which is good cause that is what POSIX
627 has, and the flag will already be cleared by the time we get here. */
628 if (flags
& O_NDELAY
)
629 printf_filtered (" | O_NDELAY");
633 if (flags
& O_APPEND
)
634 printf_filtered (" | O_APPEND");
637 #if defined (O_BINARY)
638 if (flags
& O_BINARY
)
639 printf_filtered (" | O_BINARY");
644 printf_filtered (" | 0x%x", flags
);
645 printf_filtered ("\n");
648 #ifdef PROCESS_GROUP_TYPE
649 printf_filtered ("Process group = %d\n", (int) tinfo
->process_group
);
652 serial_print_tty_state (stdin_serial
, tinfo
->ttystate
, gdb_stdout
);
655 /* NEW_TTY_PREFORK is called before forking a new child process,
656 so we can record the state of ttys in the child to be formed.
657 TTYNAME is null if we are to share the terminal with gdb;
658 or points to a string containing the name of the desired tty.
660 NEW_TTY is called in new child processes under Unix, which will
661 become debugger target processes. This actually switches to
662 the terminal specified in the NEW_TTY_PREFORK call. */
665 new_tty_prefork (const char *ttyname
)
667 /* Save the name for later, for determining whether we and the child
668 are sharing a tty. */
669 inferior_thisrun_terminal
= ttyname
;
672 #if !defined(__GO32__) && !defined(_WIN32)
673 /* If RESULT, assumed to be the return value from a system call, is
674 negative, print the error message indicated by errno and exit.
675 MSG should identify the operation that failed. */
677 check_syscall (const char *msg
, int result
)
681 print_sys_errmsg (msg
, errno
);
692 if (inferior_thisrun_terminal
== 0)
694 #if !defined(__GO32__) && !defined(_WIN32)
696 /* Disconnect the child process from our controlling terminal. On some
697 systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
699 tty
= open ("/dev/tty", O_RDWR
);
704 osigttou
= (void (*)()) signal (SIGTTOU
, SIG_IGN
);
705 ioctl (tty
, TIOCNOTTY
, 0);
707 signal (SIGTTOU
, osigttou
);
711 /* Now open the specified new terminal. */
712 tty
= open (inferior_thisrun_terminal
, O_RDWR
| O_NOCTTY
);
713 check_syscall (inferior_thisrun_terminal
, tty
);
715 /* Avoid use of dup2; doesn't exist on all systems. */
719 check_syscall ("dup'ing tty into fd 0", dup (tty
));
724 check_syscall ("dup'ing tty into fd 1", dup (tty
));
729 check_syscall ("dup'ing tty into fd 2", dup (tty
));
733 /* Make tty our new controlling terminal. */
734 if (ioctl (tty
, TIOCSCTTY
, 0) == -1)
735 /* Mention GDB in warning because it will appear in the inferior's
736 terminal instead of GDB's. */
737 warning (_("GDB: Failed to set controlling terminal: %s"),
738 safe_strerror (errno
));
743 #endif /* !go32 && !win32 */
746 /* NEW_TTY_POSTFORK is called after forking a new child process, and
747 adding it to the inferior table, to store the TTYNAME being used by
748 the child, or null if it sharing the terminal with gdb. */
751 new_tty_postfork (void)
753 /* Save the name for later, for determining whether we and the child
754 are sharing a tty. */
756 if (inferior_thisrun_terminal
)
758 struct inferior
*inf
= current_inferior ();
759 struct terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
761 tinfo
->run_terminal
= xstrdup (inferior_thisrun_terminal
);
764 inferior_thisrun_terminal
= NULL
;
768 /* Call set_sigint_trap when you need to pass a signal on to an attached
769 process when handling SIGINT. */
772 pass_signal (int signo
)
775 kill (ptid_get_pid (inferior_ptid
), SIGINT
);
779 static void (*osig
) ();
783 set_sigint_trap (void)
785 struct inferior
*inf
= current_inferior ();
786 struct terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
788 if (inf
->attach_flag
|| tinfo
->run_terminal
)
790 osig
= (void (*)()) signal (SIGINT
, pass_signal
);
798 clear_sigint_trap (void)
802 signal (SIGINT
, osig
);
808 /* Create a new session if the inferior will run in a different tty.
809 A session is UNIX's way of grouping processes that share a controlling
810 terminal, so a new one is needed if the inferior terminal will be
811 different from GDB's.
813 Returns the session id of the new session, 0 if no session was created
814 or -1 if an error occurred. */
816 create_tty_session (void)
821 if (!job_control
|| inferior_thisrun_terminal
== 0)
826 warning (_("Failed to create new terminal session: setsid: %s"),
827 safe_strerror (errno
));
832 #endif /* HAVE_SETSID */
835 /* This is here because this is where we figure out whether we (probably)
836 have job control. Just using job_control only does part of it because
837 setpgid or setpgrp might not exist on a system without job control.
838 It might be considered misplaced (on the other hand, process groups and
839 job control are closely related to ttys).
841 For a more clean implementation, in libiberty, put a setpgid which merely
842 calls setpgrp and a setpgrp which does nothing (any system with job control
843 will have one or the other). */
851 #if defined (HAVE_TERMIOS) || defined (TIOCGPGRP)
853 /* The call setpgid (0, 0) is supposed to work and mean the same
854 thing as this, but on Ultrix 4.2A it fails with EPERM (and
855 setpgid (getpid (), getpid ()) succeeds). */
856 retval
= setpgid (getpid (), getpid ());
862 retval
= setpgrp (getpid (), getpid ());
864 #endif /* HAVE_SETPGRP */
865 #endif /* HAVE_SETPGID */
866 #endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */
872 /* Get all the current tty settings (including whether we have a
873 tty at all!). We can't do this in _initialize_inflow because
874 serial_fdopen() won't work until the serial_ops_list is
875 initialized, but we don't want to do it lazily either, so
876 that we can guarantee stdin_serial is opened if there is
879 initialize_stdin_serial (void)
881 stdin_serial
= serial_fdopen (0);
885 _initialize_inflow (void)
887 add_info ("terminal", term_info
,
888 _("Print inferior's saved terminal status."));
890 add_setshow_auto_boolean_cmd ("interactive-mode", class_support
,
891 &interactive_mode
, _("\
892 Set whether GDB's standard input is a terminal."), _("\
893 Show whether GDB's standard input is a terminal."), _("\
894 If on, GDB assumes that standard input is a terminal. In practice, it\n\
895 means that GDB should wait for the user to answer queries associated to\n\
896 commands entered at the command prompt. If off, GDB assumes that standard\n\
897 input is not a terminal, and uses the default answer to all queries.\n\
898 If auto (the default), determine which mode to use based on the standard\n\
901 show_interactive_mode
,
902 &setlist
, &showlist
);
904 terminal_is_ours
= 1;
906 /* OK, figure out whether we have job control. If neither termios nor
907 sgtty (i.e. termio or go32), leave job_control 0. */
909 #if defined (HAVE_TERMIOS)
910 /* Do all systems with termios have the POSIX way of identifying job
911 control? I hope so. */
912 #ifdef _POSIX_JOB_CONTROL
915 #ifdef _SC_JOB_CONTROL
916 job_control
= sysconf (_SC_JOB_CONTROL
);
918 job_control
= 0; /* Have to assume the worst. */
919 #endif /* _SC_JOB_CONTROL */
920 #endif /* _POSIX_JOB_CONTROL */
921 #endif /* HAVE_TERMIOS */
928 #endif /* TIOCGPGRP */
931 observer_attach_inferior_exit (inflow_inferior_exit
);
934 = register_inferior_data_with_cleanup (NULL
, inflow_inferior_data_cleanup
);