Patchwork [2/3] Pass inferior down to target_detach and to_detach

login
register
mail settings
Submitter Simon Marchi
Date Dec. 31, 2017, 5:50 a.m.
Message ID <1514699454-18587-2-git-send-email-simon.marchi@ericsson.com>
Download mbox | patch
Permalink /patch/25159/
State New
Headers show

Comments

Simon Marchi - Dec. 31, 2017, 5:50 a.m.
The to_detach target_ops method implementations are currently expected
to work on current_inferior/inferior_ptid.  In order to make things more
explicit, and remove some "shadow" parameter passing through globals,
this patch adds an "inferior" parameter to to_detach.  Implementations
will be expected to use this instead of relying on the global.  However,
to keep things simple, this patch only does the minimum that is
necessary to add the parameter.  The following patch gives an example of
how one such implementation would be adapted.  If the approach is deemed
good, we can then look into adapting more implementations.  Until then,
they'll continue to work as they do currently.

gdb/ChangeLog:

	* target.h (struct target_ops) <to_detach>: Add inferior
	parameter.
	(target_detach): Likewise.
	* target.c (dispose_inferior): Pass inferior down.
	(target_detach): Likewise.
	* aix-thread.c (aix_thread_detach): Likewise.
	* corefile.c (core_file_command): Pass current_inferior() down.
	* corelow.c (core_detach): Add inferior parameter.
	* darwin-nat.c (darwin_detach): Likewise.
	* gnu-nat.c (gnu_detach): Likewise.
	* inf-ptrace.c (inf_ptrace_detach): Likewise.
	* infcmd.c (detach_command): Pass current_inferior() down to
	target_detach.
	* infrun.c (follow_fork_inferior): Pass parent_inf to
	target_detach.
	(handle_vfork_child_exec_or_exit): Pass inf->vfork_parent to
	target_detach.
	* linux-nat.c (linux_nat_detach): Add inferior parameter.
	* linux-thread-db.c (thread_db_detach): Likewise.
	* nto-procfs.c (procfs_detach): Likewise.
	* procfs.c (procfs_detach): Likewise.
	* record.c (record_detach): Likewise.
	* record.h (struct inferior): Forward-declare.
	(record_detach): Add inferior parameter.
	* remote-sim.c (gdbsim_detach): Likewise.
	* remote.c (remote_detach_1): Likewise.
	(remote_detach): Likewise.
	(extended_remote_detach): Likewise.
	* sol-thread.c (sol_thread_detach): Likewise.
	* target-debug.h (target_debug_print_inferior_p): New macro.
	* target-delegates.c: Re-generate.
	* top.c (kill_or_detach): Pass inferior down to target_detach.
	* windows-nat.c (windows_detach): Add inferior parameter.
---
 gdb/aix-thread.c       |  4 ++--
 gdb/corefile.c         |  2 +-
 gdb/corelow.c          |  2 +-
 gdb/darwin-nat.c       |  3 +--
 gdb/gnu-nat.c          |  2 +-
 gdb/inf-ptrace.c       |  2 +-
 gdb/infcmd.c           |  2 +-
 gdb/infrun.c           |  4 ++--
 gdb/linux-nat.c        |  2 +-
 gdb/linux-thread-db.c  |  4 ++--
 gdb/nto-procfs.c       |  2 +-
 gdb/procfs.c           |  2 +-
 gdb/record.c           |  4 ++--
 gdb/record.h           |  3 ++-
 gdb/remote-sim.c       |  4 ++--
 gdb/remote.c           | 10 +++++-----
 gdb/sol-thread.c       |  4 ++--
 gdb/target-debug.h     |  2 ++
 gdb/target-delegates.c | 14 ++++++++------
 gdb/target.c           |  6 +++---
 gdb/target.h           |  4 ++--
 gdb/top.c              |  2 +-
 gdb/windows-nat.c      |  2 +-
 23 files changed, 45 insertions(+), 41 deletions(-)
Pedro Alves - Jan. 18, 2018, 4:41 p.m.
On 12/31/2017 05:50 AM, Simon Marchi wrote:
> The to_detach target_ops method implementations are currently expected
> to work on current_inferior/inferior_ptid.  In order to make things more
> explicit, and remove some "shadow" parameter passing through globals,
> this patch adds an "inferior" parameter to to_detach.  Implementations
> will be expected to use this instead of relying on the global.  However,
> to keep things simple, this patch only does the minimum that is
> necessary to add the parameter.  The following patch gives an example of
> how one such implementation would be adapted.  If the approach is deemed
> good, we can then look into adapting more implementations.  Until then,
> they'll continue to work as they do currently.

