gdb/debuginfod-support.c

   1 /* debuginfod utilities for GDB.
   2    Copyright (C) 2020-2023 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   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.
  10
  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.
  15
  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/>.  */
  18
  19 #include "defs.h"
  20 #include "diagnostics.h"
  21 #include <errno.h>
  22 #include "gdbsupport/scoped_fd.h"
  23 #include "debuginfod-support.h"
  24 #include "gdbsupport/gdb_optional.h"
  25 #include "cli/cli-cmds.h"
  26 #include "cli/cli-style.h"
  27 #include "cli-out.h"
  28 #include "target.h"
  29
  30 /* Set/show debuginfod commands.  */
  31 static cmd_list_element *set_debuginfod_prefix_list;
  32 static cmd_list_element *show_debuginfod_prefix_list;
  33
  34 static const char debuginfod_on[] = "on";
  35 static const char debuginfod_off[] = "off";
  36 static const char debuginfod_ask[] = "ask";
  37
  38 static const char *debuginfod_enabled_enum[] =
  39 {
  40   debuginfod_on,
  41   debuginfod_off,
  42   debuginfod_ask,
  43   nullptr
  44 };
  45
  46 static const char *debuginfod_enabled =
  47 #if defined(HAVE_LIBDEBUGINFOD)
  48   debuginfod_ask;
  49 #else
  50   debuginfod_off;
  51 #endif
  52
  53 static unsigned int debuginfod_verbose = 1;
  54
  55 #ifndef HAVE_LIBDEBUGINFOD
  56 scoped_fd
  57 debuginfod_source_query (const unsigned char *build_id,
  58                          int build_id_len,
  59                          const char *srcpath,
  60                          gdb::unique_xmalloc_ptr<char> *destname)
  61 {
  62   return scoped_fd (-ENOSYS);
  63 }
  64
  65 scoped_fd
  66 debuginfod_debuginfo_query (const unsigned char *build_id,
  67                             int build_id_len,
  68                             const char *filename,
  69                             gdb::unique_xmalloc_ptr<char> *destname)
  70 {
  71   return scoped_fd (-ENOSYS);
  72 }
  73
  74 scoped_fd
  75 debuginfod_exec_query (const unsigned char *build_id,
  76                        int build_id_len,
  77                        const char *filename,
  78                        gdb::unique_xmalloc_ptr<char> *destname)
  79 {
  80   return scoped_fd (-ENOSYS);
  81 }
  82
  83 #define NO_IMPL _("Support for debuginfod is not compiled into GDB.")
  84
  85 #else
  86 #include <elfutils/debuginfod.h>
  87
  88 struct user_data
  89 {
  90   user_data (const char *desc, const char *fname)
  91     : desc (desc), fname (fname)
  92   { }
  93
  94   const char * const desc;
  95   const char * const fname;
  96   ui_out::progress_update progress;
  97 };
  98
  99 /* Deleter for a debuginfod_client.  */
 100
 101 struct debuginfod_client_deleter
 102 {
 103   void operator() (debuginfod_client *c)
 104   {
 105     debuginfod_end (c);
 106   }
 107 };
 108
 109 using debuginfod_client_up
 110   = std::unique_ptr<debuginfod_client, debuginfod_client_deleter>;
 111
 112
 113 /* Convert SIZE into a unit suitable for use with progress updates.
 114    SIZE should in given in bytes and will be converted into KB, MB, GB
 115    or remain unchanged. UNIT will be set to "B", "KB", "MB" or "GB"
 116    accordingly.  */
 117
 118 static const char *
 119 get_size_and_unit (double &size)
 120 {
 121   if (size < 1024)
 122     /* If size is less than 1 KB then set unit to B.  */
 123     return "B";
 124
 125   size /= 1024;
 126   if (size < 1024)
 127     /* If size is less than 1 MB then set unit to KB.  */
 128     return "K";
 129
 130   size /= 1024;
 131   if (size < 1024)
 132     /* If size is less than 1 GB then set unit to MB.  */
 133     return "M";
 134
 135   size /= 1024;
 136   return "G";
 137 }
 138
 139 static int
 140 progressfn (debuginfod_client *c, long cur, long total)
 141 {
 142   user_data *data = static_cast<user_data *> (debuginfod_get_user_data (c));
 143   gdb_assert (data != nullptr);
 144
 145   string_file styled_fname (current_uiout->can_emit_style_escape ());
 146   fprintf_styled (&styled_fname, file_name_style.style (), "%s",
 147                   data->fname);
 148
 149   if (check_quit_flag ())
 150     {
 151       gdb_printf ("Cancelling download of %s %s...\n",
 152                   data->desc, styled_fname.c_str ());
 153       return 1;
 154     }
 155
 156   if (debuginfod_verbose == 0)
 157     return 0;
 158
 159   /* Print progress update.  Include the transfer size if available.  */
 160   if (total > 0)
 161     {
 162       /* Transfer size is known.  */
 163       double howmuch = (double) cur / (double) total;
 164
 165       if (howmuch >= 0.0 && howmuch <= 1.0)
 166         {
 167           double d_total = (double) total;
 168           const char *unit =  get_size_and_unit (d_total);
 169           std::string msg = string_printf ("Downloading %0.2f %s %s %s",
 170                                            d_total, unit, data->desc,
 171                                            styled_fname.c_str ());
 172           data->progress.update_progress (msg, unit, howmuch, d_total);
 173           return 0;
 174         }
 175     }
 176
 177   std::string msg = string_printf ("Downloading %s %s",
 178                                    data->desc, styled_fname.c_str ());
 179   data->progress.update_progress (msg);
 180   return 0;
 181 }
 182
 183 static debuginfod_client *
 184 get_debuginfod_client ()
 185 {
 186   static debuginfod_client_up global_client;
 187
 188   if (global_client == nullptr)
 189     {
 190       global_client.reset (debuginfod_begin ());
 191
 192       if (global_client != nullptr)
 193         debuginfod_set_progressfn (global_client.get (), progressfn);
 194     }
 195
 196   return global_client.get ();
 197 }
 198
 199 /* Check if debuginfod is enabled.  If configured to do so, ask the user
 200    whether to enable debuginfod.  */
 201
 202 static bool
 203 debuginfod_is_enabled ()
 204 {
 205   const char *urls = skip_spaces (getenv (DEBUGINFOD_URLS_ENV_VAR));
 206
 207   if (debuginfod_enabled == debuginfod_off
 208       || urls == nullptr
 209       || *urls == '\0')
 210     return false;
 211
 212   if (debuginfod_enabled == debuginfod_ask)
 213     {
 214       gdb_printf (_("\nThis GDB supports auto-downloading debuginfo " \
 215                     "from the following URLs:\n"));
 216
 217       gdb::string_view url_view (urls);
 218       while (true)
 219         {
 220           size_t off = url_view.find_first_not_of (' ');
 221           if (off == gdb::string_view::npos)
 222             break;
 223           url_view = url_view.substr (off);
 224           /* g++ 11.2.1 on s390x, g++ 11.3.1 on ppc64le and g++ 11 on
 225              hppa seem convinced url_view might be of SIZE_MAX length.
 226              And so complains because the length of an array can only
 227              be PTRDIFF_MAX.  */
 228           DIAGNOSTIC_PUSH
 229           DIAGNOSTIC_IGNORE_STRINGOP_OVERREAD
 230           off = url_view.find_first_of (' ');
 231           DIAGNOSTIC_POP
 232           gdb_printf
 233             (_("  <%ps>\n"),
 234              styled_string (file_name_style.style (),
 235                             gdb::to_string (url_view.substr (0,
 236                                                              off)).c_str ()));
 237           if (off == gdb::string_view::npos)
 238             break;
 239           url_view = url_view.substr (off);
 240         }
 241
 242       int resp = nquery (_("Enable debuginfod for this session? "));
 243       if (!resp)
 244         {
 245           gdb_printf (_("Debuginfod has been disabled.\nTo make this " \
 246                         "setting permanent, add \'set debuginfod " \
 247                         "enabled off\' to .gdbinit.\n"));
 248           debuginfod_enabled = debuginfod_off;
 249           return false;
 250         }
 251
 252       gdb_printf (_("Debuginfod has been enabled.\nTo make this " \
 253                     "setting permanent, add \'set debuginfod enabled " \
 254                     "on\' to .gdbinit.\n"));
 255       debuginfod_enabled = debuginfod_on;
 256     }
 257
 258   return true;
 259 }
 260
 261 /* Print the result of the most recent attempted download.  */
 262
 263 static void
 264 print_outcome (user_data &data, int fd)
 265 {
 266   /* Clears the current line of progress output.  */
 267   current_uiout->do_progress_end ();
 268
 269   if (fd < 0 && fd != -ENOENT)
 270     gdb_printf (_("Download failed: %s.  Continuing without %s %ps.\n"),
 271                 safe_strerror (-fd),
 272                 data.desc,
 273                 styled_string (file_name_style.style (), data.fname));
 274 }
 275
 276 /* See debuginfod-support.h  */
 277
 278 scoped_fd
 279 debuginfod_source_query (const unsigned char *build_id,
 280                          int build_id_len,
 281                          const char *srcpath,
 282                          gdb::unique_xmalloc_ptr<char> *destname)
 283 {
 284   if (!debuginfod_is_enabled ())
 285     return scoped_fd (-ENOSYS);
 286
 287   debuginfod_client *c = get_debuginfod_client ();
 288
 289   if (c == nullptr)
 290     return scoped_fd (-ENOMEM);
 291
 292   char *dname = nullptr;
 293   user_data data ("source file", srcpath);
 294
 295   debuginfod_set_user_data (c, &data);
 296   gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
 297   if (target_supports_terminal_ours ())
 298     {
 299       term_state.emplace ();
 300       target_terminal::ours ();
 301     }
 302
 303   scoped_fd fd (debuginfod_find_source (c,
 304                                         build_id,
 305                                         build_id_len,
 306                                         srcpath,
 307                                         &dname));
 308   debuginfod_set_user_data (c, nullptr);
 309   print_outcome (data, fd.get ());
 310
 311   if (fd.get () >= 0)
 312     destname->reset (dname);
 313
 314   return fd;
 315 }
 316
 317 /* See debuginfod-support.h  */
 318
 319 scoped_fd
 320 debuginfod_debuginfo_query (const unsigned char *build_id,
 321                             int build_id_len,
 322                             const char *filename,
 323                             gdb::unique_xmalloc_ptr<char> *destname)
 324 {
 325   if (!debuginfod_is_enabled ())
 326     return scoped_fd (-ENOSYS);
 327
 328   debuginfod_client *c = get_debuginfod_client ();
 329
 330   if (c == nullptr)
 331     return scoped_fd (-ENOMEM);
 332
 333   char *dname = nullptr;
 334   user_data data ("separate debug info for", filename);
 335
 336   debuginfod_set_user_data (c, &data);
 337   gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
 338   if (target_supports_terminal_ours ())
 339     {
 340       term_state.emplace ();
 341       target_terminal::ours ();
 342     }
 343
 344   scoped_fd fd (debuginfod_find_debuginfo (c, build_id, build_id_len,
 345                                            &dname));
 346   debuginfod_set_user_data (c, nullptr);
 347   print_outcome (data, fd.get ());
 348
 349   if (fd.get () >= 0)
 350     destname->reset (dname);
 351
 352   return fd;
 353 }
 354
 355 /* See debuginfod-support.h  */
 356
 357 scoped_fd
 358 debuginfod_exec_query (const unsigned char *build_id,
 359                        int build_id_len,
 360                        const char *filename,
 361                        gdb::unique_xmalloc_ptr<char> *destname)
 362 {
 363   if (!debuginfod_is_enabled ())
 364     return scoped_fd (-ENOSYS);
 365
 366   debuginfod_client *c = get_debuginfod_client ();
 367
 368   if (c == nullptr)
 369     return scoped_fd (-ENOMEM);
 370
 371   char *dname = nullptr;
 372   user_data data ("executable for", filename);
 373
 374   debuginfod_set_user_data (c, &data);
 375   gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
 376   if (target_supports_terminal_ours ())
 377     {
 378       term_state.emplace ();
 379       target_terminal::ours ();
 380     }
 381
 382   scoped_fd fd (debuginfod_find_executable (c, build_id, build_id_len, &dname));
 383   debuginfod_set_user_data (c, nullptr);
 384   print_outcome (data, fd.get ());
 385
 386   if (fd.get () >= 0)
 387     destname->reset (dname);
 388
 389   return fd;
 390 }
 391 #endif
 392
 393 /* Set callback for "set debuginfod enabled".  */
 394
 395 static void
 396 set_debuginfod_enabled (const char *value)
 397 {
 398 #if defined(HAVE_LIBDEBUGINFOD)
 399   debuginfod_enabled = value;
 400 #else
 401   /* Disabling debuginfod when gdb is not built with it is a no-op.  */
 402   if (value != debuginfod_off)
 403     error (NO_IMPL);
 404 #endif
 405 }
 406
 407 /* Get callback for "set debuginfod enabled".  */
 408
 409 static const char *
 410 get_debuginfod_enabled ()
 411 {
 412   return debuginfod_enabled;
 413 }
 414
 415 /* Show callback for "set debuginfod enabled".  */
 416
 417 static void
 418 show_debuginfod_enabled (ui_file *file, int from_tty, cmd_list_element *cmd,
 419                          const char *value)
 420 {
 421   gdb_printf (file,
 422               _("Debuginfod functionality is currently set to "
 423                 "\"%s\".\n"), debuginfod_enabled);
 424 }
 425
 426 /* Set callback for "set debuginfod urls".  */
 427
 428 static void
 429 set_debuginfod_urls (const std::string &urls)
 430 {
 431 #if defined(HAVE_LIBDEBUGINFOD)
 432   if (setenv (DEBUGINFOD_URLS_ENV_VAR, urls.c_str (), 1) != 0)
 433     warning (_("Unable to set debuginfod URLs: %s"), safe_strerror (errno));
 434 #else
 435   error (NO_IMPL);
 436 #endif
 437 }
 438
 439 /* Get callback for "set debuginfod urls".  */
 440
 441 static const std::string&
 442 get_debuginfod_urls ()
 443 {
 444   static std::string urls;
 445 #if defined(HAVE_LIBDEBUGINFOD)
 446   const char *envvar = getenv (DEBUGINFOD_URLS_ENV_VAR);
 447
 448   if (envvar != nullptr)
 449     urls = envvar;
 450   else
 451     urls.clear ();
 452 #endif
 453
 454   return urls;
 455 }
 456
 457 /* Show callback for "set debuginfod urls".  */
 458
 459 static void
 460 show_debuginfod_urls (ui_file *file, int from_tty, cmd_list_element *cmd,
 461                       const char *value)
 462 {
 463   if (value[0] == '\0')
 464     gdb_printf (file, _("Debuginfod URLs have not been set.\n"));
 465   else
 466     gdb_printf (file, _("Debuginfod URLs are currently set to:\n%s\n"),
 467                 value);
 468 }
 469
 470 /* Show callback for "set debuginfod verbose".  */
 471
 472 static void
 473 show_debuginfod_verbose_command (ui_file *file, int from_tty,
 474                                  cmd_list_element *cmd, const char *value)
 475 {
 476   gdb_printf (file, _("Debuginfod verbose output is set to %s.\n"),
 477               value);
 478 }
 479
 480 /* Register debuginfod commands.  */
 481
 482 void _initialize_debuginfod ();
 483 void
 484 _initialize_debuginfod ()
 485 {
 486   /* set/show debuginfod */
 487   add_setshow_prefix_cmd ("debuginfod", class_run,
 488                           _("Set debuginfod options."),
 489                           _("Show debuginfod options."),
 490                           &set_debuginfod_prefix_list,
 491                           &show_debuginfod_prefix_list,
 492                           &setlist, &showlist);
 493
 494   add_setshow_enum_cmd ("enabled", class_run, debuginfod_enabled_enum,
 495                         _("Set whether to use debuginfod."),
 496                         _("Show whether to use debuginfod."),
 497                         _("\
 498 When on, enable the use of debuginfod to download missing debug info and\n\
 499 source files."),
 500                         set_debuginfod_enabled,
 501                         get_debuginfod_enabled,
 502                         show_debuginfod_enabled,
 503                         &set_debuginfod_prefix_list,
 504                         &show_debuginfod_prefix_list);
 505
 506   /* set/show debuginfod urls */
 507   add_setshow_string_noescape_cmd ("urls", class_run, _("\
 508 Set the list of debuginfod server URLs."), _("\
 509 Show the list of debuginfod server URLs."), _("\
 510 Manage the space-separated list of debuginfod server URLs that GDB will query \
 511 when missing debuginfo, executables or source files.\nThe default value is \
 512 copied from the DEBUGINFOD_URLS environment variable."),
 513                                    set_debuginfod_urls,
 514                                    get_debuginfod_urls,
 515                                    show_debuginfod_urls,
 516                                    &set_debuginfod_prefix_list,
 517                                    &show_debuginfod_prefix_list);
 518
 519   /* set/show debuginfod verbose */
 520   add_setshow_zuinteger_cmd ("verbose", class_support,
 521                              &debuginfod_verbose, _("\
 522 Set verbosity of debuginfod output."), _("\
 523 Show debuginfod debugging."), _("\
 524 When set to a non-zero value, display verbose output for each debuginfod \
 525 query.\nTo disable, set to zero.  Verbose output is displayed by default."),
 526                              nullptr,
 527                              show_debuginfod_verbose_command,
 528                              &set_debuginfod_prefix_list,
 529                              &show_debuginfod_prefix_list);
 530 }