This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [RFA 5/7] Improved linker-debugger interface


On Thu, 16 May 2013 16:48:38 +0200, Gary Benson wrote:
[...]
> --- a/gdb/solib.c
> +++ b/gdb/solib.c
> @@ -1208,6 +1208,38 @@ no_shared_libraries (char *ignored, int from_tty)
>    objfile_purge_solibs ();
>  }
>  
> +/* See solib.h.  */
> +
> +void
> +update_solib_breakpoints (void)
> +{
> +  struct target_so_ops *ops = solib_ops (target_gdbarch ());
> +
> +  if (ops->update_breakpoints != NULL)
> +    ops->update_breakpoints ();
> +}
> +
> +/* See solib.h.  */
> +
> +void
> +handle_solib_event (void)
> +{
> +  struct target_so_ops *ops = solib_ops (target_gdbarch ());
> +
> +  if (ops->handle_event != NULL)
> +    ops->handle_event ();
> +
> +  clear_program_space_solib_cache (current_inferior ()->pspace);
> +
> +  /* Check for any newly added shared libraries if we're supposed to
> +     be adding them automatically.  Switch terminal for any messages
> +     produced by breakpoint_re_set.  */
> +  target_terminal_ours_for_output ();
> +  solib_add (NULL, 0, &current_target, auto_solib_add);
> +  target_terminal_inferior ();
> +}
> +
> +

Should be only one empty line.


>  /* Reload shared libraries, but avoid reloading the same symbol file
>     we already have loaded.  */
>  
> diff --git a/gdb/solist.h b/gdb/solist.h
> index 0495474..244484a 100644
> --- a/gdb/solist.h
> +++ b/gdb/solist.h
> @@ -153,6 +153,19 @@ struct target_so_ops
>         core file (in particular, for readonly sections).  */
>      int (*keep_data_in_core) (CORE_ADDR vaddr,
>  			      unsigned long size);
> +
> +    /* Enable or disable optional solib event breakpoints as
> +       appropriate.  This should be called whenever
> +       stop_on_solib_events is changed.  This pointer can be
> +       NULL, in which case no enabling or disabling is necessary
> +       for this target.  */
> +    void (*update_breakpoints) (void);
> +
> +    /* Target-specific processing of solib events that will be
> +       performed before solib_add is called.  This pointer can be
> +       NULL, in which case no specific preprocessing is necessary
> +       for this target.  */
> +    void (*handle_event) (void);
>    };
>  
>  /* Free the memory associated with a (so_list *).  */
> diff --git a/gdb/infrun.c b/gdb/infrun.c
> index 54e92f2..a020dd6 100644
> --- a/gdb/infrun.c
> +++ b/gdb/infrun.c
> @@ -370,6 +370,16 @@ static struct symbol *step_start_function;
>  /* Nonzero if we want to give control to the user when we're notified
>     of shared library events by the dynamic linker.  */
>  int stop_on_solib_events;
> +
> +/* Enable or disable optional shared library event breakpoints
> +   as appropriate when the above flag is changed.  */
> +
> +static void
> +set_stop_on_solib_events (char *args, int from_tty, struct cmd_list_element *c)
> +{
> +  update_solib_breakpoints ();
> +}
> +
>  static void
>  show_stop_on_solib_events (struct ui_file *file, int from_tty,
>  			   struct cmd_list_element *c, const char *value)
> @@ -7303,7 +7313,7 @@ Show stopping for shared library events."), _("\
>  If nonzero, gdb will give control to the user when the dynamic linker\n\
>  notifies gdb of shared library events.  The most common event of interest\n\
>  to the user would be loading/unloading of a new library."),
> -			    NULL,
> +			    set_stop_on_solib_events,
>  			    show_stop_on_solib_events,
>  			    &setlist, &showlist);
>  
> diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
> index 4e09472..6b4bdb0 100644
> --- a/gdb/solib-svr4.c
> +++ b/gdb/solib-svr4.c
> @@ -47,9 +47,12 @@
>  #include "exceptions.h"
>  #include "gdb_bfd.h"
>  

No need for an empty line.


