gdb/nat/linux-osdata.c

   1 /* Linux-specific functions to retrieve OS data.
   2
   3    Copyright (C) 2009-2015 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "common-defs.h"
  21 #include "linux-osdata.h"
  22
  23 #include <sys/types.h>
  24 #include <sys/sysinfo.h>
  25 #include <ctype.h>
  26 #include <utmp.h>
  27 #include <time.h>
  28 #include <unistd.h>
  29 #include <pwd.h>
  30 #include <grp.h>
  31 #include <netdb.h>
  32 #include <netinet/in.h>
  33 #include <arpa/inet.h>
  34
  35 #include "xml-utils.h"
  36 #include "buffer.h"
  37 #include <dirent.h>
  38 #include <sys/stat.h>
  39 #include "filestuff.h"
  40
  41 #define NAMELEN(dirent) strlen ((dirent)->d_name)
  42
  43 /* Define PID_T to be a fixed size that is at least as large as pid_t,
  44    so that reading pid values embedded in /proc works
  45    consistently.  */
  46
  47 typedef long long  PID_T;
  48
  49 /* Define TIME_T to be at least as large as time_t, so that reading
  50    time values embedded in /proc works consistently.  */
  51
  52 typedef long long TIME_T;
  53
  54 #define MAX_PID_T_STRLEN  (sizeof ("-9223372036854775808") - 1)
  55
  56 /* Returns the CPU core that thread PTID is currently running on.  */
  57
  58 /* Compute and return the processor core of a given thread.  */
  59
  60 int
  61 linux_common_core_of_thread (ptid_t ptid)
  62 {
  63   char filename[sizeof ("/proc//task//stat") + 2 * MAX_PID_T_STRLEN];
  64   FILE *f;
  65   char *content = NULL;
  66   char *p;
  67   char *ts = 0;
  68   int content_read = 0;
  69   int i;
  70   int core;
  71
  72   sprintf (filename, "/proc/%lld/task/%lld/stat",
  73            (PID_T) ptid_get_pid (ptid), (PID_T) ptid_get_lwp (ptid));
  74   f = gdb_fopen_cloexec (filename, "r");
  75   if (!f)
  76     return -1;
  77
  78   for (;;)
  79     {
  80       int n;
  81       content = xrealloc (content, content_read + 1024);
  82       n = fread (content + content_read, 1, 1024, f);
  83       content_read += n;
  84       if (n < 1024)
  85         {
  86           content[content_read] = '\0';
  87           break;
  88         }
  89     }
  90
  91   /* ps command also relies on no trailing fields ever contain ')'.  */
  92   p = strrchr (content, ')');
  93   if (p != NULL)
  94     p++;
  95
  96   /* If the first field after program name has index 0, then core number is
  97      the field with index 36.  There's no constant for that anywhere.  */
  98   if (p != NULL)
  99     p = strtok_r (p, " ", &ts);
 100   for (i = 0; p != NULL && i != 36; ++i)
 101     p = strtok_r (NULL, " ", &ts);
 102
 103   if (p == NULL || sscanf (p, "%d", &core) == 0)
 104     core = -1;
 105
 106   xfree (content);
 107   fclose (f);
 108
 109   return core;
 110 }
 111
 112 /* Finds the command-line of process PID and copies it into COMMAND.
 113    At most MAXLEN characters are copied.  If the command-line cannot
 114    be found, PID is copied into command in text-form.  */
 115
 116 static void
 117 command_from_pid (char *command, int maxlen, PID_T pid)
 118 {
 119   char *stat_path = xstrprintf ("/proc/%lld/stat", pid);
 120   FILE *fp = gdb_fopen_cloexec (stat_path, "r");
 121
 122   command[0] = '\0';
 123
 124   if (fp)
 125     {
 126       /* sizeof (cmd) should be greater or equal to TASK_COMM_LEN (in
 127          include/linux/sched.h in the Linux kernel sources) plus two
 128          (for the brackets).  */
 129       char cmd[18];
 130       PID_T stat_pid;
 131       int items_read = fscanf (fp, "%lld %17s", &stat_pid, cmd);
 132
 133       if (items_read == 2 && pid == stat_pid)
 134         {
 135           cmd[strlen (cmd) - 1] = '\0'; /* Remove trailing parenthesis.  */
 136           strncpy (command, cmd + 1, maxlen); /* Ignore leading parenthesis.  */
 137         }
 138
 139       fclose (fp);
 140     }
 141   else
 142     {
 143       /* Return the PID if a /proc entry for the process cannot be found.  */
 144       snprintf (command, maxlen, "%lld", pid);
 145     }
 146
 147   command[maxlen - 1] = '\0'; /* Ensure string is null-terminated.  */
 148
 149   xfree (stat_path);
 150 }
 151
 152 /* Returns the command-line of the process with the given PID. The
 153    returned string needs to be freed using xfree after use.  */
 154
 155 static char *
 156 commandline_from_pid (PID_T pid)
 157 {
 158   char *pathname = xstrprintf ("/proc/%lld/cmdline", pid);
 159   char *commandline = NULL;
 160   FILE *f = gdb_fopen_cloexec (pathname, "r");
 161
 162   if (f)
 163     {
 164       size_t len = 0;
 165
 166       while (!feof (f))
 167         {
 168           char buf[1024];
 169           size_t read_bytes = fread (buf, 1, sizeof (buf), f);
 170
 171           if (read_bytes)
 172             {
 173               commandline = (char *) xrealloc (commandline, len + read_bytes + 1);
 174               memcpy (commandline + len, buf, read_bytes);
 175               len += read_bytes;
 176             }
 177         }
 178
 179       fclose (f);
 180
 181       if (commandline)
 182         {
 183           size_t i;
 184
 185           /* Replace null characters with spaces.  */
 186           for (i = 0; i < len; ++i)
 187             if (commandline[i] == '\0')
 188               commandline[i] = ' ';
 189
 190           commandline[len] = '\0';
 191         }
 192       else
 193         {
 194           /* Return the command in square brackets if the command-line
 195              is empty.  */
 196           commandline = (char *) xmalloc (32);
 197           commandline[0] = '[';
 198           command_from_pid (commandline + 1, 31, pid);
 199
 200           len = strlen (commandline);
 201           if (len < 31)
 202             strcat (commandline, "]");
 203         }
 204     }
 205
 206   xfree (pathname);
 207
 208   return commandline;
 209 }
 210
 211 /* Finds the user name for the user UID and copies it into USER.  At
 212    most MAXLEN characters are copied.  */
 213
 214 static void
 215 user_from_uid (char *user, int maxlen, uid_t uid)
 216 {
 217   struct passwd *pwentry = getpwuid (uid);
 218
 219   if (pwentry)
 220     {
 221       strncpy (user, pwentry->pw_name, maxlen);
 222       /* Ensure that the user name is null-terminated.  */
 223       user[maxlen - 1] = '\0';
 224     }
 225   else
 226     user[0] = '\0';
 227 }
 228
 229 /* Finds the owner of process PID and returns the user id in OWNER.
 230    Returns 0 if the owner was found, -1 otherwise.  */
 231
 232 static int
 233 get_process_owner (uid_t *owner, PID_T pid)
 234 {
 235   struct stat statbuf;
 236   char procentry[sizeof ("/proc/") + MAX_PID_T_STRLEN];
 237
 238   sprintf (procentry, "/proc/%lld", pid);
 239
 240   if (stat (procentry, &statbuf) == 0 && S_ISDIR (statbuf.st_mode))
 241     {
 242       *owner = statbuf.st_uid;
 243       return 0;
 244     }
 245   else
 246     return -1;
 247 }
 248
 249 /* Find the CPU cores used by process PID and return them in CORES.
 250    CORES points to an array of NUM_CORES elements.  */
 251
 252 static int
 253 get_cores_used_by_process (PID_T pid, int *cores, const int num_cores)
 254 {
 255   char taskdir[sizeof ("/proc/") + MAX_PID_T_STRLEN + sizeof ("/task") - 1];
 256   DIR *dir;
 257   struct dirent *dp;
 258   int task_count = 0;
 259
 260   sprintf (taskdir, "/proc/%lld/task", pid);
 261   dir = opendir (taskdir);
 262   if (dir)
 263     {
 264       while ((dp = readdir (dir)) != NULL)
 265         {
 266           PID_T tid;
 267           int core;
 268
 269           if (!isdigit (dp->d_name[0])
 270               || NAMELEN (dp) > MAX_PID_T_STRLEN)
 271             continue;
 272
 273           sscanf (dp->d_name, "%lld", &tid);
 274           core = linux_common_core_of_thread (ptid_build ((pid_t) pid,
 275                                                           (pid_t) tid, 0));
 276
 277           if (core >= 0 && core < num_cores)
 278             {
 279               ++cores[core];
 280               ++task_count;
 281             }
 282         }
 283
 284       closedir (dir);
 285     }
 286
 287   return task_count;
 288 }
 289
 290 static LONGEST
 291 linux_xfer_osdata_processes (gdb_byte *readbuf,
 292                              ULONGEST offset, ULONGEST len)
 293 {
 294   /* We make the process list snapshot when the object starts to be read.  */
 295   static const char *buf;
 296   static LONGEST len_avail = -1;
 297   static struct buffer buffer;
 298
 299   if (offset == 0)
 300     {
 301       DIR *dirp;
 302
 303       if (len_avail != -1 && len_avail != 0)
 304         buffer_free (&buffer);
 305       len_avail = 0;
 306       buf = NULL;
 307       buffer_init (&buffer);
 308       buffer_grow_str (&buffer, "<osdata type=\"processes\">\n");
 309
 310       dirp = opendir ("/proc");
 311       if (dirp)
 312         {
 313           const int num_cores = sysconf (_SC_NPROCESSORS_ONLN);
 314           struct dirent *dp;
 315
 316           while ((dp = readdir (dirp)) != NULL)
 317             {
 318               PID_T pid;
 319               uid_t owner;
 320               char user[UT_NAMESIZE];
 321               char *command_line;
 322               int *cores;
 323               int task_count;
 324               char *cores_str;
 325               int i;
 326
 327               if (!isdigit (dp->d_name[0])
 328                   || NAMELEN (dp) > MAX_PID_T_STRLEN)
 329                 continue;
 330
 331               sscanf (dp->d_name, "%lld", &pid);
 332               command_line = commandline_from_pid (pid);
 333
 334               if (get_process_owner (&owner, pid) == 0)
 335                 user_from_uid (user, sizeof (user), owner);
 336               else
 337                 strcpy (user, "?");
 338
 339               /* Find CPU cores used by the process.  */
 340               cores = (int *) xcalloc (num_cores, sizeof (int));
 341               task_count = get_cores_used_by_process (pid, cores, num_cores);
 342               cores_str = (char *) xcalloc (task_count, sizeof ("4294967295") + 1);
 343
 344               for (i = 0; i < num_cores && task_count > 0; ++i)
 345                 if (cores[i])
 346                   {
 347                     char core_str[sizeof ("4294967295")];
 348
 349                     sprintf (core_str, "%d", i);
 350                     strcat (cores_str, core_str);
 351
 352                     task_count -= cores[i];
 353                     if (task_count > 0)
 354                       strcat (cores_str, ",");
 355                   }
 356
 357               xfree (cores);
 358
 359               buffer_xml_printf (
 360                   &buffer,
 361                   "<item>"
 362                   "<column name=\"pid\">%lld</column>"
 363                   "<column name=\"user\">%s</column>"
 364                   "<column name=\"command\">%s</column>"
 365                   "<column name=\"cores\">%s</column>"
 366                   "</item>",
 367                   pid,
 368                   user,
 369                   command_line ? command_line : "",
 370                   cores_str);
 371
 372               xfree (command_line);
 373               xfree (cores_str);
 374             }
 375
 376           closedir (dirp);
 377         }
 378
 379       buffer_grow_str0 (&buffer, "</osdata>\n");
 380       buf = buffer_finish (&buffer);
 381       len_avail = strlen (buf);
 382     }
 383
 384   if (offset >= len_avail)
 385     {
 386       /* Done.  Get rid of the buffer.  */
 387       buffer_free (&buffer);
 388       buf = NULL;
 389       len_avail = 0;
 390       return 0;
 391     }
 392
 393   if (len > len_avail - offset)
 394     len = len_avail - offset;
 395   memcpy (readbuf, buf + offset, len);
 396
 397   return len;
 398 }
 399
 400 /* Auxiliary function used by qsort to sort processes by process
 401    group.  Compares two processes with ids PROCESS1 and PROCESS2.
 402    PROCESS1 comes before PROCESS2 if it has a lower process group id.
 403    If they belong to the same process group, PROCESS1 comes before
 404    PROCESS2 if it has a lower process id or is the process group
 405    leader.  */
 406
 407 static int
 408 compare_processes (const void *process1, const void *process2)
 409 {
 410   PID_T pid1 = *((PID_T *) process1);
 411   PID_T pid2 = *((PID_T *) process2);
 412   PID_T pgid1 = *((PID_T *) process1 + 1);
 413   PID_T pgid2 = *((PID_T *) process2 + 1);
 414
 415   /* Sort by PGID.  */
 416   if (pgid1 < pgid2)
 417     return -1;
 418   else if (pgid1 > pgid2)
 419     return 1;
 420   else
 421     {
 422       /* Process group leaders always come first, else sort by PID.  */
 423       if (pid1 == pgid1)
 424         return -1;
 425       else if (pid2 == pgid2)
 426         return 1;
 427       else if (pid1 < pid2)
 428         return -1;
 429       else if (pid1 > pid2)
 430         return 1;
 431       else
 432         return 0;
 433     }
 434 }
 435
 436 /* Collect all process groups from /proc.  */
 437
 438 static LONGEST
 439 linux_xfer_osdata_processgroups (gdb_byte *readbuf,
 440                                  ULONGEST offset, ULONGEST len)
 441 {
 442   /* We make the process list snapshot when the object starts to be read.  */
 443   static const char *buf;
 444   static LONGEST len_avail = -1;
 445   static struct buffer buffer;
 446
 447   if (offset == 0)
 448     {
 449       DIR *dirp;
 450
 451       if (len_avail != -1 && len_avail != 0)
 452         buffer_free (&buffer);
 453       len_avail = 0;
 454       buf = NULL;
 455       buffer_init (&buffer);
 456       buffer_grow_str (&buffer, "<osdata type=\"process groups\">\n");
 457
 458       dirp = opendir ("/proc");
 459       if (dirp)
 460         {
 461           struct dirent *dp;
 462           const size_t list_block_size = 512;
 463           PID_T *process_list = (PID_T *) xmalloc (list_block_size * 2 * sizeof (PID_T));
 464           size_t process_count = 0;
 465           size_t i;
 466
 467           /* Build list consisting of PIDs followed by their
 468              associated PGID.  */
 469           while ((dp = readdir (dirp)) != NULL)
 470             {
 471               PID_T pid, pgid;
 472
 473               if (!isdigit (dp->d_name[0])
 474                   || NAMELEN (dp) > MAX_PID_T_STRLEN)
 475                 continue;
 476
 477               sscanf (dp->d_name, "%lld", &pid);
 478               pgid = getpgid (pid);
 479
 480               if (pgid > 0)
 481                 {
 482                   process_list[2 * process_count] = pid;
 483                   process_list[2 * process_count + 1] = pgid;
 484                   ++process_count;
 485
 486                   /* Increase the size of the list if necessary.  */
 487                   if (process_count % list_block_size == 0)
 488                     process_list = (PID_T *) xrealloc (
 489                         process_list,
 490                         (process_count + list_block_size)
 491                         * 2 * sizeof (PID_T));
 492                 }
 493             }
 494
 495           closedir (dirp);
 496
 497           /* Sort the process list.  */
 498           qsort (process_list, process_count, 2 * sizeof (PID_T),
 499                  compare_processes);
 500
 501           for (i = 0; i < process_count; ++i)
 502             {
 503               PID_T pid = process_list[2 * i];
 504               PID_T pgid = process_list[2 * i + 1];
 505               char leader_command[32];
 506               char *command_line;
 507
 508               command_from_pid (leader_command, sizeof (leader_command), pgid);
 509               command_line = commandline_from_pid (pid);
 510
 511               buffer_xml_printf (
 512                   &buffer,
 513                   "<item>"
 514                   "<column name=\"pgid\">%lld</column>"
 515                   "<column name=\"leader command\">%s</column>"
 516                   "<column name=\"pid\">%lld</column>"
 517                   "<column name=\"command line\">%s</column>"
 518                   "</item>",
 519                   pgid,
 520                   leader_command,
 521                   pid,
 522                   command_line ? command_line : "");
 523
 524               xfree (command_line);
 525             }
 526
 527           xfree (process_list);
 528         }
 529
 530       buffer_grow_str0 (&buffer, "</osdata>\n");
 531       buf = buffer_finish (&buffer);
 532       len_avail = strlen (buf);
 533     }
 534
 535   if (offset >= len_avail)
 536     {
 537       /* Done.  Get rid of the buffer.  */
 538       buffer_free (&buffer);
 539       buf = NULL;
 540       len_avail = 0;
 541       return 0;
 542     }
 543
 544   if (len > len_avail - offset)
 545     len = len_avail - offset;
 546   memcpy (readbuf, buf + offset, len);
 547
 548   return len;
 549 }
 550
 551 /* Collect all the threads in /proc by iterating through processes and
 552    then tasks within each process.  */
 553
 554 static LONGEST
 555 linux_xfer_osdata_threads (gdb_byte *readbuf,
 556                            ULONGEST offset, ULONGEST len)
 557 {
 558   /* We make the process list snapshot when the object starts to be read.  */
 559   static const char *buf;
 560   static LONGEST len_avail = -1;
 561   static struct buffer buffer;
 562
 563   if (offset == 0)
 564     {
 565       DIR *dirp;
 566
 567       if (len_avail != -1 && len_avail != 0)
 568         buffer_free (&buffer);
 569       len_avail = 0;
 570       buf = NULL;
 571       buffer_init (&buffer);
 572       buffer_grow_str (&buffer, "<osdata type=\"threads\">\n");
 573
 574       dirp = opendir ("/proc");
 575       if (dirp)
 576         {
 577           struct dirent *dp;
 578
 579           while ((dp = readdir (dirp)) != NULL)
 580             {
 581               struct stat statbuf;
 582               char procentry[sizeof ("/proc/4294967295")];
 583
 584               if (!isdigit (dp->d_name[0])
 585                   || NAMELEN (dp) > sizeof ("4294967295") - 1)
 586                 continue;
 587
 588               sprintf (procentry, "/proc/%s", dp->d_name);
 589               if (stat (procentry, &statbuf) == 0
 590                   && S_ISDIR (statbuf.st_mode))
 591                 {
 592                   DIR *dirp2;
 593                   char *pathname;
 594                   PID_T pid;
 595                   char command[32];
 596
 597                   pathname = xstrprintf ("/proc/%s/task", dp->d_name);
 598
 599                   pid = atoi (dp->d_name);
 600                   command_from_pid (command, sizeof (command), pid);
 601
 602                   dirp2 = opendir (pathname);
 603
 604                   if (dirp2)
 605                     {
 606                       struct dirent *dp2;
 607
 608                       while ((dp2 = readdir (dirp2)) != NULL)
 609                         {
 610                           PID_T tid;
 611                           int core;
 612
 613                           if (!isdigit (dp2->d_name[0])
 614                               || NAMELEN (dp2) > sizeof ("4294967295") - 1)
 615                             continue;
 616
 617                           tid = atoi (dp2->d_name);
 618                           core = linux_common_core_of_thread (ptid_build (pid, tid, 0));
 619
 620                           buffer_xml_printf (
 621                             &buffer,
 622                             "<item>"
 623                             "<column name=\"pid\">%lld</column>"
 624                             "<column name=\"command\">%s</column>"
 625                             "<column name=\"tid\">%lld</column>"
 626                             "<column name=\"core\">%d</column>"
 627                             "</item>",
 628                             pid,
 629                             command,
 630                             tid,
 631                             core);
 632                         }
 633
 634                       closedir (dirp2);
 635                     }
 636
 637                   xfree (pathname);
 638                 }
 639             }
 640
 641           closedir (dirp);
 642         }
 643
 644       buffer_grow_str0 (&buffer, "</osdata>\n");
 645       buf = buffer_finish (&buffer);
 646       len_avail = strlen (buf);
 647     }
 648
 649   if (offset >= len_avail)
 650     {
 651       /* Done.  Get rid of the buffer.  */
 652       buffer_free (&buffer);
 653       buf = NULL;
 654       len_avail = 0;
 655       return 0;
 656     }
 657
 658   if (len > len_avail - offset)
 659     len = len_avail - offset;
 660   memcpy (readbuf, buf + offset, len);
 661
 662   return len;
 663 }
 664
 665 /* Collect all the open file descriptors found in /proc and put the details
 666    found about them into READBUF.  */
 667
 668 static LONGEST
 669 linux_xfer_osdata_fds (gdb_byte *readbuf,
 670                        ULONGEST offset, ULONGEST len)
 671 {
 672   /* We make the process list snapshot when the object starts to be read.  */
 673   static const char *buf;
 674   static LONGEST len_avail = -1;
 675   static struct buffer buffer;
 676
 677   if (offset == 0)
 678     {
 679       DIR *dirp;
 680
 681       if (len_avail != -1 && len_avail != 0)
 682         buffer_free (&buffer);
 683       len_avail = 0;
 684       buf = NULL;
 685       buffer_init (&buffer);
 686       buffer_grow_str (&buffer, "<osdata type=\"files\">\n");
 687
 688       dirp = opendir ("/proc");
 689       if (dirp)
 690         {
 691           struct dirent *dp;
 692
 693           while ((dp = readdir (dirp)) != NULL)
 694             {
 695               struct stat statbuf;
 696               char procentry[sizeof ("/proc/4294967295")];
 697
 698               if (!isdigit (dp->d_name[0])
 699                   || NAMELEN (dp) > sizeof ("4294967295") - 1)
 700                 continue;
 701
 702               sprintf (procentry, "/proc/%s", dp->d_name);
 703               if (stat (procentry, &statbuf) == 0
 704                   && S_ISDIR (statbuf.st_mode))
 705                 {
 706                   char *pathname;
 707                   DIR *dirp2;
 708                   PID_T pid;
 709                   char command[32];
 710
 711                   pid = atoi (dp->d_name);
 712                   command_from_pid (command, sizeof (command), pid);
 713
 714                   pathname = xstrprintf ("/proc/%s/fd", dp->d_name);
 715                   dirp2 = opendir (pathname);
 716
 717                   if (dirp2)
 718                     {
 719                       struct dirent *dp2;
 720
 721                       while ((dp2 = readdir (dirp2)) != NULL)
 722                         {
 723                           char *fdname;
 724                           char buf[1000];
 725                           ssize_t rslt;
 726
 727                           if (!isdigit (dp2->d_name[0]))
 728                             continue;
 729
 730                           fdname = xstrprintf ("%s/%s", pathname, dp2->d_name);
 731                           rslt = readlink (fdname, buf, sizeof (buf) - 1);
 732                           if (rslt >= 0)
 733                             buf[rslt] = '\0';
 734
 735                           buffer_xml_printf (
 736                             &buffer,
 737                             "<item>"
 738                             "<column name=\"pid\">%s</column>"
 739                             "<column name=\"command\">%s</column>"
 740                             "<column name=\"file descriptor\">%s</column>"
 741                             "<column name=\"name\">%s</column>"
 742                             "</item>",
 743                             dp->d_name,
 744                             command,
 745                             dp2->d_name,
 746                             (rslt >= 0 ? buf : dp2->d_name));
 747                         }
 748
 749                       closedir (dirp2);
 750                     }
 751
 752                   xfree (pathname);
 753                 }
 754             }
 755
 756           closedir (dirp);
 757         }
 758
 759       buffer_grow_str0 (&buffer, "</osdata>\n");
 760       buf = buffer_finish (&buffer);
 761       len_avail = strlen (buf);
 762     }
 763
 764   if (offset >= len_avail)
 765     {
 766       /* Done.  Get rid of the buffer.  */
 767       buffer_free (&buffer);
 768       buf = NULL;
 769       len_avail = 0;
 770       return 0;
 771     }
 772
 773   if (len > len_avail - offset)
 774     len = len_avail - offset;
 775   memcpy (readbuf, buf + offset, len);
 776
 777   return len;
 778 }
 779
 780 /* Returns the socket state STATE in textual form.  */
 781
 782 static const char *
 783 format_socket_state (unsigned char state)
 784 {
 785   /* Copied from include/net/tcp_states.h in the Linux kernel sources.  */
 786   enum {
 787     TCP_ESTABLISHED = 1,
 788     TCP_SYN_SENT,
 789     TCP_SYN_RECV,
 790     TCP_FIN_WAIT1,
 791     TCP_FIN_WAIT2,
 792     TCP_TIME_WAIT,
 793     TCP_CLOSE,
 794     TCP_CLOSE_WAIT,
 795     TCP_LAST_ACK,
 796     TCP_LISTEN,
 797     TCP_CLOSING
 798   };
 799
 800   switch (state)
 801     {
 802     case TCP_ESTABLISHED:
 803       return "ESTABLISHED";
 804     case TCP_SYN_SENT:
 805       return "SYN_SENT";
 806     case TCP_SYN_RECV:
 807       return "SYN_RECV";
 808     case TCP_FIN_WAIT1:
 809       return "FIN_WAIT1";
 810     case TCP_FIN_WAIT2:
 811       return "FIN_WAIT2";
 812     case TCP_TIME_WAIT:
 813       return "TIME_WAIT";
 814     case TCP_CLOSE:
 815       return "CLOSE";
 816     case TCP_CLOSE_WAIT:
 817       return "CLOSE_WAIT";
 818     case TCP_LAST_ACK:
 819       return "LAST_ACK";
 820     case TCP_LISTEN:
 821       return "LISTEN";
 822     case TCP_CLOSING:
 823       return "CLOSING";
 824     default:
 825       return "(unknown)";
 826     }
 827 }
 828
 829 union socket_addr
 830   {
 831     struct sockaddr sa;
 832     struct sockaddr_in sin;
 833     struct sockaddr_in6 sin6;
 834   };
 835
 836 /* Auxiliary function used by linux_xfer_osdata_isocket.  Formats
 837    information for all open internet sockets of type FAMILY on the
 838    system into BUFFER.  If TCP is set, only TCP sockets are processed,
 839    otherwise only UDP sockets are processed.  */
 840
 841 static void
 842 print_sockets (unsigned short family, int tcp, struct buffer *buffer)
 843 {
 844   const char *proc_file;
 845   FILE *fp;
 846
 847   if (family == AF_INET)
 848     proc_file = tcp ? "/proc/net/tcp" : "/proc/net/udp";
 849   else if (family == AF_INET6)
 850     proc_file = tcp ? "/proc/net/tcp6" : "/proc/net/udp6";
 851   else
 852     return;
 853
 854   fp = gdb_fopen_cloexec (proc_file, "r");
 855   if (fp)
 856     {
 857       char buf[8192];
 858
 859       do
 860         {
 861           if (fgets (buf, sizeof (buf), fp))
 862             {
 863               uid_t uid;
 864               unsigned int local_port, remote_port, state;
 865               char local_address[NI_MAXHOST], remote_address[NI_MAXHOST];
 866               int result;
 867
 868 #if NI_MAXHOST <= 32
 869 #error "local_address and remote_address buffers too small"
 870 #endif
 871
 872               result = sscanf (buf,
 873                                "%*d: %32[0-9A-F]:%X %32[0-9A-F]:%X %X %*X:%*X %*X:%*X %*X %d %*d %*u %*s\n",
 874                                local_address, &local_port,
 875                                remote_address, &remote_port,
 876                                &state,
 877                                &uid);
 878
 879               if (result == 6)
 880                 {
 881                   union socket_addr locaddr, remaddr;
 882                   size_t addr_size;
 883                   char user[UT_NAMESIZE];
 884                   char local_service[NI_MAXSERV], remote_service[NI_MAXSERV];
 885
 886                   if (family == AF_INET)
 887                     {
 888                       sscanf (local_address, "%X",
 889                               &locaddr.sin.sin_addr.s_addr);
 890                       sscanf (remote_address, "%X",
 891                               &remaddr.sin.sin_addr.s_addr);
 892
 893                       locaddr.sin.sin_port = htons (local_port);
 894                       remaddr.sin.sin_port = htons (remote_port);
 895
 896                       addr_size = sizeof (struct sockaddr_in);
 897                     }
 898                   else
 899                     {
 900                       sscanf (local_address, "%8X%8X%8X%8X",
 901                               locaddr.sin6.sin6_addr.s6_addr32,
 902                               locaddr.sin6.sin6_addr.s6_addr32 + 1,
 903                               locaddr.sin6.sin6_addr.s6_addr32 + 2,
 904                               locaddr.sin6.sin6_addr.s6_addr32 + 3);
 905                       sscanf (remote_address, "%8X%8X%8X%8X",
 906                               remaddr.sin6.sin6_addr.s6_addr32,
 907                               remaddr.sin6.sin6_addr.s6_addr32 + 1,
 908                               remaddr.sin6.sin6_addr.s6_addr32 + 2,
 909                               remaddr.sin6.sin6_addr.s6_addr32 + 3);
 910
 911                       locaddr.sin6.sin6_port = htons (local_port);
 912                       remaddr.sin6.sin6_port = htons (remote_port);
 913
 914                       locaddr.sin6.sin6_flowinfo = 0;
 915                       remaddr.sin6.sin6_flowinfo = 0;
 916                       locaddr.sin6.sin6_scope_id = 0;
 917                       remaddr.sin6.sin6_scope_id = 0;
 918
 919                       addr_size = sizeof (struct sockaddr_in6);
 920                     }
 921
 922                   locaddr.sa.sa_family = remaddr.sa.sa_family = family;
 923
 924                   result = getnameinfo (&locaddr.sa, addr_size,
 925                                         local_address, sizeof (local_address),
 926                                         local_service, sizeof (local_service),
 927                                         NI_NUMERICHOST | NI_NUMERICSERV
 928                                         | (tcp ? 0 : NI_DGRAM));
 929                   if (result)
 930                     continue;
 931
 932                   result = getnameinfo (&remaddr.sa, addr_size,
 933                                         remote_address,
 934                                         sizeof (remote_address),
 935                                         remote_service,
 936                                         sizeof (remote_service),
 937                                         NI_NUMERICHOST | NI_NUMERICSERV
 938                                         | (tcp ? 0 : NI_DGRAM));
 939                   if (result)
 940                     continue;
 941
 942                   user_from_uid (user, sizeof (user), uid);
 943
 944                   buffer_xml_printf (
 945                       buffer,
 946                       "<item>"
 947                       "<column name=\"local address\">%s</column>"
 948                       "<column name=\"local port\">%s</column>"
 949                       "<column name=\"remote address\">%s</column>"
 950                       "<column name=\"remote port\">%s</column>"
 951                       "<column name=\"state\">%s</column>"
 952                       "<column name=\"user\">%s</column>"
 953                       "<column name=\"family\">%s</column>"
 954                       "<column name=\"protocol\">%s</column>"
 955                       "</item>",
 956                       local_address,
 957                       local_service,
 958                       remote_address,
 959                       remote_service,
 960                       format_socket_state (state),
 961                       user,
 962                       (family == AF_INET) ? "INET" : "INET6",
 963                       tcp ? "STREAM" : "DGRAM");
 964                 }
 965             }
 966         }
 967       while (!feof (fp));
 968
 969       fclose (fp);
 970     }
 971 }
 972
 973 /* Collect data about internet sockets and write it into READBUF.  */
 974
 975 static LONGEST
 976 linux_xfer_osdata_isockets (gdb_byte *readbuf,
 977                             ULONGEST offset, ULONGEST len)
 978 {
 979   static const char *buf;
 980   static LONGEST len_avail = -1;
 981   static struct buffer buffer;
 982
 983   if (offset == 0)
 984     {
 985       if (len_avail != -1 && len_avail != 0)
 986         buffer_free (&buffer);
 987       len_avail = 0;
 988       buf = NULL;
 989       buffer_init (&buffer);
 990       buffer_grow_str (&buffer, "<osdata type=\"I sockets\">\n");
 991
 992       print_sockets (AF_INET, 1, &buffer);
 993       print_sockets (AF_INET, 0, &buffer);
 994       print_sockets (AF_INET6, 1, &buffer);
 995       print_sockets (AF_INET6, 0, &buffer);
 996
 997       buffer_grow_str0 (&buffer, "</osdata>\n");
 998       buf = buffer_finish (&buffer);
 999       len_avail = strlen (buf);
1000     }
1001
1002   if (offset >= len_avail)
1003     {
1004       /* Done.  Get rid of the buffer.  */
1005       buffer_free (&buffer);
1006       buf = NULL;
1007       len_avail = 0;
1008       return 0;
1009     }
1010
1011   if (len > len_avail - offset)
1012     len = len_avail - offset;
1013   memcpy (readbuf, buf + offset, len);
1014
1015   return len;
1016 }
1017
1018 /* Converts the time SECONDS into textual form and copies it into a
1019    buffer TIME, with at most MAXLEN characters copied.  */
1020
1021 static void
1022 time_from_time_t (char *time, int maxlen, TIME_T seconds)
1023 {
1024   if (!seconds)
1025     time[0] = '\0';
1026   else
1027     {
1028       time_t t = (time_t) seconds;
1029
1030       strncpy (time, ctime (&t), maxlen);
1031       time[maxlen - 1] = '\0';
1032     }
1033 }
1034
1035 /* Finds the group name for the group GID and copies it into GROUP.
1036    At most MAXLEN characters are copied.  */
1037
1038 static void
1039 group_from_gid (char *group, int maxlen, gid_t gid)
1040 {
1041   struct group *grentry = getgrgid (gid);
1042
1043   if (grentry)
1044     {
1045       strncpy (group, grentry->gr_name, maxlen);
1046       /* Ensure that the group name is null-terminated.  */
1047       group[maxlen - 1] = '\0';
1048     }
1049   else
1050     group[0] = '\0';
1051 }
1052
1053 /* Collect data about shared memory recorded in /proc and write it
1054    into READBUF.  */
1055
1056 static LONGEST
1057 linux_xfer_osdata_shm (gdb_byte *readbuf,
1058                        ULONGEST offset, ULONGEST len)
1059 {
1060   static const char *buf;
1061   static LONGEST len_avail = -1;
1062   static struct buffer buffer;
1063
1064   if (offset == 0)
1065     {
1066       FILE *fp;
1067
1068       if (len_avail != -1 && len_avail != 0)
1069         buffer_free (&buffer);
1070       len_avail = 0;
1071       buf = NULL;
1072       buffer_init (&buffer);
1073       buffer_grow_str (&buffer, "<osdata type=\"shared memory\">\n");
1074
1075       fp = gdb_fopen_cloexec ("/proc/sysvipc/shm", "r");
1076       if (fp)
1077         {
1078           char buf[8192];
1079
1080           do
1081             {
1082               if (fgets (buf, sizeof (buf), fp))
1083                 {
1084                   key_t key;
1085                   uid_t uid, cuid;
1086                   gid_t gid, cgid;
1087                   PID_T cpid, lpid;
1088                   int shmid, size, nattch;
1089                   TIME_T atime, dtime, ctime;
1090                   unsigned int perms;
1091                   int items_read;
1092
1093                   items_read = sscanf (buf,
1094                                        "%d %d %o %d %lld %lld %d %u %u %u %u %lld %lld %lld",
1095                                        &key, &shmid, &perms, &size,
1096                                        &cpid, &lpid,
1097                                        &nattch,
1098                                        &uid, &gid, &cuid, &cgid,
1099                                        &atime, &dtime, &ctime);
1100
1101                   if (items_read == 14)
1102                     {
1103                       char user[UT_NAMESIZE], group[UT_NAMESIZE];
1104                       char cuser[UT_NAMESIZE], cgroup[UT_NAMESIZE];
1105                       char ccmd[32], lcmd[32];
1106                       char atime_str[32], dtime_str[32], ctime_str[32];
1107
1108                       user_from_uid (user, sizeof (user), uid);
1109                       group_from_gid (group, sizeof (group), gid);
1110                       user_from_uid (cuser, sizeof (cuser), cuid);
1111                       group_from_gid (cgroup, sizeof (cgroup), cgid);
1112
1113                       command_from_pid (ccmd, sizeof (ccmd), cpid);
1114                       command_from_pid (lcmd, sizeof (lcmd), lpid);
1115
1116                       time_from_time_t (atime_str, sizeof (atime_str), atime);
1117                       time_from_time_t (dtime_str, sizeof (dtime_str), dtime);
1118                       time_from_time_t (ctime_str, sizeof (ctime_str), ctime);
1119
1120                       buffer_xml_printf (
1121                           &buffer,
1122                           "<item>"
1123                           "<column name=\"key\">%d</column>"
1124                           "<column name=\"shmid\">%d</column>"
1125                           "<column name=\"permissions\">%o</column>"
1126                           "<column name=\"size\">%d</column>"
1127                           "<column name=\"creator command\">%s</column>"
1128                           "<column name=\"last op. command\">%s</column>"
1129                           "<column name=\"num attached\">%d</column>"
1130                           "<column name=\"user\">%s</column>"
1131                           "<column name=\"group\">%s</column>"
1132                           "<column name=\"creator user\">%s</column>"
1133                           "<column name=\"creator group\">%s</column>"
1134                           "<column name=\"last shmat() time\">%s</column>"
1135                           "<column name=\"last shmdt() time\">%s</column>"
1136                           "<column name=\"last shmctl() time\">%s</column>"
1137                           "</item>",
1138                           key,
1139                           shmid,
1140                           perms,
1141                           size,
1142                           ccmd,
1143                           lcmd,
1144                           nattch,
1145                           user,
1146                           group,
1147                           cuser,
1148                           cgroup,
1149                           atime_str,
1150                           dtime_str,
1151                           ctime_str);
1152                     }
1153                 }
1154             }
1155           while (!feof (fp));
1156
1157           fclose (fp);
1158         }
1159
1160       buffer_grow_str0 (&buffer, "</osdata>\n");
1161       buf = buffer_finish (&buffer);
1162       len_avail = strlen (buf);
1163     }
1164
1165   if (offset >= len_avail)
1166     {
1167       /* Done.  Get rid of the buffer.  */
1168       buffer_free (&buffer);
1169       buf = NULL;
1170       len_avail = 0;
1171       return 0;
1172     }
1173
1174   if (len > len_avail - offset)
1175     len = len_avail - offset;
1176   memcpy (readbuf, buf + offset, len);
1177
1178   return len;
1179 }
1180
1181 /* Collect data about semaphores recorded in /proc and write it
1182    into READBUF.  */
1183
1184 static LONGEST
1185 linux_xfer_osdata_sem (gdb_byte *readbuf,
1186                        ULONGEST offset, ULONGEST len)
1187 {
1188   static const char *buf;
1189   static LONGEST len_avail = -1;
1190   static struct buffer buffer;
1191
1192   if (offset == 0)
1193     {
1194       FILE *fp;
1195
1196       if (len_avail != -1 && len_avail != 0)
1197         buffer_free (&buffer);
1198       len_avail = 0;
1199       buf = NULL;
1200       buffer_init (&buffer);
1201       buffer_grow_str (&buffer, "<osdata type=\"semaphores\">\n");
1202
1203       fp = gdb_fopen_cloexec ("/proc/sysvipc/sem", "r");
1204       if (fp)
1205         {
1206           char buf[8192];
1207
1208           do
1209             {
1210               if (fgets (buf, sizeof (buf), fp))
1211                 {
1212                   key_t key;
1213                   uid_t uid, cuid;
1214                   gid_t gid, cgid;
1215                   unsigned int perms, nsems;
1216                   int semid;
1217                   TIME_T otime, ctime;
1218                   int items_read;
1219
1220                   items_read = sscanf (buf,
1221                                        "%d %d %o %u %d %d %d %d %lld %lld",
1222                                        &key, &semid, &perms, &nsems,
1223                                        &uid, &gid, &cuid, &cgid,
1224                                        &otime, &ctime);
1225
1226                   if (items_read == 10)
1227                     {
1228                       char user[UT_NAMESIZE], group[UT_NAMESIZE];
1229                       char cuser[UT_NAMESIZE], cgroup[UT_NAMESIZE];
1230                       char otime_str[32], ctime_str[32];
1231
1232                       user_from_uid (user, sizeof (user), uid);
1233                       group_from_gid (group, sizeof (group), gid);
1234                       user_from_uid (cuser, sizeof (cuser), cuid);
1235                       group_from_gid (cgroup, sizeof (cgroup), cgid);
1236
1237                       time_from_time_t (otime_str, sizeof (otime_str), otime);
1238                       time_from_time_t (ctime_str, sizeof (ctime_str), ctime);
1239
1240                       buffer_xml_printf (
1241                           &buffer,
1242                           "<item>"
1243                           "<column name=\"key\">%d</column>"
1244                           "<column name=\"semid\">%d</column>"
1245                           "<column name=\"permissions\">%o</column>"
1246                           "<column name=\"num semaphores\">%u</column>"
1247                           "<column name=\"user\">%s</column>"
1248                           "<column name=\"group\">%s</column>"
1249                           "<column name=\"creator user\">%s</column>"
1250                           "<column name=\"creator group\">%s</column>"
1251                           "<column name=\"last semop() time\">%s</column>"
1252                           "<column name=\"last semctl() time\">%s</column>"
1253                           "</item>",
1254                           key,
1255                           semid,
1256                           perms,
1257                           nsems,
1258                           user,
1259                           group,
1260                           cuser,
1261                           cgroup,
1262                           otime_str,
1263                           ctime_str);
1264                     }
1265                 }
1266             }
1267           while (!feof (fp));
1268
1269           fclose (fp);
1270         }
1271
1272       buffer_grow_str0 (&buffer, "</osdata>\n");
1273       buf = buffer_finish (&buffer);
1274       len_avail = strlen (buf);
1275     }
1276
1277   if (offset >= len_avail)
1278     {
1279       /* Done.  Get rid of the buffer.  */
1280       buffer_free (&buffer);
1281       buf = NULL;
1282       len_avail = 0;
1283       return 0;
1284     }
1285
1286   if (len > len_avail - offset)
1287     len = len_avail - offset;
1288   memcpy (readbuf, buf + offset, len);
1289
1290   return len;
1291 }
1292
1293 /* Collect data about message queues recorded in /proc and write it
1294    into READBUF.  */
1295
1296 static LONGEST
1297 linux_xfer_osdata_msg (gdb_byte *readbuf,
1298                        ULONGEST offset, ULONGEST len)
1299 {
1300   static const char *buf;
1301   static LONGEST len_avail = -1;
1302   static struct buffer buffer;
1303
1304   if (offset == 0)
1305     {
1306       FILE *fp;
1307
1308       if (len_avail != -1 && len_avail != 0)
1309         buffer_free (&buffer);
1310       len_avail = 0;
1311       buf = NULL;
1312       buffer_init (&buffer);
1313       buffer_grow_str (&buffer, "<osdata type=\"message queues\">\n");
1314
1315       fp = gdb_fopen_cloexec ("/proc/sysvipc/msg", "r");
1316       if (fp)
1317         {
1318           char buf[8192];
1319
1320           do
1321             {
1322               if (fgets (buf, sizeof (buf), fp))
1323                 {
1324                   key_t key;
1325                   PID_T lspid, lrpid;
1326                   uid_t uid, cuid;
1327                   gid_t gid, cgid;
1328                   unsigned int perms, cbytes, qnum;
1329                   int msqid;
1330                   TIME_T stime, rtime, ctime;
1331                   int items_read;
1332
1333                   items_read = sscanf (buf,
1334                                        "%d %d %o %u %u %lld %lld %d %d %d %d %lld %lld %lld",
1335                                        &key, &msqid, &perms, &cbytes, &qnum,
1336                                        &lspid, &lrpid, &uid, &gid, &cuid, &cgid,
1337                                        &stime, &rtime, &ctime);
1338
1339                   if (items_read == 14)
1340                     {
1341                       char user[UT_NAMESIZE], group[UT_NAMESIZE];
1342                       char cuser[UT_NAMESIZE], cgroup[UT_NAMESIZE];
1343                       char lscmd[32], lrcmd[32];
1344                       char stime_str[32], rtime_str[32], ctime_str[32];
1345
1346                       user_from_uid (user, sizeof (user), uid);
1347                       group_from_gid (group, sizeof (group), gid);
1348                       user_from_uid (cuser, sizeof (cuser), cuid);
1349                       group_from_gid (cgroup, sizeof (cgroup), cgid);
1350
1351                       command_from_pid (lscmd, sizeof (lscmd), lspid);
1352                       command_from_pid (lrcmd, sizeof (lrcmd), lrpid);
1353
1354                       time_from_time_t (stime_str, sizeof (stime_str), stime);
1355                       time_from_time_t (rtime_str, sizeof (rtime_str), rtime);
1356                       time_from_time_t (ctime_str, sizeof (ctime_str), ctime);
1357
1358                       buffer_xml_printf (
1359                           &buffer,
1360                           "<item>"
1361                           "<column name=\"key\">%d</column>"
1362                           "<column name=\"msqid\">%d</column>"
1363                           "<column name=\"permissions\">%o</column>"
1364                           "<column name=\"num used bytes\">%u</column>"
1365                           "<column name=\"num messages\">%u</column>"
1366                           "<column name=\"last msgsnd() command\">%s</column>"
1367                           "<column name=\"last msgrcv() command\">%s</column>"
1368                           "<column name=\"user\">%s</column>"
1369                           "<column name=\"group\">%s</column>"
1370                           "<column name=\"creator user\">%s</column>"
1371                           "<column name=\"creator group\">%s</column>"
1372                           "<column name=\"last msgsnd() time\">%s</column>"
1373                           "<column name=\"last msgrcv() time\">%s</column>"
1374                           "<column name=\"last msgctl() time\">%s</column>"
1375                           "</item>",
1376                           key,
1377                           msqid,
1378                           perms,
1379                           cbytes,
1380                           qnum,
1381                           lscmd,
1382                           lrcmd,
1383                           user,
1384                           group,
1385                           cuser,
1386                           cgroup,
1387                           stime_str,
1388                           rtime_str,
1389                           ctime_str);
1390                     }
1391                 }
1392             }
1393           while (!feof (fp));
1394
1395           fclose (fp);
1396         }
1397
1398       buffer_grow_str0 (&buffer, "</osdata>\n");
1399       buf = buffer_finish (&buffer);
1400       len_avail = strlen (buf);
1401     }
1402
1403   if (offset >= len_avail)
1404     {
1405       /* Done.  Get rid of the buffer.  */
1406       buffer_free (&buffer);
1407       buf = NULL;
1408       len_avail = 0;
1409       return 0;
1410     }
1411
1412   if (len > len_avail - offset)
1413     len = len_avail - offset;
1414   memcpy (readbuf, buf + offset, len);
1415
1416   return len;
1417 }
1418
1419 /* Collect data about loaded kernel modules and write it into
1420    READBUF.  */
1421
1422 static LONGEST
1423 linux_xfer_osdata_modules (gdb_byte *readbuf,
1424                            ULONGEST offset, ULONGEST len)
1425 {
1426   static const char *buf;
1427   static LONGEST len_avail = -1;
1428   static struct buffer buffer;
1429
1430   if (offset == 0)
1431     {
1432       FILE *fp;
1433
1434       if (len_avail != -1 && len_avail != 0)
1435         buffer_free (&buffer);
1436       len_avail = 0;
1437       buf = NULL;
1438       buffer_init (&buffer);
1439       buffer_grow_str (&buffer, "<osdata type=\"modules\">\n");
1440
1441       fp = gdb_fopen_cloexec ("/proc/modules", "r");
1442       if (fp)
1443         {
1444           char buf[8192];
1445
1446           do
1447             {
1448               if (fgets (buf, sizeof (buf), fp))
1449                 {
1450                   char *name, *dependencies, *status, *tmp;
1451                   unsigned int size;
1452                   unsigned long long address;
1453                   int uses;
1454
1455                   name = strtok (buf, " ");
1456                   if (name == NULL)
1457                     continue;
1458
1459                   tmp = strtok (NULL, " ");
1460                   if (tmp == NULL)
1461                     continue;
1462                   if (sscanf (tmp, "%u", &size) != 1)
1463                     continue;
1464
1465                   tmp = strtok (NULL, " ");
1466                   if (tmp == NULL)
1467                     continue;
1468                   if (sscanf (tmp, "%d", &uses) != 1)
1469                     continue;
1470
1471                   dependencies = strtok (NULL, " ");
1472                   if (dependencies == NULL)
1473                     continue;
1474
1475                   status = strtok (NULL, " ");
1476                   if (status == NULL)
1477                     continue;
1478
1479                   tmp = strtok (NULL, "\n");
1480                   if (tmp == NULL)
1481                     continue;
1482                   if (sscanf (tmp, "%llx", &address) != 1)
1483                     continue;
1484
1485                   buffer_xml_printf (
1486                         &buffer,
1487                         "<item>"
1488                         "<column name=\"name\">%s</column>"
1489                         "<column name=\"size\">%u</column>"
1490                         "<column name=\"num uses\">%d</column>"
1491                         "<column name=\"dependencies\">%s</column>"
1492                         "<column name=\"status\">%s</column>"
1493                         "<column name=\"address\">%llx</column>"
1494                         "</item>",
1495                         name,
1496                         size,
1497                         uses,
1498                         dependencies,
1499                         status,
1500                         address);
1501                 }
1502             }
1503           while (!feof (fp));
1504
1505           fclose (fp);
1506         }
1507
1508       buffer_grow_str0 (&buffer, "</osdata>\n");
1509       buf = buffer_finish (&buffer);
1510       len_avail = strlen (buf);
1511     }
1512
1513   if (offset >= len_avail)
1514     {
1515       /* Done.  Get rid of the buffer.  */
1516       buffer_free (&buffer);
1517       buf = NULL;
1518       len_avail = 0;
1519       return 0;
1520     }
1521
1522   if (len > len_avail - offset)
1523     len = len_avail - offset;
1524   memcpy (readbuf, buf + offset, len);
1525
1526   return len;
1527 }
1528
1529 struct osdata_type {
1530   char *type;
1531   char *title;
1532   char *description;
1533   LONGEST (*getter) (gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
1534 } osdata_table[] = {
1535   { "processes", "Processes", "Listing of all processes",
1536     linux_xfer_osdata_processes },
1537   { "procgroups", "Process groups", "Listing of all process groups",
1538     linux_xfer_osdata_processgroups },
1539   { "threads", "Threads", "Listing of all threads",
1540     linux_xfer_osdata_threads },
1541   { "files", "File descriptors", "Listing of all file descriptors",
1542     linux_xfer_osdata_fds },
1543   { "sockets", "Sockets", "Listing of all internet-domain sockets",
1544     linux_xfer_osdata_isockets },
1545   { "shm", "Shared-memory regions", "Listing of all shared-memory regions",
1546     linux_xfer_osdata_shm },
1547   { "semaphores", "Semaphores", "Listing of all semaphores",
1548     linux_xfer_osdata_sem },
1549   { "msg", "Message queues", "Listing of all message queues",
1550     linux_xfer_osdata_msg },
1551   { "modules", "Kernel modules", "Listing of all loaded kernel modules",
1552     linux_xfer_osdata_modules },
1553   { NULL, NULL, NULL }
1554 };
1555
1556 LONGEST
1557 linux_common_xfer_osdata (const char *annex, gdb_byte *readbuf,
1558                           ULONGEST offset, ULONGEST len)
1559 {
1560   if (!annex || *annex == '\0')
1561     {
1562       static const char *buf;
1563       static LONGEST len_avail = -1;
1564       static struct buffer buffer;
1565
1566       if (offset == 0)
1567         {
1568           int i;
1569
1570           if (len_avail != -1 && len_avail != 0)
1571             buffer_free (&buffer);
1572           len_avail = 0;
1573           buf = NULL;
1574           buffer_init (&buffer);
1575           buffer_grow_str (&buffer, "<osdata type=\"types\">\n");
1576
1577           for (i = 0; osdata_table[i].type; ++i)
1578             buffer_xml_printf (
1579                                &buffer,
1580                                "<item>"
1581                                "<column name=\"Type\">%s</column>"
1582                                "<column name=\"Description\">%s</column>"
1583                                "<column name=\"Title\">%s</column>"
1584                                "</item>",
1585                                osdata_table[i].type,
1586                                osdata_table[i].description,
1587                                osdata_table[i].title);
1588
1589           buffer_grow_str0 (&buffer, "</osdata>\n");
1590           buf = buffer_finish (&buffer);
1591           len_avail = strlen (buf);
1592         }
1593
1594       if (offset >= len_avail)
1595         {
1596           /* Done.  Get rid of the buffer.  */
1597           buffer_free (&buffer);
1598           buf = NULL;
1599           len_avail = 0;
1600           return 0;
1601         }
1602
1603       if (len > len_avail - offset)
1604         len = len_avail - offset;
1605       memcpy (readbuf, buf + offset, len);
1606
1607       return len;
1608     }
1609   else
1610     {
1611       int i;
1612
1613       for (i = 0; osdata_table[i].type; ++i)
1614         {
1615           if (strcmp (annex, osdata_table[i].type) == 0)
1616             {
1617               gdb_assert (readbuf);
1618
1619               return (osdata_table[i].getter) (readbuf, offset, len);
1620             }
1621         }
1622
1623       return 0;
1624     }
1625 }
1626