On the multi-target work/branch, I ended up hanging the current
target stack to the current inferior.  Which means that in practice
we have to switch the current inferior/thread before calling any target
method.  I can't see any other practical way.  I've pondered making
every target method take an inferior or some kind of "execution
context" object as parameter, but that's a massive undertaking.
The result is still better for relying more on thread pointers
instead of inferior_ptid / ptid_t, though, IMO.

Note that in practice, even with your patch (in master) we still have
to switch the current inferior before calling target_detach anyway,
for making sure things like the current program space is set correctly,
target_gdbarch(), target description, removing breakpoints, accessing memory,
registers, etc., like here:

>        /* Note that the detach above makes PARENT_INF dangling.  */
> @@ -976,7 +976,7 @@ handle_vfork_child_exec_or_exit (int exec)
>  		}
>  	    }
>  
> -	  target_detach (0);
> +	  target_detach (inf->vfork_parent, 0);

... this still relies on the switch_to_thread call a bit above.

Or look at the prepare_to_detach call in target_detach.

All that said, I'm totally fine with incremental progress.  Actually,
it's probably the only way to go!

So I'm fine with the patch, though, I think we should add a
temporary assertion in target_detach, like:

  gdb_assert (inf == current_inferior ());

until everything beneath either uses an explicit inferior,
or switches the current inferior temporarily.

Thanks,
Pedro Alves
Simon Marchi - Jan. 19, 2018, 3:17 a.m.
On 2018-01-18 11:41, Pedro Alves wrote:
> On 12/31/2017 05:50 AM, Simon Marchi wrote:
>> The to_detach target_ops method implementations are currently expected
>> to work on current_inferior/inferior_ptid.  In order to make things 
>> more
>> explicit, and remove some "shadow" parameter passing through globals,
>> this patch adds an "inferior" parameter to to_detach.  Implementations
>> will be expected to use this instead of relying on the global.  
>> However,
>> to keep things simple, this patch only does the minimum that is
>> necessary to add the parameter.  The following patch gives an example 
>> of
>> how one such implementation would be adapted.  If the approach is 
>> deemed
>> good, we can then look into adapting more implementations.  Until 
>> then,
>> they'll continue to work as they do currently.
> 
> On the multi-target work/branch, I ended up hanging the current
> target stack to the current inferior.  Which means that in practice
> we have to switch the current inferior/thread before calling any target
> method.  I can't see any other practical way.  I've pondered making
> every target method take an inferior or some kind of "execution
> context" object as parameter, but that's a massive undertaking.
> The result is still better for relying more on thread pointers
> instead of inferior_ptid / ptid_t, though, IMO.

Ok.

> Note that in practice, even with your patch (in master) we still have
> to switch the current inferior before calling target_detach anyway,
> for making sure things like the current program space is set correctly,
> target_gdbarch(), target description, removing breakpoints, accessing 
> memory,
> registers, etc., like here:
> 
>>        /* Note that the detach above makes PARENT_INF dangling.  */
>> @@ -976,7 +976,7 @@ handle_vfork_child_exec_or_exit (int exec)
>>  		}
>>  	    }
>> 
>> -	  target_detach (0);
>> +	  target_detach (inf->vfork_parent, 0);
> 
> ... this still relies on the switch_to_thread call a bit above.
> 
> Or look at the prepare_to_detach call in target_detach.
> 
> All that said, I'm totally fine with incremental progress.  Actually,
> it's probably the only way to go!

Yes this is the idea.  The ramifications go very deep, so it's hard to 
know what still relies on the current inferior being set.  This is just 
one step in the right direction, and it's easier to take smaller steps.

> So I'm fine with the patch, though, I think we should add a
> temporary assertion in target_detach, like:
> 
>   gdb_assert (inf == current_inferior ());
> 
> until everything beneath either uses an explicit inferior,
> or switches the current inferior temporarily.

That's a good idea, this way it will also check if I passed the wrong 
thing to target_detach.

Simon

Patch

diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index adb3a83..242df11 100644
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -981,12 +981,12 @@  aix_thread_inferior_created (struct target_ops *ops, int from_tty)
 /* Detach from the process attached to by aix_thread_attach().  */
 
 static void
-aix_thread_detach (struct target_ops *ops, int from_tty)
+aix_thread_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   struct target_ops *beneath = find_target_beneath (ops);
 
   pd_disable ();