> +#include "probe.h"
> +
>  static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
>  static int svr4_have_link_map_offsets (void);
>  static void svr4_relocate_main_executable (void);
> +static void svr4_free_library_list (void *p_list);
>  
>  /* Link map info to include in an allocated so_list entry.  */
>  
> @@ -106,6 +109,55 @@ static const  char * const main_name_list[] =
>    NULL
>  };
>  
> +/* What to do when a probe stop occurs.  */
> +
> +enum probe_action
> +  {

This bracket should have no indentation.


> +    /* Something went seriously wrong.  Stop using probes and
> +       revert to using the older interface.  */
> +    PROBES_INTERFACE_FAILED,
> +
> +    /* No action is required.  The shared object list is still
> +       valid.  */
> +    DO_NOTHING,
> +
> +    /* The shared object list should be reloaded entirely.  */
> +    FULL_RELOAD,
> +
> +    /* Attempt to incrementally update the shared object list. If
> +       the update fails or is not possible, fall back to reloading
> +       the list in full.  */
> +    UPDATE_OR_RELOAD,
> +  };
> +
> +/* A probe's name and its associated action.  */
> +
> +struct probe_info
> +{
> +  /* The name of the probe.  */
> +  const char *name;
> +
> +  /* What to do when a probe stop occurs.  */
> +  enum probe_action action;
> +};
> +
> +/* A list of named probes and their associated actions.  If all
> +   probes are present in the dynamic linker then the probes-based
> +   interface will be used.  */
> +
> +static const struct probe_info probe_info[] =
> +{
> +  { "init_start", DO_NOTHING },
> +  { "init_complete", FULL_RELOAD },
> +  { "map_start", DO_NOTHING },
> +  { "map_failed", DO_NOTHING },
> +  { "reloc_complete", UPDATE_OR_RELOAD },
> +  { "unmap_start", DO_NOTHING },
> +  { "unmap_complete", FULL_RELOAD },
> +};
> +
> +#define NUM_PROBES ARRAY_SIZE (probe_info)
> +
>  /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
>     the same shared library.  */
>  
> @@ -313,17 +365,56 @@ struct svr4_info
>    CORE_ADDR interp_text_sect_high;
>    CORE_ADDR interp_plt_sect_low;
>    CORE_ADDR interp_plt_sect_high;
> +
> +  /* Nonzero if the list of objects was last obtained from the target
> +     via qXfer:libraries-svr4:read.  */
> +  int using_xfer;
> +
> +  /* Table mapping breakpoint addresses to probes and actions, used
> +     by the probes-based interface.  */

As this is not C++ it is not clear here it indexes 'struct probe_and_action'.
Also one could state the lookup is done via probe_and_action->probe->address.