-  beneath->to_detach (beneath, from_tty);
+  beneath->to_detach (beneath, inf, from_tty);
 }
 
 /* Tell the inferior process to continue running thread PID if != -1
diff --git a/gdb/corefile.c b/gdb/corefile.c
index 434c64a..c4e0bad 100644
--- a/gdb/corefile.c
+++ b/gdb/corefile.c
@@ -68,7 +68,7 @@  core_file_command (const char *filename, int from_tty)
   gdb_assert (core_target != NULL);
 
   if (!filename)
-    (core_target->to_detach) (core_target, from_tty);
+    (core_target->to_detach) (core_target, current_inferior (), from_tty);
   else
     (core_target->to_open) (filename, from_tty);
 }
diff --git a/gdb/corelow.c b/gdb/corelow.c
index 2894c96..0f7da4b 100644
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -464,7 +464,7 @@  core_open (const char *arg, int from_tty)
 }
 
 static void
-core_detach (struct target_ops *ops, int from_tty)
+core_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   unpush_target (ops);
   reinit_frame_cache ();
diff --git a/gdb/darwin-nat.c b/gdb/darwin-nat.c
index 1b64536..cf02bad 100644
--- a/gdb/darwin-nat.c
+++ b/gdb/darwin-nat.c
@@ -1938,10 +1938,9 @@  darwin_attach (struct target_ops *ops, const char *args, int from_tty)
    previously attached.  It *might* work if the program was
    started via fork.  */
 static void
-darwin_detach (struct target_ops *ops, int from_tty)
+darwin_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   pid_t pid = ptid_get_pid (inferior_ptid);
-  struct inferior *inf = current_inferior ();
   darwin_inferior *priv = get_darwin_inferior (inf);
   kern_return_t kret;
   int res;
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index caa8c3d..db79bab 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -2253,7 +2253,7 @@  gnu_attach (struct target_ops *ops, const char *args, int from_tty)
    previously attached.  It *might* work if the program was
    started via fork.  */
 static void
-gnu_detach (struct target_ops *ops, int from_tty)
+gnu_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   int pid;
 
diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c
index 8633108..766a660 100644
--- a/gdb/inf-ptrace.c
+++ b/gdb/inf-ptrace.c
@@ -244,7 +244,7 @@  inf_ptrace_post_attach (struct target_ops *self, int pid)
 /* Detach from the inferior.  If FROM_TTY is non-zero, be chatty about it.  */
 
 static void
-inf_ptrace_detach (struct target_ops *ops, int from_tty)
+inf_ptrace_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   pid_t pid = ptid_get_pid (inferior_ptid);
 
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 3aa2ced..e5bceb4 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -2976,7 +2976,7 @@  detach_command (const char *args, int from_tty)
 
   disconnect_tracing ();
 
-  target_detach (from_tty);
+  target_detach (current_inferior (), from_tty);
 
   /* The current inferior process was just detached successfully.  Get
      rid of breakpoints that no longer make sense.  Note we don't do
diff --git a/gdb/infrun.c b/gdb/infrun.c
index c4d168c..7d71ad5 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -606,7 +606,7 @@  holding the child stopped.  Try \"set detach-on-fork\" or \
 				target_pid_to_str (process_ptid));
 	    }
 
-	  target_detach (0);
+	  target_detach (parent_inf, 0);
 	}
 
       /* Note that the detach above makes PARENT_INF dangling.  */
@@ -976,7 +976,7 @@  handle_vfork_child_exec_or_exit (int exec)
 		}
 	    }
 
-	  target_detach (0);
+	  target_detach (inf->vfork_parent, 0);
 
 	  /* Put it back.  */
 	  inf->pspace = pspace;
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 3290ed5..9a54397 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -1507,7 +1507,7 @@  detach_callback (struct lwp_info *lp, void *data)
 }
 
 static void
-linux_nat_detach (struct target_ops *ops, int from_tty)
+linux_nat_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   int pid;
   struct lwp_info *main_lwp;
diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c
index ed41640..ddb010e 100644
--- a/gdb/linux-thread-db.c
+++ b/gdb/linux-thread-db.c
@@ -1090,13 +1090,13 @@  record_thread (struct thread_db_info *info,
 }
 
 static void
-thread_db_detach (struct target_ops *ops, int from_tty)
+thread_db_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   struct target_ops *target_beneath = find_target_beneath (ops);
 
   delete_thread_db_info (ptid_get_pid (inferior_ptid));
 
-  target_beneath->to_detach (target_beneath, from_tty);
+  target_beneath->to_detach (target_beneath, inf, from_tty);
 
   /* NOTE: From this point on, inferior_ptid is null_ptid.  */
 
diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c
index 5094eb4..a56a7ce 100644
--- a/gdb/nto-procfs.c
+++ b/gdb/nto-procfs.c
@@ -943,7 +943,7 @@  procfs_xfer_partial (struct target_ops *ops, enum target_object object,
    on signals, etc.  We'd better not have left any breakpoints
    in the program or it'll die when it hits one.  */
 static void
-procfs_detach (struct target_ops *ops, int from_tty)
+procfs_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   int pid;
 
diff --git a/gdb/procfs.c b/gdb/procfs.c
index f6f9ab0..cc8dce4 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -1924,7 +1924,7 @@  procfs_attach (struct target_ops *ops, const char *args, int from_tty)
 }
 
 static void
-procfs_detach (struct target_ops *ops, int from_tty)
+procfs_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   int pid = ptid_get_pid (inferior_ptid);
 
diff --git a/gdb/record.c b/gdb/record.c
index 6e1af91..fad28cd 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -187,7 +187,7 @@  record_disconnect (struct target_ops *t, const char *args, int from_tty)
 /* See record.h.  */
 
 void
-record_detach (struct target_ops *t, int from_tty)
+record_detach (struct target_ops *t, inferior *inf, int from_tty)
 {
   gdb_assert (t->to_stratum == record_stratum);
 
@@ -196,7 +196,7 @@  record_detach (struct target_ops *t, int from_tty)
   record_stop (t);
   record_unpush (t);
 
-  target_detach (from_tty);
+  target_detach (inf, from_tty);
 }
 
 /* See record.h.  */
diff --git a/gdb/record.h b/gdb/record.h
index bee1142..3f6583d 100644
--- a/gdb/record.h
+++ b/gdb/record.h
@@ -24,6 +24,7 @@ 
 #include "common/enum-flags.h"
 
 struct cmd_list_element;
+struct inferior;
 
 extern unsigned int record_debug;
 
@@ -88,7 +89,7 @@  extern void record_goto (const char *arg);
 extern void record_disconnect (struct target_ops *, const char *, int);
 
 /* The default "to_detach" target method for record targets.  */
-extern void record_detach (struct target_ops *, int);
+extern void record_detach (struct target_ops *, inferior *, int);
 
 /* The default "to_mourn_inferior" target method for record targets.  */
 extern void record_mourn_inferior (struct target_ops *);
diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index 8eaadcb..7e586fa 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -77,7 +77,7 @@  static void gdbsim_open (const char *args, int from_tty);
 
 static void gdbsim_close (struct target_ops *self);
 
-static void gdbsim_detach (struct target_ops *ops, int from_tty);
+static void gdbsim_detach (struct target_ops *ops, inferior *inf, int from_tty);
 
 static void gdbsim_prepare_to_store (struct target_ops *self,
 				     struct regcache *regcache);
@@ -820,7 +820,7 @@  gdbsim_close (struct target_ops *self)
    Use this when you want to detach and do something else with your gdb.  */
 
 static void
-gdbsim_detach (struct target_ops *ops, int from_tty)
+gdbsim_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "gdbsim_detach\n");
diff --git a/gdb/remote.c b/gdb/remote.c
index 3fcd279..90eabd8 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -5125,7 +5125,7 @@  remote_detach_pid (int pid)
    one.  */
 
 static void
-remote_detach_1 (int from_tty)
+remote_detach_1 (int from_tty, inferior *inf)
 {
   int pid = ptid_get_pid (inferior_ptid);
   struct remote_state *rs = get_remote_state ();
@@ -5161,15 +5161,15 @@  remote_detach_1 (int from_tty)
 }
 
 static void
-remote_detach (struct target_ops *ops, int from_tty)
+remote_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
-  remote_detach_1 (from_tty);
+  remote_detach_1 (from_tty, inf);
 }
 
 static void