> +  htab_t probes_table;
> +
> +  /* List of objects loaded into the inferior, used by the probes-
> +     based interface.  */
> +  struct so_list *solib_list;
>  };
>  
>  /* Per-program-space data key.  */
>  static const struct program_space_data *solib_svr4_pspace_data;
>  
> +/* Free the probes table.  */
> +
> +static void
> +free_probes_table (struct svr4_info *info)
> +{
> +  if (info->probes_table == NULL)
> +    return;
> +
> +  htab_delete (info->probes_table);
> +  info->probes_table = NULL;
> +}
> +
> +/* Free the solib list.  */
> +
> +static void
> +free_solib_list (struct svr4_info *info)
> +{
> +  svr4_free_library_list (&info->solib_list);
> +  info->solib_list = NULL;
> +}
> +
>  static void
>  svr4_pspace_data_cleanup (struct program_space *pspace, void *arg)
>  {
>    struct svr4_info *info;
>  
>    info = program_space_data (pspace, solib_svr4_pspace_data);
> +  if (info == NULL)
> +    return;
> +
> +  free_probes_table (info);
> +  free_solib_list (info);
> +
>    xfree (info);
>  }
>  
> @@ -990,6 +1081,36 @@ svr4_free_library_list (void *p_list)
>      }
>  }
>  
> +/* Copy library list.  */
> +
> +static struct so_list *
> +svr4_copy_library_list (struct so_list *src)
> +{
> +  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

No longer needed after the 2nd comment below.


> +  struct so_list *dst = NULL;
> +  struct so_list **link = &dst;
> +
> +  while (src != NULL)
> +    {
> +      struct so_list *new;
> +
> +      new = XZALLOC (struct so_list);

xmalloc is enough - without clearing.  You overwrite the whole allocated space
by the next statement anyway.


> +
> +      memcpy (new, src, sizeof (struct so_list));
> +
> +      new->lm_info = xmalloc (lmo->link_map_size);
> +      memcpy (new->lm_info, src->lm_info, lmo->link_map_size);

Here should be s/lmo->link_map_size/sizeof (struct lm_info)/.
so_list->lm_info is defined as struct lm_info at solib-svr4.c:59:
	(gdb) p sizeof (struct lm_info)
	$1 = 64
vs.
svr4_ilp32_fetch_link_map_offsets (void)
      lmo.link_map_size = 20;
svr4_lp64_fetch_link_map_offsets (void)
      lmo.link_map_size = 40;

lmo->link_map_size is the external layout of that data but so_list->lm_info is
its internal representation.


> +
> +      new->next = NULL;
> +      *link = new;
> +      link = &new->next;
> +
> +      src = src->next;
> +    }
> +
> +  return dst;
> +}
> +
>  #ifdef HAVE_LIBEXPAT
>  
>  #include "xml-support.h"
> @@ -1105,14 +1226,19 @@ svr4_parse_libraries (const char *document, struct svr4_library_list *list)
>    return 0;
>  }
>  
> -/* Attempt to get so_list from target via qXfer:libraries:read packet.
> +/* Attempt to get so_list from target via qXfer:libraries-svr4:read packet.
>  
>     Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
>     case.  Return 1 if *SO_LIST_RETURN contains the library list, it may be
> -   empty, caller is responsible for freeing all its entries.  */
> +   empty, caller is responsible for freeing all its entries.
> +
> +   Note that ANNEX must be NULL if the remote does not explicitly allow
> +   qXfer:libraries-svr4:read packets with non-empty annexes.  Support for
> +   this can be checked using target_augmented_libraries_svr4_read ().  */

So you can gdb_assert such requirement here.


>  
>  static int
> -svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
> +svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list,
> +				     const char *annex)
>  {
>    char *svr4_library_document;
>    int result;
> @@ -1121,7 +1247,7 @@ svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
>    /* Fetch the list of shared libraries.  */
>    svr4_library_document = target_read_stralloc (&current_target,
>  						TARGET_OBJECT_LIBRARIES_SVR4,
> -						NULL);
> +						annex);
>    if (svr4_library_document == NULL)
>      return 0;
>  
> @@ -1135,7 +1261,8 @@ svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
>  #else
>  
>  static int
> -svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
> +svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list,
> +				     const char *annex)
>  {
>    return 0;
>  }
> @@ -1169,15 +1296,17 @@ svr4_default_sos (void)
>    return new;
>  }
>  
> -/* Read the whole inferior libraries chain starting at address LM.  Add the
> -   entries to the tail referenced by LINK_PTR_PTR.  Ignore the first entry if
> -   IGNORE_FIRST and set global MAIN_LM_ADDR according to it.  */
> +/* Read the whole inferior libraries chain starting at address LM.
> +   Expect the first entry in the chain's previous entry to be PREV_LM.
> +   Add the entries to the tail referenced by LINK_PTR_PTR.  Ignore the
> +   first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according
> +   to it.  Returns nonzero upon success.  */

Please document what does a failure mean as it is used by the callers,
something like:
  If zero is returned the entries stored to LINK_PTR_PTR are still valid
  although they may represent only part of the inferior library list.


>  
> -static void
> -svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
> -		   int ignore_first)
> +static int
> +svr4_read_so_list (CORE_ADDR lm, CORE_ADDR prev_lm,
> +		   struct so_list ***link_ptr_ptr, int ignore_first)
>  {
> -  CORE_ADDR prev_lm = 0, next_lm;
> +  CORE_ADDR next_lm;
>  
>    for (; lm != 0; prev_lm = lm, lm = next_lm)
>      {
> @@ -1193,7 +1322,7 @@ svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
>        if (new->lm_info == NULL)
>  	{
>  	  do_cleanups (old_chain);
> -	  break;
> +	  return 0;
>  	}
>  
>        next_lm = new->lm_info->l_next;
> @@ -1204,7 +1333,7 @@ svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
>  		   paddress (target_gdbarch (), prev_lm),
>  		   paddress (target_gdbarch (), new->lm_info->l_prev));
>  	  do_cleanups (old_chain);
> -	  break;
> +	  return 0;
>  	}
>  
>        /* For SVR4 versions, the first entry in the link map is for the
> @@ -1250,17 +1379,19 @@ svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
>        **link_ptr_ptr = new;
>        *link_ptr_ptr = &new->next;
>      }
> +
> +  return 1;
>  }
>  
> -/* Implement the "current_sos" target_so_ops method.  */
> +/* Read the full list of currently loaded shared objects directly from
> +   the inferior.  */
>  
>  static struct so_list *
> -svr4_current_sos (void)
> +svr4_current_sos_direct (struct svr4_info *info)