-extended_remote_detach (struct target_ops *ops, int from_tty)
+extended_remote_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
-  remote_detach_1 (from_tty);
+  remote_detach_1 (from_tty, inf);
 }
 
 /* Target follow-fork function for remote targets.  On entry, and
diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index 4765ff3..acf0da2 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -348,14 +348,14 @@  lwp_to_thread (ptid_t lwp)
    program was started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
-sol_thread_detach (struct target_ops *ops, int from_tty)
+sol_thread_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   struct target_ops *beneath = find_target_beneath (ops);
 
   sol_thread_active = 0;
   inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
   unpush_target (ops);
-  beneath->to_detach (beneath, from_tty);
+  beneath->to_detach (beneath, inf, from_tty);
 }
 
 /* Resume execution of process PTID.  If STEP is nozero, then just
diff --git a/gdb/target-debug.h b/gdb/target-debug.h
index 27e5a55..d8d2c48 100644
--- a/gdb/target-debug.h
+++ b/gdb/target-debug.h
@@ -170,6 +170,8 @@ 
   target_debug_do_print (host_address_to_string (X.get ()))
 #define target_debug_print_gdb_array_view_const_int(X)	\
   target_debug_do_print (host_address_to_string (X.data ()))
+#define target_debug_print_inferior_p(inf) \
+  target_debug_do_print (host_address_to_string (inf))
 
 static void
 target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 6bb7d7f..bc84791 100644
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -28,26 +28,28 @@  debug_post_attach (struct target_ops *self, int arg1)
 }
 
 static void
-delegate_detach (struct target_ops *self, int arg1)
+delegate_detach (struct target_ops *self, inferior *arg1, int arg2)
 {
   self = self->beneath;
-  self->to_detach (self, arg1);
+  self->to_detach (self, arg1, arg2);
 }
 
 static void
-tdefault_detach (struct target_ops *self, int arg1)
+tdefault_detach (struct target_ops *self, inferior *arg1, int arg2)
 {
 }
 
 static void
-debug_detach (struct target_ops *self, int arg1)
+debug_detach (struct target_ops *self, inferior *arg1, int arg2)
 {
   fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
-  debug_target.to_detach (&debug_target, arg1);
+  debug_target.to_detach (&debug_target, arg1, arg2);
   fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
   target_debug_print_struct_target_ops_p (&debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
-  target_debug_print_int (arg1);
+  target_debug_print_inferior_p (arg1);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_int (arg2);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
diff --git a/gdb/target.c b/gdb/target.c
index 728cab8..a9ee175 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -2108,7 +2108,7 @@  dispose_inferior (struct inferior *inf, void *args)
       if (target_has_execution)
 	target_kill ();
       else
-	target_detach (0);
+	target_detach (inf, 0);
     }
 
   return 0;
@@ -2144,7 +2144,7 @@  target_preopen (int from_tty)
 /* See target.h.  */
 
 void
-target_detach (int from_tty)
+target_detach (inferior *inf, int from_tty)
 {
   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
     /* Don't remove global breakpoints here.  They're removed on
@@ -2157,7 +2157,7 @@  target_detach (int from_tty)
 
   prepare_for_detach ();
 
-  current_target.to_detach (&current_target, from_tty);
+  current_target.to_detach (&current_target, inf, from_tty);
 }
 
 void
diff --git a/gdb/target.h b/gdb/target.h
index efd0311..3ed6350 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -440,7 +440,7 @@  struct target_ops
     void (*to_attach) (struct target_ops *ops, const char *, int);
     void (*to_post_attach) (struct target_ops *, int)
       TARGET_DEFAULT_IGNORE ();
-    void (*to_detach) (struct target_ops *ops, int)
+    void (*to_detach) (struct target_ops *ops, inferior *, int)
       TARGET_DEFAULT_IGNORE ();
     void (*to_disconnect) (struct target_ops *, const char *, int)
       TARGET_DEFAULT_NORETURN (tcomplain ());
@@ -1326,7 +1326,7 @@  extern void target_announce_detach (int from_tty);
    in the program or it'll die when it hits one.  FROM_TTY says whether to be
    verbose or not.  */
 
-extern void target_detach (int from_tty);
+extern void target_detach (inferior *inf, int from_tty);
 
 /* Disconnect from the current target without resuming it (leaving it
    waiting for a debugger).  */
diff --git a/gdb/top.c b/gdb/top.c
index 61055cf..2c78e4e 100644
--- a/gdb/top.c
+++ b/gdb/top.c
@@ -1485,7 +1485,7 @@  kill_or_detach (struct inferior *inf, void *args)
       if (target_has_execution)
 	{
 	  if (inf->attach_flag)
-	    target_detach (qt->from_tty);
+	    target_detach (inf, qt->from_tty);
 	  else
 	    target_kill ();
 	}
diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index 6a6cd08..266f710 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -1931,7 +1931,7 @@  windows_attach (struct target_ops *ops, const char *args, int from_tty)
 }
 
 static void
-windows_detach (struct target_ops *ops, int from_tty)
+windows_detach (struct target_ops *ops, inferior *inf, int from_tty)
 {
   int detached = 1;