Meaning of 'direct' seems ambiguous/unclear to me, maybe 'uncached'?
Just a hint, OK even with 'direct'.


>  {
>    CORE_ADDR lm;
>    struct so_list *head = NULL;
>    struct so_list **link_ptr = &head;
> -  struct svr4_info *info;
>    struct cleanup *back_to;
>    int ignore_first;
>    struct svr4_library_list library_list;
> @@ -1273,19 +1404,16 @@ svr4_current_sos (void)
>       Unfortunately statically linked inferiors will also fall back through this
>       suboptimal code path.  */
>  
> -  if (svr4_current_sos_via_xfer_libraries (&library_list))
> +  info->using_xfer = svr4_current_sos_via_xfer_libraries (&library_list,
> +							  NULL);
> +  if (info->using_xfer)
>      {
>        if (library_list.main_lm)
> -	{
> -	  info = get_svr4_info ();
> -	  info->main_lm_addr = library_list.main_lm;
> -	}
> +	info->main_lm_addr = library_list.main_lm;
>  
>        return library_list.head ? library_list.head : svr4_default_sos ();
>      }
>  
> -  info = get_svr4_info ();
> -
>    /* Always locate the debug struct, in case it has moved.  */
>    info->debug_base = 0;
>    locate_base (info);
> @@ -1308,7 +1436,7 @@ svr4_current_sos (void)
>       `struct so_list' nodes.  */
>    lm = solib_svr4_r_map (info);
>    if (lm)
> -    svr4_read_so_list (lm, &link_ptr, ignore_first);
> +    svr4_read_so_list (lm, 0, &link_ptr, ignore_first);
>  
>    /* On Solaris, the dynamic linker is not in the normal list of
>       shared objects, so make sure we pick it up too.  Having
> @@ -1316,7 +1444,7 @@ svr4_current_sos (void)
>       for skipping dynamic linker resolver code.  */
>    lm = solib_svr4_r_ldsomap (info);
>    if (lm)
> -    svr4_read_so_list (lm, &link_ptr, 0);
> +    svr4_read_so_list (lm, 0, &link_ptr, 0);
>  
>    discard_cleanups (back_to);
>  
> @@ -1326,6 +1454,22 @@ svr4_current_sos (void)
>    return head;
>  }
>  
> +/* Implement the "current_sos" target_so_ops method.  */
> +
> +static struct so_list *
> +svr4_current_sos (void)
> +{
> +  struct svr4_info *info = get_svr4_info ();
> +
> +  /* If we are using the probes interface and the solib list has
> +     been cached then we simply return that.  */
> +  if (info->solib_list != NULL)
> +    return svr4_copy_library_list (info->solib_list);
> +
> +  /* Otherwise obtain the solib list directly from the inferior.  */
> +  return svr4_current_sos_direct (info);
> +}
> +
>  /* Get the address of the link_map for a given OBJFILE.  */
>  
>  CORE_ADDR
> @@ -1408,6 +1552,434 @@ exec_entry_point (struct bfd *abfd, struct target_ops *targ)
>    return gdbarch_addr_bits_remove (target_gdbarch (), addr);
>  }
>  
> +/* A probe and its associated action.  */
> +
> +struct probe_and_action
> +{
> +  /* The probe.  */
> +  struct probe *probe;
> +
> +  /* The action.  */
> +  enum probe_action action;
> +};
> +
> +/* Returns a hash code for the probe_and_action referenced by p.  */
> +
> +static hashval_t
> +hash_probe_and_action (const void *p)
> +{
> +  const struct probe_and_action *pa = p;
> +
> +  return (hashval_t) pa->probe->address;
> +}
> +
> +/* Returns non-zero if the probe_and_actions referenced by p1 and p2
> +   are equal.  */
> +
> +static int
> +equal_probe_and_action (const void *p1, const void *p2)
> +{
> +  const struct probe_and_action *pa1 = p1;
> +  const struct probe_and_action *pa2 = p2;
> +
> +  return pa1->probe->address == pa2->probe->address;
> +}
> +
> +/* Register a solib event probe and its associated action in the
> +   probes table.  */
> +
> +static void
> +register_solib_event_probe (struct probe *probe, enum probe_action action)
> +{
> +  struct svr4_info *info = get_svr4_info ();
> +  struct probe_and_action lookup, *pa;
> +  void **slot;
> +
> +  /* Create the probes table, if necessary.  */
> +  if (info->probes_table == NULL)
> +    {

These curly brackets are not needed.


> +      info->probes_table = htab_create_alloc (1, hash_probe_and_action,
> +					      equal_probe_and_action,
> +					      xfree, xcalloc, xfree);
> +    }
> +
> +  lookup.probe = probe;
> +  slot = htab_find_slot (info->probes_table, &lookup, INSERT);
> +  gdb_assert (*slot == HTAB_EMPTY_ENTRY);
> +
> +  pa = XCNEW (struct probe_and_action);
> +  pa->probe = probe;
> +  pa->action = action;
> +
> +  *slot = pa;
> +}
> +
> +/* Get the solib event probe at the specified location, and the
> +   action associated with it.  Returns NULL if no solib event probe
> +   was found.  */
> +
> +static struct probe_and_action *
> +solib_event_probe_at (struct svr4_info *info, CORE_ADDR address)
> +{
> +  struct probe lookup_probe;
> +  struct probe_and_action lookup;
> +  void **slot;
> +
> +  lookup_probe.address = address;
> +  lookup.probe = &lookup_probe;
> +  slot = htab_find_slot (info->probes_table, &lookup, NO_INSERT);
> +
> +  if (slot == NULL)
> +    return NULL;
> +
> +  return (struct probe_and_action *) *slot;
> +}
> +
> +/* Decide what action to take when the specified solib event probe is
> +   hit.  */
> +
> +static enum probe_action
> +solib_event_probe_action (struct probe_and_action *pa)
> +{
> +  enum probe_action action;
> +  unsigned probe_argc;
> +
> +  action = pa->action;
> +  if (action == DO_NOTHING || action == PROBES_INTERFACE_FAILED)
> +    return action;
> +
> +  gdb_assert (action == FULL_RELOAD || action == UPDATE_OR_RELOAD);
> +
> +  /* Check that an appropriate number of arguments has been supplied.
> +     We expect:
> +       arg0: Lmid_t lmid (mandatory)
> +       arg1: struct r_debug *debug_base (mandatory)
> +       arg2: struct link_map *new (optional, for incremental updates)  */
> +  probe_argc = get_probe_argument_count (pa->probe);
> +  if (probe_argc == 2)
> +    action = FULL_RELOAD;
> +  else if (probe_argc < 2)
> +    action = PROBES_INTERFACE_FAILED;
> +
> +  return action;
> +}
> +
> +/* Populate the shared object list by reading the entire list of
> +   shared objects from the inferior.  Returns nonzero on success.  */
> +
> +static int
> +solist_update_full (struct svr4_info *info)
> +{
> +  svr4_free_library_list (&info->solib_list);

I find it a bit fragily this way, I would find worth it here also:
  info->solib_list = NULL;

As svr4_current_sos_direct is a pretty big function and it could somehow
check/update even info->solib_list possibly in the future.

Maybe a matter of opinion a bit.


> +  info->solib_list = svr4_current_sos_direct (info);
> +
> +  return 1;
> +}
> +
> +/* Update the shared object list starting from the link-map entry
> +   passed by the linker in the probe's third argument.  Returns
> +   nonzero if the list was successfully updated, or zero to indicate
> +   failure.  */
> +
> +static int
> +solist_update_incremental (struct svr4_info *info, CORE_ADDR lm)
> +{
> +  struct so_list *tail;
> +  CORE_ADDR prev_lm;
> +
> +  /* Fall back to a full update if we haven't read anything yet.  */
> +  if (info->solib_list == NULL)
> +    return 0;
> +
> +  /* Fall back to a full update if we are using a remote target
> +     that does not support incremental transfers.  */
> +  if (info->using_xfer && !target_augmented_libraries_svr4_read())
> +    return 0;
> +
> +  /* Walk to the end of the list.  */
> +  for (tail = info->solib_list; tail->next; tail = tail->next);

Not sure if it is any Coding Style but:

  for (tail = info->solib_list; tail->next; tail = tail->next)
    /* Nothing.  */;


> +  prev_lm = tail->lm_info->lm_addr;
> +
> +  /* Read the new objects.  */
> +  if (info->using_xfer)
> +    {
> +      struct svr4_library_list library_list;
> +      char annex[64];
> +
> +      xsnprintf (annex, sizeof (annex), "start=%lx;prev=%lx", lm, prev_lm);

CORE_ADDR is not compatible with %lx in some GDB configurations.
One may have Windows 32-bit host GDB with 32-bit long and 64-bit remote target
and therefore also 64-bit CORE_ADDR.

Unfortunately functions like paddress or core_addr_to_string_nz output also
the 0x prefix so you need to use phex_nz (addr, sizeof (addr)).

I hope the width stripping of paddress is not required for solib-svr4.c
targets.


> +      if (!svr4_current_sos_via_xfer_libraries (&library_list, annex))
> +	return 0;
> +
> +      tail->next = library_list.head;
> +    }
> +  else
> +    {
> +      struct so_list **link = &tail->next;
> +
> +      if (!svr4_read_so_list (lm, prev_lm, &link, 0))

You should set the last IGNORE_FIRST parameter properly.  While glibc has ""
there AFAIK some OSes like Solaris may have some valid pathname there which
would confuse GDB listing the executable also as a shared library.


> +	return 0;
> +    }
> +
> +  return 1;
> +}
> +
> +/* Disable the probes-based linker interface and revert to the
> +   original interface.  We don't reset the breakpoints as the
> +   ones set up for the probes-based interface are adequate.  */
> +
> +static void
> +disable_probes_interface_cleanup (void *arg)
> +{
> +  struct svr4_info *info = get_svr4_info ();
> +
> +  warning (_("Probes-based dynamic linker interface failed.\n"
> +	     "Reverting to original interface.\n"));
> +
> +  free_probes_table (info);
> +  free_solib_list (info);
> +}
> +
> +/* Update the solib list as appropriate when using the
> +   probes-based linker interface.  Do nothing if using the
> +   standard interface.  */
> +
> +static void
> +svr4_handle_solib_event (void)
> +{
> +  struct svr4_info *info = get_svr4_info ();
> +  struct probe_and_action *pa;
> +  enum probe_action action;
> +  struct cleanup *old_chain, *usm_chain;
> +  struct value *val;
> +  CORE_ADDR pc, debug_base, lm = 0;
> +  int is_initial_ns;
> +
> +  /* Do nothing if not using the probes interface.  */
> +  if (info->probes_table == NULL)
> +    return;
> +
> +  /* If anything goes wrong we revert to the original linker
> +     interface.  */
> +  old_chain = make_cleanup (disable_probes_interface_cleanup, NULL);
> +
> +  pc = regcache_read_pc (get_current_regcache ());
> +  pa = solib_event_probe_at (info, pc);
> +  if (pa == NULL)
> +    goto error;
> +
> +  action = solib_event_probe_action (pa);
> +  if (action == PROBES_INTERFACE_FAILED)
> +    goto error;
> +
> +  if (action == DO_NOTHING)

Leaked OLD_CHAIN cleanups.


> +    return;
> +
> +  /* EVALUATE_PROBE_ARGUMENT looks up symbols in the dynamic linker

Functions should not be uppercased.  Only variables are uppercased if you
refer to their value (it is usually a bit ambiguous if you refer to their
value or to the variable itself but that is offtopic here)..
	http://www.gnu.org/prep/standards/standards.html
	The variable name itself should be lower case, but write it in upper
	case when you are speaking about the value rather than the variable
	itself. Thus, “the inode number NODE_NUM” rather than “an inode”. 

It is at more places around.


> +     using FIND_PC_SECTION.  FIND_PC_SECTION is accelerated by a cache
> +     called the section map.  The section map is invalidated every
> +     time a shared library is loaded or unloaded, and if the inferior
> +     is generating a lot of shared library events then the section map
> +     will be updated every time SVR4_HANDLE_SOLIB_EVENT is called.
> +     We called FIND_PC_SECTION in SVR4_CREATE_SOLIB_EVENT_BREAKPOINTS,
> +     so we can guarantee that the dynamic linker's sections are in the
> +     section map.  We can therefore inhibit section map updates across
> +     these calls to EVALUATE_PROBE_ARGUMENT and save a lot of time.  */
> +  inhibit_section_map_updates ();
> +  usm_chain = make_cleanup (resume_section_map_updates_cleanup, NULL);
> +
> +  val = evaluate_probe_argument (pa->probe, 1);
> +  if (val == NULL)
> +    goto error;
> +
> +  debug_base = value_as_address (val);
> +  if (debug_base == 0)
> +    goto error;
> +
> +  /* Always locate the debug struct, in case it moved.  */
> +  info->debug_base = 0;
> +  if (locate_base (info) == 0)
> +    goto error;
> +
> +  /* Do not process namespaces other than the initial one.  */

I find a more rich description appropriate given how long this issue was being
discussed:
	Therefore dlmopen is currently not supported by GDB.


> +  if (debug_base != info->debug_base)
> +    action = DO_NOTHING;
> +
> +  if (action == UPDATE_OR_RELOAD)
> +    {
> +      val = evaluate_probe_argument (pa->probe, 2);
> +      if (val != NULL)
> +	lm = value_as_address (val);
> +
> +      if (lm == 0)
> +	action = FULL_RELOAD;
> +    }
> +
> +  /* Resume section map updates.  */
> +  do_cleanups (usm_chain);
> +
> +  if (action == UPDATE_OR_RELOAD)
> +    {
> +      if (!solist_update_incremental (info, lm))
> +	action = FULL_RELOAD;
> +    }
> +
> +  if (action == FULL_RELOAD)
> +    {
> +      if (!solist_update_full (info))
> +	goto error;
> +    }
> +
> +  discard_cleanups (old_chain);
> +  return;
> +
> + error:
> +  /* We should never reach here, but if we do we disable the
> +     probes interface and revert to the original interface.  */
> +
> +  do_cleanups (old_chain);

You could just always do { do_cleanups; return; } IMO and avoid the goto but
up to you.


> +}
> +
> +/* Helper function for svr4_update_solib_event_breakpoints.  */
> +
> +static int
> +svr4_update_solib_event_breakpoint (struct breakpoint *b, void *arg)
> +{
> +  struct svr4_info *info = get_svr4_info ();
> +  struct bp_location *loc;
> +
> +  if (b->type != bp_shlib_event)
> +    return 0; /* Continue iterating.  */

Comment should be on a separate line (and therefore this one in a { block } ),
likewise below.


> +
> +  for (loc = b->loc; loc; loc = loc->next)
> +    {
> +      struct probe_and_action *pa = solib_event_probe_at (info, loc->address);
> +
> +      if (pa != NULL)
> +	{
> +	  if (pa->action == DO_NOTHING)
> +	    b->enable_state = (stop_on_solib_events
> +			       ? bp_enabled : bp_disabled);
> +
> +	  return 0; /* Continue iterating.  */
> +	}
> +    }
> +
> +  return 0; /* Continue iterating.  */
> +}
> +
> +/* Enable or disable optional solib event breakpoints as appropriate.
> +   Called whenever stop_on_solib_events is changed.  */

It seems a bit suspicious that no update_global_location_list* is called.
Why is it safe?


> +
> +static void
> +svr4_update_solib_event_breakpoints (void)
> +{
> +  struct svr4_info *info = get_svr4_info ();
> +
> +  if (info->probes_table)

According to the GDB Coding Style:
  if (info->probes_table != NULL)


> +    iterate_over_breakpoints (svr4_update_solib_event_breakpoint, NULL);
> +}
> +
> +/* Create and register solib event breakpoints.  */

One should describe the parametr PROBES, that it is an array of NUM_PROBES
elements containing multi-location breakpoints etc.


> +
> +static void
> +svr4_create_probe_breakpoints (struct gdbarch *gdbarch,
> +			       VEC (probe_p) **probes)
> +{
> +  int i;
> +
> +  for (i = 0; i < NUM_PROBES; i++)
> +    {
> +      enum probe_action action = probe_info[i].action;
> +      struct probe *probe;
> +      int ix;
> +
> +      for (ix = 0;
> +	   VEC_iterate (probe_p, probes[i], ix, probe);
> +	   ++ix)
> +	{
> +	  create_solib_event_breakpoint (gdbarch, probe->address);
> +	  register_solib_event_probe (probe, action);
> +	}
> +    }
> +
> +  svr4_update_solib_event_breakpoints ();

Here and also in svr4_update_solib_event_breakpoints seems a bit suspicious
that no update_global_location_list* is called.  Why is it safe?


> +}
> +
> +/* Both the SunOS and the SVR4 dynamic linkers call a marker function
> +   before and after mapping and unmapping shared libraries.  The sole
> +   purpose of this method is to allow debuggers to set a breakpoint so
> +   they can track these changes.
> +
> +   Some versions of the glibc dynamic linker contain named probes
> +   to allow more fine grained stopping.  Given the address of the
> +   original marker function, this function attempts to find these
> +   probes, and if found, sets breakpoints on those instead.  If the
> +   probes aren't found, a single breakpoint is set on the original
> +   marker function.  */
> +
> +static void
> +svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch,
> +				     CORE_ADDR address)
> +{
> +  struct svr4_info *info = get_svr4_info ();

Unused variable.


> +  struct obj_section *os;
> +
> +  os = find_pc_section (address);
> +  if (os != NULL)
> +    {
> +      int with_prefix;
> +
> +      for (with_prefix = 0; with_prefix <= 1; with_prefix++)
> +	{
> +	  VEC (probe_p) *probes[NUM_PROBES];
> +	  int all_probes_found = 1;
> +	  int i;
> +
> +	  memset (probes, 0, sizeof (probes));
> +	  for (i = 0; i < NUM_PROBES; i++)
> +	    {
> +	      char name[32] = { '\0' };
> +
> +	      /* Fedora 17, RHEL 6.2, and RHEL 6.3 shipped with an
> +		 early version of the probes code in which the probes'
> +		 names were prefixed with "rtld_" and the "map_failed"
> +		 probe did not exist.  The locations of the probes are
> +		 otherwise the same, so we check for probes with
> +		 prefixed names if probes with unprefixed names are
> +		 not present.  */
> +
> +	      if (with_prefix)
> +		strncat (name, "rtld_", sizeof (name) - strlen (name) - 1);
> +
> +	      strncat (name, probe_info[i].name,
> +		       sizeof (name) - strlen (name) - 1);
> +
> +	      probes[i] = find_probes_in_objfile (os->objfile, "rtld", name);
> +

Some comment why "rtld_map_failed" failure is ignore would be nice.


> +	      if (!strcmp (name, "rtld_map_failed"))
> +		continue;
> +
> +	      if (!VEC_length (probe_p, probes[i]))

There is also VEC_empty...


> +		{
> +		  all_probes_found = 0;
> +		  break;
> +		}
> +	    }
> +
> +	  if (all_probes_found)
> +	    svr4_create_probe_breakpoints (gdbarch, probes);
> +
> +	  for (i = 0; i < NUM_PROBES; i++)
> +	    VEC_free (probe_p, probes[i]);
> +
> +	  if (all_probes_found)
> +	    return;
> +	}
> +    }
> +
> +  create_solib_event_breakpoint (gdbarch, address);
> +}
> +
>  /* Helper function for gdb_bfd_lookup_symbol.  */
>  
>  static int
> @@ -1460,6 +2032,8 @@ enable_break (struct svr4_info *info, int from_tty)
>    info->interp_text_sect_low = info->interp_text_sect_high = 0;
>    info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
>  
> +  free_probes_table (info);

Why is this one needed and free_solib_list is not needed?


> +
>    /* If we already have a shared library list in the target, and
>       r_debug contains r_brk, set the breakpoint there - this should
>       mean r_brk has already been relocated.  Assume the dynamic linker
[...]


Thanks,
Jan


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]