2012-05-11 Stan Shebs <stan@codesourcery.com>
authorStan Shebs <shebs@codesourcery.com>
Fri, 11 May 2012 22:24:24 +0000 (22:24 +0000)
committerStan Shebs <shebs@codesourcery.com>
Fri, 11 May 2012 22:24:24 +0000 (22:24 +0000)
    Kwok Cheung Yeung  <kcy@codesourcery.com>

* NEWS: Describe new info os commands.
* common/linux-osdata.c (PID_T, TIME_T): Define.
(MAX_PID_T_STRLEN): New.
(linux_common_core_of_thread): Add comment.  Change to use PID_T and
MAX_PID_T_STRLEN.
(command_from_pid): Add comment.  Change to use PID_T.
(commandline_from_pid):  Change to use PID_T.
(user_from_pid): Add comment.
(get_process_owner): Add comment. Change to use PID_T and
MAX_PID_T_STRLEN.
(get_number_of_cpu_cores): Add comment.
(get_cores_used_by_process): Add comment.  Change to use PID_T and
MAX_PID_T_STRLEN.
(linux_xfer_osdata_processes): Change to use PID_T and
MAX_PID_T_STRLEN.
(compare_processes): New function.
(linux_xfer_osdata_processgroups): New function.
(linux_xfer_osdata_threads): Change to use PID_T.
(linux_xfer_osdata_fds): New function.
(format_socket_state, print_sockets): New functions.
(union socket_addr): New union.
(linux_xfer_osdata_isockets): New function.
(time_from_time_t, group_from_gid): New functions.
(linux_xfer_osdata_shm): New function.
(linux_xfer_osdata_sem): New function.
(linux_xfer_osdata_msg): New function.
(linux_xfer_osdata_modules): New function.
(osdata_table): Add new entries.
* common/buffer.c (buffer_xml_printf): Add support for long and
long long format specifiers.

* gdb.texinfo (Operating System Auxiliary Information): Document new
'info os' subcommands.

* gdb.base/info-os.exp: New file.
* gdb.base/info-os.c: New file.

gdb/ChangeLog
gdb/NEWS
gdb/common/buffer.c
gdb/common/linux-osdata.c
gdb/doc/ChangeLog
gdb/doc/gdb.texinfo
gdb/testsuite/ChangeLog
gdb/testsuite/gdb.base/info-os.c [new file with mode: 0644]
gdb/testsuite/gdb.base/info-os.exp [new file with mode: 0644]

index 1df5d27835e1980528f9d6b351a9944e4f0e2972..d22053699aaa9f42cb02fbafd35047b6a089ae4d 100644 (file)
@@ -1,3 +1,37 @@
+2012-05-11  Stan Shebs  <stan@codesourcery.com>
+           Kwok Cheung Yeung  <kcy@codesourcery.com>
+
+       * NEWS: Describe new info os commands.
+       * common/linux-osdata.c (PID_T, TIME_T): Define.
+       (MAX_PID_T_STRLEN): New.
+       (linux_common_core_of_thread): Add comment.  Change to use PID_T and
+       MAX_PID_T_STRLEN.
+       (command_from_pid): Add comment.  Change to use PID_T.
+       (commandline_from_pid):  Change to use PID_T.
+       (user_from_pid): Add comment.
+       (get_process_owner): Add comment. Change to use PID_T and
+       MAX_PID_T_STRLEN.
+       (get_number_of_cpu_cores): Add comment.
+       (get_cores_used_by_process): Add comment.  Change to use PID_T and
+       MAX_PID_T_STRLEN.
+       (linux_xfer_osdata_processes): Change to use PID_T and
+       MAX_PID_T_STRLEN.
+       (compare_processes): New function.
+       (linux_xfer_osdata_processgroups): New function.
+       (linux_xfer_osdata_threads): Change to use PID_T.
+       (linux_xfer_osdata_fds): New function.
+       (format_socket_state, print_sockets): New functions.
+       (union socket_addr): New union.
+       (linux_xfer_osdata_isockets): New function.
+       (time_from_time_t, group_from_gid): New functions.
+       (linux_xfer_osdata_shm): New function.
+       (linux_xfer_osdata_sem): New function.
+       (linux_xfer_osdata_msg): New function.
+       (linux_xfer_osdata_modules): New function.
+       (osdata_table): Add new entries.
+       * common/buffer.c (buffer_xml_printf): Add support for long and
+       long long format specifiers.
+
 2012-05-11  H.J. Lu  <hongjiu.lu@intel.com>
 
        * amd64-linux-tdep.h (tdesc_x32_linux): New.
index e6b7bbf2faaef45a1cb6452ab68dde0780a8b591..f89359322f137f5f9772c26333162155fee3086f 100644 (file)
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -3,6 +3,16 @@
 
 *** Changes since GDB 7.4
 
+* The "info os" command on GNU/Linux can now display information on
+  several new classes of objects managed by the operating system:
+    "info os procgroups" lists process groups
+    "info os files" lists file descriptors
+    "info os sockets" lists internet-domain sockets
+    "info os shm" lists shared-memory regions
+    "info os semaphores" lists semaphores
+    "info os msg" lists message queues
+    "info os modules" lists loaded kernel modules
+
 * GDB now has support for SDT (Static Defined Tracing) probes.  Currently,
   the only implemented backend is for SystemTap probes (<sys/sdt.h>).  You
   can set a breakpoint using the new "-probe, "-pstap" or "-probe-stap"
index 37b7b55f7488d35899cd0546a2e15177b1dd03a1..059dd6823b125420fec5cce996ebaac91e01f255 100644 (file)
@@ -101,6 +101,7 @@ buffer_xml_printf (struct buffer *buffer, const char *format, ...)
          char buf[32];
          char *p;
          char *str = buf;
+         const char *f_old = f;
          
          switch (*f)
            {
@@ -119,14 +120,56 @@ buffer_xml_printf (struct buffer *buffer, const char *format, ...)
            case 'o':
              sprintf (str, "%o", va_arg (ap, unsigned int));
              break;
+           case 'l':
+             f++;
+             switch (*f)
+               {
+               case 'd':
+                 sprintf (str, "%ld", va_arg (ap, long));
+                 break;
+               case 'u':
+                 sprintf (str, "%lu", va_arg (ap, unsigned long));
+                 break;
+               case 'x':
+                 sprintf (str, "%lx", va_arg (ap, unsigned long));
+                 break;
+               case 'o':
+                 sprintf (str, "%lo", va_arg (ap, unsigned long));
+                 break;
+               case 'l':
+                 f++;
+                 switch (*f)
+                   {
+                   case 'd':
+                     sprintf (str, "%lld", va_arg (ap, long long));
+                     break;
+                   case 'u':
+                     sprintf (str, "%llu", va_arg (ap, unsigned long long));
+                     break;
+                   case 'x':
+                     sprintf (str, "%llx", va_arg (ap, unsigned long long));
+                     break;
+                   case 'o':
+                     sprintf (str, "%llo", va_arg (ap, unsigned long long));
+                     break;
+                   default:
+                     str = 0;
+                     break;
+                   }
+                 break;
+               default:
+                 str = 0;
+                 break;
+               }
+             break;
            default:
              str = 0;
              break;
            }
-         
+
          if (str)
            {
-             buffer_grow (buffer, prev, f - prev - 1);
+             buffer_grow (buffer, prev, f_old - prev - 1);
              p = xml_escape_text (str);
              buffer_grow_str (buffer, p);
              xfree (p);
index ffb72b35d9596ac5de237d6fbc9c4728bbe49f1d..1086d10ac344df43384cfb3a7b93461bc712378b 100644 (file)
 #include "gdb_assert.h"
 #include "gdb_dirent.h"
 
+/* Define PID_T to be a fixed size that is at least as large as pid_t,
+   so that reading pid values embedded in /proc works
+   consistently.  */
+
+typedef long long  PID_T;
+
+/* Define TIME_T to be at least as large as time_t, so that reading
+   time values embedded in /proc works consistently.  */
+
+typedef long long TIME_T;
+
+#define MAX_PID_T_STRLEN  (sizeof ("-9223372036854775808") - 1)
+
+/* Returns the CPU core that thread PTID is currently running on.  */
+                                         
 /* Compute and return the processor core of a given thread.  */
 
 int
 linux_common_core_of_thread (ptid_t ptid)
 {
-  char filename[sizeof ("/proc//task//stat")
-                + 2 * 20 /* decimal digits for 2 numbers, max 2^64 bit each */
-                + 1];
+  char filename[sizeof ("/proc//task//stat") + 2 * MAX_PID_T_STRLEN];
   FILE *f;
   char *content = NULL;
   char *p;
@@ -61,8 +74,8 @@ linux_common_core_of_thread (ptid_t ptid)
   int i;
   int core;
 
-  sprintf (filename, "/proc/%d/task/%ld/stat",
-          ptid_get_pid (ptid), ptid_get_lwp (ptid));
+  sprintf (filename, "/proc/%lld/task/%lld/stat",
+          (PID_T) ptid_get_pid (ptid), (PID_T) ptid_get_lwp (ptid));
   f = fopen (filename, "r");
   if (!f)
     return -1;
@@ -104,10 +117,14 @@ linux_common_core_of_thread (ptid_t ptid)
   return core;
 }
 
+/* Finds the command-line of process PID and copies it into COMMAND.
+   At most MAXLEN characters are copied.  If the command-line cannot
+   be found, PID is copied into command in text-form.  */
+
 static void
-command_from_pid (char *command, int maxlen, pid_t pid)
+command_from_pid (char *command, int maxlen, PID_T pid)
 {
-  char *stat_path = xstrprintf ("/proc/%d/stat", pid); 
+  char *stat_path = xstrprintf ("/proc/%lld/stat", pid); 
   FILE *fp = fopen (stat_path, "r");
   
   command[0] = '\0';
@@ -118,8 +135,8 @@ command_from_pid (char *command, int maxlen, pid_t pid)
         include/linux/sched.h in the Linux kernel sources) plus two
         (for the brackets).  */
       char cmd[32]; 
-      pid_t stat_pid;
-      int items_read = fscanf (fp, "%d %32s", &stat_pid, cmd);
+      PID_T stat_pid;
+      int items_read = fscanf (fp, "%lld %32s", &stat_pid, cmd);
          
       if (items_read == 2 && pid == stat_pid)
        {
@@ -132,7 +149,7 @@ command_from_pid (char *command, int maxlen, pid_t pid)
   else
     {
       /* Return the PID if a /proc entry for the process cannot be found.  */
-      snprintf (command, maxlen, "%d", pid);
+      snprintf (command, maxlen, "%lld", pid);
     }
 
   command[maxlen - 1] = '\0'; /* Ensure string is null-terminated.  */
@@ -140,13 +157,13 @@ command_from_pid (char *command, int maxlen, pid_t pid)
   xfree (stat_path);
 }
 
-/* Returns the command-line of the process with the given PID. The returned
-   string needs to be freed using xfree after use.  */
+/* Returns the command-line of the process with the given PID. The
+   returned string needs to be freed using xfree after use.  */
 
 static char *
-commandline_from_pid (pid_t pid)
+commandline_from_pid (PID_T pid)
 {
-  char *pathname = xstrprintf ("/proc/%d/cmdline", pid);
+  char *pathname = xstrprintf ("/proc/%lld/cmdline", pid);
   char *commandline = NULL;
   FILE *f = fopen (pathname, "r");
 
@@ -182,7 +199,8 @@ commandline_from_pid (pid_t pid)
        }
       else
        {
-         /* Return the command in square brackets if the command-line is empty.  */
+         /* Return the command in square brackets if the command-line
+            is empty.  */
          commandline = (char *) xmalloc (32);
          commandline[0] = '[';
          command_from_pid (commandline + 1, 31, pid);
@@ -198,6 +216,9 @@ commandline_from_pid (pid_t pid)
   return commandline;
 }
 
+/* Finds the user name for the user UID and copies it into USER.  At
+   most MAXLEN characters are copied.  */
+
 static void
 user_from_uid (char *user, int maxlen, uid_t uid)
 {
@@ -206,19 +227,23 @@ user_from_uid (char *user, int maxlen, uid_t uid)
   if (pwentry)
     {
       strncpy (user, pwentry->pw_name, maxlen);
-      user[maxlen - 1] = '\0'; /* Ensure that the user name is null-terminated.  */
+      /* Ensure that the user name is null-terminated.  */
+      user[maxlen - 1] = '\0';
     }
   else
     user[0] = '\0';
 }
 
+/* Finds the owner of process PID and returns the user id in OWNER.
+   Returns 0 if the owner was found, -1 otherwise.  */
+
 static int
-get_process_owner (uid_t *owner, pid_t pid)
+get_process_owner (uid_t *owner, PID_T pid)
 {
   struct stat statbuf;
-  char procentry[sizeof ("/proc/4294967295")];
+  char procentry[sizeof ("/proc/") + MAX_PID_T_STRLEN];
 
-  sprintf (procentry, "/proc/%d", pid);
+  sprintf (procentry, "/proc/%lld", pid);
   
   if (stat (procentry, &statbuf) == 0 && S_ISDIR (statbuf.st_mode))
     {
@@ -229,6 +254,8 @@ get_process_owner (uid_t *owner, pid_t pid)
     return -1;
 }
 
+/* Returns the number of CPU cores found on the system.  */
+
 static int
 get_number_of_cpu_cores (void)
 {
@@ -249,31 +276,34 @@ get_number_of_cpu_cores (void)
   return cores;
 }
 
-/* CORES points to an array of at least get_number_of_cpu_cores () elements.  */
+/* Find the CPU cores used by process PID and return them in CORES.
+   CORES points to an array of at least get_number_of_cpu_cores ()
+   elements.  */
 
 static int
-get_cores_used_by_process (pid_t pid, int *cores)
+get_cores_used_by_process (PID_T pid, int *cores)
 {
-  char taskdir[sizeof ("/proc/4294967295/task")];
+  char taskdir[sizeof ("/proc/") + MAX_PID_T_STRLEN + sizeof ("/task") - 1];
   DIR *dir;
   struct dirent *dp;
   int task_count = 0;
 
-  sprintf (taskdir, "/proc/%d/task", pid);
+  sprintf (taskdir, "/proc/%lld/task", pid);
   dir = opendir (taskdir);
   if (dir)
     {
       while ((dp = readdir (dir)) != NULL)
        {
-         pid_t tid;
+         PID_T tid;
          int core;
 
          if (!isdigit (dp->d_name[0])
-             || NAMELEN (dp) > sizeof ("4294967295") - 1)
+             || NAMELEN (dp) > MAX_PID_T_STRLEN)
            continue;
 
-         tid = atoi (dp->d_name);
-         core = linux_common_core_of_thread (ptid_build (pid, tid, 0));
+         sscanf (dp->d_name, "%lld", &tid);
+         core = linux_common_core_of_thread (ptid_build ((pid_t) pid,
+                                                         (pid_t) tid, 0));
 
          if (core >= 0)
            {
@@ -316,7 +346,7 @@ linux_xfer_osdata_processes (gdb_byte *readbuf,
 
          while ((dp = readdir (dirp)) != NULL)
            {
-             pid_t pid;
+             PID_T pid;
              uid_t owner;
              char user[UT_NAMESIZE];
              char *command_line;
@@ -326,10 +356,10 @@ linux_xfer_osdata_processes (gdb_byte *readbuf,
              int i;
 
              if (!isdigit (dp->d_name[0])
-                 || NAMELEN (dp) > sizeof ("4294967295") - 1)
+                 || NAMELEN (dp) > MAX_PID_T_STRLEN)
                continue;
 
-             sscanf (dp->d_name, "%d", &pid);
+             sscanf (dp->d_name, "%lld", &pid);
              command_line = commandline_from_pid (pid);
 
              if (get_process_owner (&owner, pid) == 0)
@@ -345,7 +375,7 @@ linux_xfer_osdata_processes (gdb_byte *readbuf,
              for (i = 0; i < num_cores && task_count > 0; ++i)
                if (cores[i])
                  {
-                   char core_str[sizeof ("4294967205")];
+                   char core_str[sizeof ("4294967295")];
 
                    sprintf (core_str, "%d", i);
                    strcat (cores_str, core_str);
@@ -360,7 +390,7 @@ linux_xfer_osdata_processes (gdb_byte *readbuf,
              buffer_xml_printf (
                  &buffer,
                  "<item>"
-                 "<column name=\"pid\">%d</column>"
+                 "<column name=\"pid\">%lld</column>"
                  "<column name=\"user\">%s</column>"
                  "<column name=\"command\">%s</column>"
                  "<column name=\"cores\">%s</column>"
@@ -398,6 +428,160 @@ linux_xfer_osdata_processes (gdb_byte *readbuf,
   return len;
 }
 
+/* Auxiliary function used by qsort to sort processes by process
+   group.  Compares two processes with ids PROCESS1 and PROCESS2.
+   PROCESS1 comes before PROCESS2 if it has a lower process group id.
+   If they belong to the same process group, PROCESS1 comes before
+   PROCESS2 if it has a lower process id or is the process group
+   leader.  */
+
+static int
+compare_processes (const void *process1, const void *process2)
+{
+  PID_T pid1 = *((PID_T *) process1);
+  PID_T pid2 = *((PID_T *) process2);
+  PID_T pgid1 = *((PID_T *) process1 + 1);
+  PID_T pgid2 = *((PID_T *) process2 + 1);
+
+  /* Sort by PGID.  */
+  if (pgid1 < pgid2)
+    return -1;
+  else if (pgid1 > pgid2)
+    return 1;
+  else
+    {
+      /* Process group leaders always come first, else sort by PID.  */
+      if (pid1 == pgid1)
+       return -1;
+      else if (pid2 == pgid2)
+       return 1;
+      else if (pid1 < pid2)
+       return -1;
+      else if (pid1 > pid2)
+       return 1;
+      else
+       return 0;
+    }
+}
+
+/* Collect all process groups from /proc.  */
+
+static LONGEST
+linux_xfer_osdata_processgroups (gdb_byte *readbuf,
+                                ULONGEST offset, LONGEST len)
+{
+  /* We make the process list snapshot when the object starts to be read.  */
+  static const char *buf;
+  static LONGEST len_avail = -1;
+  static struct buffer buffer;
+
+  if (offset == 0)
+    {
+      DIR *dirp;
+
+      if (len_avail != -1 && len_avail != 0)
+       buffer_free (&buffer);
+      len_avail = 0;
+      buf = NULL;
+      buffer_init (&buffer);
+      buffer_grow_str (&buffer, "<osdata type=\"process groups\">\n");
+
+      dirp = opendir ("/proc");
+      if (dirp)
+       {
+         struct dirent *dp;
+         const size_t list_block_size = 512;
+         PID_T *process_list = (PID_T *) xmalloc (list_block_size * 2 * sizeof (PID_T));
+         size_t process_count = 0;
+         size_t i;
+
+         /* Build list consisting of PIDs followed by their
+            associated PGID.  */
+         while ((dp = readdir (dirp)) != NULL)
+           {
+             PID_T pid, pgid;
+
+             if (!isdigit (dp->d_name[0])
+                 || NAMELEN (dp) > MAX_PID_T_STRLEN)
+               continue;
+
+             sscanf (dp->d_name, "%lld", &pid);
+             pgid = getpgid (pid);
+
+             if (pgid > 0)
+               {
+                 process_list[2 * process_count] = pid;
+                 process_list[2 * process_count + 1] = pgid;
+                 ++process_count;
+
+                 /* Increase the size of the list if necessary.  */
+                 if (process_count % list_block_size == 0)
+                   process_list = (PID_T *) xrealloc (
+                       process_list,
+                       (process_count + list_block_size)
+                       * 2 * sizeof (PID_T));
+               }
+           }
+
+         closedir (dirp);
+
+         /* Sort the process list.  */
+         qsort (process_list, process_count, 2 * sizeof (PID_T),
+                compare_processes);
+
+         for (i = 0; i < process_count; ++i)
+           {
+             PID_T pid = process_list[2 * i];
+             PID_T pgid = process_list[2 * i + 1];
+             char leader_command[32];
+             char *command_line;
+
+             command_from_pid (leader_command, sizeof (leader_command), pgid);
+             command_line = commandline_from_pid (pid);
+
+             buffer_xml_printf (
+                 &buffer,
+                 "<item>"
+                 "<column name=\"pgid\">%lld</column>"
+                 "<column name=\"leader command\">%s</column>"
+                 "<column name=\"pid\">%lld</column>"
+                 "<column name=\"command line\">%s</column>"
+                 "</item>",
+                 pgid,
+                 leader_command,
+                 pid,
+                 command_line ? command_line : "");
+
+             xfree (command_line);
+           }
+
+         xfree (process_list);
+       }   
+
+      buffer_grow_str0 (&buffer, "</osdata>\n");
+      buf = buffer_finish (&buffer);
+      len_avail = strlen (buf);
+    }
+
+  if (offset >= len_avail)
+    {
+      /* Done.  Get rid of the buffer.  */
+      buffer_free (&buffer);
+      buf = NULL;
+      len_avail = 0;
+      return 0;
+    }
+
+  if (len > len_avail - offset)
+    len = len_avail - offset;
+  memcpy (readbuf, buf + offset, len);
+
+  return len;
+}
+
+/* Collect all the threads in /proc by iterating through processes and
+   then tasks within each process.  */
+
 static LONGEST
 linux_xfer_osdata_threads (gdb_byte *readbuf,
                           ULONGEST offset, LONGEST len)
@@ -438,7 +622,7 @@ linux_xfer_osdata_threads (gdb_byte *readbuf,
                {
                  DIR *dirp2;
                  char *pathname;
-                 pid_t pid;
+                 PID_T pid;
                  char command[32];
 
                  pathname = xstrprintf ("/proc/%s/task", dp->d_name);
@@ -454,7 +638,7 @@ linux_xfer_osdata_threads (gdb_byte *readbuf,
 
                      while ((dp2 = readdir (dirp2)) != NULL)
                        {
-                         pid_t tid;
+                         PID_T tid;
                          int core;
 
                          if (!isdigit (dp2->d_name[0])
@@ -467,9 +651,9 @@ linux_xfer_osdata_threads (gdb_byte *readbuf,
                          buffer_xml_printf (
                            &buffer,
                            "<item>"
-                           "<column name=\"pid\">%d</column>"
+                           "<column name=\"pid\">%lld</column>"
                            "<column name=\"command\">%s</column>"
-                           "<column name=\"tid\">%d</column>"
+                           "<column name=\"tid\">%lld</column>"
                            "<column name=\"core\">%d</column>"
                            "</item>",
                            pid,
@@ -509,13 +693,877 @@ linux_xfer_osdata_threads (gdb_byte *readbuf,
   return len;
 }
 
+/* Collect all the open file descriptors found in /proc and put the details
+   found about them into READBUF.  */
+
+static LONGEST
+linux_xfer_osdata_fds (gdb_byte *readbuf,
+                      ULONGEST offset, LONGEST len)
+{
+  /* We make the process list snapshot when the object starts to be read.  */
+  static const char *buf;
+  static LONGEST len_avail = -1;
+  static struct buffer buffer;
+
+  if (offset == 0)
+    {
+      DIR *dirp;
+
+      if (len_avail != -1 && len_avail != 0)
+       buffer_free (&buffer);
+      len_avail = 0;
+      buf = NULL;
+      buffer_init (&buffer);
+      buffer_grow_str (&buffer, "<osdata type=\"files\">\n");
+
+      dirp = opendir ("/proc");
+      if (dirp)
+       {
+         struct dirent *dp;
+
+         while ((dp = readdir (dirp)) != NULL)
+           {
+             struct stat statbuf;
+             char procentry[sizeof ("/proc/4294967295")];
+
+             if (!isdigit (dp->d_name[0])
+                 || NAMELEN (dp) > sizeof ("4294967295") - 1)
+               continue;
+
+             sprintf (procentry, "/proc/%s", dp->d_name);
+             if (stat (procentry, &statbuf) == 0
+                 && S_ISDIR (statbuf.st_mode))
+               {
+                 char *pathname;
+                 DIR *dirp2;
+                 PID_T pid;
+                 char command[32];
+
+                 pid = atoi (dp->d_name);
+                 command_from_pid (command, sizeof (command), pid);
+
+                 pathname = xstrprintf ("/proc/%s/fd", dp->d_name);
+                 dirp2 = opendir (pathname);
+
+                 if (dirp2)
+                   {
+                     struct dirent *dp2;
+
+                     while ((dp2 = readdir (dirp2)) != NULL)
+                       {
+                         char *fdname;
+                         char buf[1000];
+                         ssize_t rslt;
+
+                         if (!isdigit (dp2->d_name[0]))
+                           continue;
+
+                         fdname = xstrprintf ("%s/%s", pathname, dp2->d_name);
+                         rslt = readlink (fdname, buf, 1000);
+                         if (rslt >= 0)
+                           buf[rslt] = '\0';
+
+                         buffer_xml_printf (
+                           &buffer,
+                           "<item>"
+                           "<column name=\"pid\">%s</column>"
+                           "<column name=\"command\">%s</column>"
+                           "<column name=\"file descriptor\">%s</column>"
+                           "<column name=\"name\">%s</column>"
+                           "</item>",
+                           dp->d_name,
+                           command,
+                           dp2->d_name,
+                           (rslt >= 0 ? buf : dp2->d_name));
+                       }
+
+                     closedir (dirp2);
+                   }
+
+                 xfree (pathname);
+               }
+           }
+
+         closedir (dirp);
+       }
+
+      buffer_grow_str0 (&buffer, "</osdata>\n");
+      buf = buffer_finish (&buffer);
+      len_avail = strlen (buf);
+    }
+
+  if (offset >= len_avail)
+    {
+      /* Done.  Get rid of the buffer.  */
+      buffer_free (&buffer);
+      buf = NULL;
+      len_avail = 0;
+      return 0;
+    }
+
+  if (len > len_avail - offset)
+    len = len_avail - offset;
+  memcpy (readbuf, buf + offset, len);
+
+  return len;
+}
+
+/* Returns the socket state STATE in textual form.  */
+
+static const char *
+format_socket_state (unsigned char state)
+{
+  /* Copied from include/net/tcp_states.h in the Linux kernel sources.  */
+  enum {
+    TCP_ESTABLISHED = 1,
+    TCP_SYN_SENT,
+    TCP_SYN_RECV,
+    TCP_FIN_WAIT1,
+    TCP_FIN_WAIT2,
+    TCP_TIME_WAIT,
+    TCP_CLOSE,
+    TCP_CLOSE_WAIT,
+    TCP_LAST_ACK,
+    TCP_LISTEN,
+    TCP_CLOSING
+  };
+
+  switch (state)
+    {
+    case TCP_ESTABLISHED:
+      return "ESTABLISHED";
+    case TCP_SYN_SENT:
+      return "SYN_SENT";
+    case TCP_SYN_RECV:
+      return "SYN_RECV";
+    case TCP_FIN_WAIT1:
+      return "FIN_WAIT1";
+    case TCP_FIN_WAIT2:
+      return "FIN_WAIT2";
+    case TCP_TIME_WAIT:
+      return "TIME_WAIT";
+    case TCP_CLOSE:
+      return "CLOSE";
+    case TCP_CLOSE_WAIT:
+      return "CLOSE_WAIT";
+    case TCP_LAST_ACK:
+      return "LAST_ACK";
+    case TCP_LISTEN:
+      return "LISTEN";
+    case TCP_CLOSING:
+      return "CLOSING";
+    default:
+      return "(unknown)";
+    }
+}
+
+union socket_addr
+  {
+    struct sockaddr sa;
+    struct sockaddr_in sin;
+    struct sockaddr_in6 sin6;
+  };
+
+/* Auxiliary function used by linux_xfer_osdata_isocket.  Formats
+   information for all open internet sockets of type FAMILY on the
+   system into BUFFER.  If TCP is set, only TCP sockets are processed,
+   otherwise only UDP sockets are processed.  */
+
+static void
+print_sockets (unsigned short family, int tcp, struct buffer *buffer)
+{
+  const char *proc_file;
+  FILE *fp;
+
+  if (family == AF_INET)
+    proc_file = tcp ? "/proc/net/tcp" : "/proc/net/udp";
+  else if (family == AF_INET6)
+    proc_file = tcp ? "/proc/net/tcp6" : "/proc/net/udp6";
+  else
+    return;
+
+  fp = fopen (proc_file, "r");
+  if (fp)
+    {
+      char buf[8192];
+
+      do
+       {
+         if (fgets (buf, sizeof (buf), fp))
+           {
+             uid_t uid;
+             unsigned long tlen, inode;
+             int sl, timeout;
+             unsigned int local_port, remote_port, state;
+             unsigned int txq, rxq, trun, retn;
+             char local_address[NI_MAXHOST], remote_address[NI_MAXHOST];
+             char extra[512];
+             int result;
+
+             result = sscanf (buf,
+                              "%d: %33[0-9A-F]:%X %33[0-9A-F]:%X %X %X:%X %X:%lX %X %d %d %lu %512s\n",
+                              &sl,
+                              local_address, &local_port,
+                              remote_address, &remote_port,
+                              &state,
+                              &txq, &rxq,
+                              &trun, &tlen,
+                              &retn,
+                              &uid,
+                              &timeout,
+                              &inode,
+                              extra);
+             
+             if (result == 15)
+               {
+                 union socket_addr locaddr, remaddr;
+                 size_t addr_size;
+                 char user[UT_NAMESIZE];
+                 char local_service[NI_MAXSERV], remote_service[NI_MAXSERV];
+
+                 if (family == AF_INET)
+                   {
+                     sscanf (local_address, "%X",
+                             &locaddr.sin.sin_addr.s_addr);
+                     sscanf (remote_address, "%X",
+                             &remaddr.sin.sin_addr.s_addr);
+                     
+                     locaddr.sin.sin_port = htons (local_port);
+                     remaddr.sin.sin_port = htons (remote_port);
+
+                     addr_size = sizeof (struct sockaddr_in);
+                   }
+                 else
+                   {
+                     sscanf (local_address, "%8X%8X%8X%8X",
+                             locaddr.sin6.sin6_addr.s6_addr32,
+                             locaddr.sin6.sin6_addr.s6_addr32 + 1,
+                             locaddr.sin6.sin6_addr.s6_addr32 + 2,
+                             locaddr.sin6.sin6_addr.s6_addr32 + 3);
+                     sscanf (remote_address, "%8X%8X%8X%8X",
+                             remaddr.sin6.sin6_addr.s6_addr32,
+                             remaddr.sin6.sin6_addr.s6_addr32 + 1,
+                             remaddr.sin6.sin6_addr.s6_addr32 + 2,
+                             remaddr.sin6.sin6_addr.s6_addr32 + 3);
+
+                     locaddr.sin6.sin6_port = htons (local_port);
+                     remaddr.sin6.sin6_port = htons (remote_port);
+                     
+                     locaddr.sin6.sin6_flowinfo = 0;
+                     remaddr.sin6.sin6_flowinfo = 0;
+                     locaddr.sin6.sin6_scope_id = 0;
+                     remaddr.sin6.sin6_scope_id = 0;
+
+                     addr_size = sizeof (struct sockaddr_in6);
+                   }
+             
+                 locaddr.sa.sa_family = remaddr.sa.sa_family = family;
+                     
+                 result = getnameinfo (&locaddr.sa, addr_size,
+                                       local_address, sizeof (local_address),
+                                       local_service, sizeof (local_service),
+                                       NI_NUMERICHOST | NI_NUMERICSERV
+                                       | (tcp ? 0 : NI_DGRAM));
+                 if (result)
+                   continue;
+                 
+                 result = getnameinfo (&remaddr.sa, addr_size,
+                                       remote_address,
+                                       sizeof (remote_address),
+                                       remote_service,
+                                       sizeof (remote_service),
+                                       NI_NUMERICHOST | NI_NUMERICSERV
+                                       | (tcp ? 0 : NI_DGRAM));
+                 if (result)
+                   continue;
+                 
+                 user_from_uid (user, sizeof (user), uid);
+                 
+                 buffer_xml_printf (
+                     buffer,
+                     "<item>"
+                     "<column name=\"local address\">%s</column>"
+                     "<column name=\"local port\">%s</column>"
+                     "<column name=\"remote address\">%s</column>"
+                     "<column name=\"remote port\">%s</column>"
+                     "<column name=\"state\">%s</column>"
+                     "<column name=\"user\">%s</column>"
+                     "<column name=\"family\">%s</column>" 
+                     "<column name=\"protocol\">%s</column>"
+                     "</item>",
+                     local_address,
+                     local_service,
+                     remote_address,
+                     remote_service,
+                     format_socket_state (state),
+                     user,
+                     (family == AF_INET) ? "INET" : "INET6",
+                     tcp ? "STREAM" : "DGRAM");
+               }
+           }
+       }
+      while (!feof (fp));
+
+      fclose (fp);
+    }
+}
+
+/* Collect data about internet sockets and write it into READBUF.  */
+
+static LONGEST
+linux_xfer_osdata_isockets (gdb_byte *readbuf,
+                           ULONGEST offset, LONGEST len)
+{
+  static const char *buf;
+  static LONGEST len_avail = -1;
+  static struct buffer buffer;
+
+  if (offset == 0)
+    {
+      if (len_avail != -1 && len_avail != 0)
+       buffer_free (&buffer);
+      len_avail = 0;
+      buf = NULL;
+      buffer_init (&buffer);
+      buffer_grow_str (&buffer, "<osdata type=\"I sockets\">\n");
+
+      print_sockets (AF_INET, 1, &buffer);
+      print_sockets (AF_INET, 0, &buffer);
+      print_sockets (AF_INET6, 1, &buffer);
+      print_sockets (AF_INET6, 0, &buffer);
+
+      buffer_grow_str0 (&buffer, "</osdata>\n");
+      buf = buffer_finish (&buffer);
+      len_avail = strlen (buf);
+    }
+
+  if (offset >= len_avail)
+    {
+      /* Done.  Get rid of the buffer.  */
+      buffer_free (&buffer);
+      buf = NULL;
+      len_avail = 0;
+      return 0;
+    }
+
+  if (len > len_avail - offset)
+    len = len_avail - offset;
+  memcpy (readbuf, buf + offset, len);
+
+  return len;
+}
+
+/* Converts the time SECONDS into textual form and copies it into a
+   buffer TIME, with at most MAXLEN characters copied.  */
+
+static void
+time_from_time_t (char *time, int maxlen, TIME_T seconds)
+{
+  if (!seconds)
+    time[0] = '\0';
+  else
+    {
+      time_t t = (time_t) seconds;
+      
+      strncpy (time, ctime (&t), maxlen);
+      time[maxlen - 1] = '\0';
+    }
+}
+
+/* Finds the group name for the group GID and copies it into GROUP.
+   At most MAXLEN characters are copied.  */
+
+static void
+group_from_gid (char *group, int maxlen, gid_t gid)
+{
+  struct group *grentry = getgrgid (gid);
+  
+  if (grentry)
+    {
+      strncpy (group, grentry->gr_name, maxlen);
+      /* Ensure that the group name is null-terminated.  */
+      group[maxlen - 1] = '\0';
+    }
+  else
+    group[0] = '\0';
+}
+
+/* Collect data about shared memory recorded in /proc and write it
+   into READBUF.  */
+
+static LONGEST
+linux_xfer_osdata_shm (gdb_byte *readbuf,
+                      ULONGEST offset, LONGEST len)
+{
+  static const char *buf;
+  static LONGEST len_avail = -1;
+  static struct buffer buffer;
+
+  if (offset == 0)
+    {
+      FILE *fp;
+
+      if (len_avail != -1 && len_avail != 0)
+       buffer_free (&buffer);
+      len_avail = 0;
+      buf = NULL;
+      buffer_init (&buffer);
+      buffer_grow_str (&buffer, "<osdata type=\"shared memory\">\n");
+
+      fp = fopen ("/proc/sysvipc/shm", "r");
+      if (fp)
+       {
+         char buf[8192];
+
+         do
+           {
+             if (fgets (buf, sizeof (buf), fp))
+               {
+                 key_t key;
+                 uid_t uid, cuid;
+                 gid_t gid, cgid;
+                 PID_T cpid, lpid;
+                 int shmid, size, nattch;
+                 TIME_T atime, dtime, ctime;
+                 unsigned int perms;
+                 int items_read;
+                                 
+                 items_read = sscanf (buf,
+                                      "%d %d %o %d %lld %lld %d %u %u %u %u %lld %lld %lld",
+                                      &key, &shmid, &perms, &size,
+                                      &cpid, &lpid,
+                                      &nattch,
+                                      &uid, &gid, &cuid, &cgid,
+                                      &atime, &dtime, &ctime);
+
+                 if (items_read == 14)
+                   {
+                     char user[UT_NAMESIZE], group[UT_NAMESIZE];
+                     char cuser[UT_NAMESIZE], cgroup[UT_NAMESIZE];
+                     char ccmd[32], lcmd[32];
+                     char atime_str[32], dtime_str[32], ctime_str[32];
+                     
+                     user_from_uid (user, sizeof (user), uid);
+                     group_from_gid (group, sizeof (group), gid);
+                     user_from_uid (cuser, sizeof (cuser), cuid);
+                     group_from_gid (cgroup, sizeof (cgroup), cgid);
+                     
+                     command_from_pid (ccmd, sizeof (ccmd), cpid);
+                     command_from_pid (lcmd, sizeof (lcmd), lpid);
+                     
+                     time_from_time_t (atime_str, sizeof (atime_str), atime);
+                     time_from_time_t (dtime_str, sizeof (dtime_str), dtime);
+                     time_from_time_t (ctime_str, sizeof (ctime_str), ctime);
+                     
+                     buffer_xml_printf (
+                         &buffer,
+                         "<item>"
+                         "<column name=\"key\">%d</column>"
+                         "<column name=\"shmid\">%d</column>"
+                         "<column name=\"permissions\">%o</column>"
+                         "<column name=\"size\">%d</column>"
+                         "<column name=\"creator command\">%s</column>"
+                         "<column name=\"last op. command\">%s</column>"
+                         "<column name=\"num attached\">%d</column>"
+                         "<column name=\"user\">%s</column>"
+                         "<column name=\"group\">%s</column>"
+                         "<column name=\"creator user\">%s</column>"
+                         "<column name=\"creator group\">%s</column>"
+                         "<column name=\"last shmat() time\">%s</column>"
+                         "<column name=\"last shmdt() time\">%s</column>"
+                         "<column name=\"last shmctl() time\">%s</column>"
+                         "</item>",
+                         key,
+                         shmid,
+                         perms,
+                         size,
+                         ccmd,
+                         lcmd,
+                         nattch,
+                         user,
+                         group,
+                         cuser,
+                         cgroup,
+                         atime_str,
+                         dtime_str,
+                         ctime_str);
+                   }
+               }
+           }
+         while (!feof (fp));
+
+         fclose (fp);
+       }
+      
+      buffer_grow_str0 (&buffer, "</osdata>\n");
+      buf = buffer_finish (&buffer);
+      len_avail = strlen (buf);
+    }
+
+  if (offset >= len_avail)
+    {
+      /* Done.  Get rid of the buffer.  */
+      buffer_free (&buffer);
+      buf = NULL;
+      len_avail = 0;
+      return 0;
+    }
+
+  if (len > len_avail - offset)
+    len = len_avail - offset;
+  memcpy (readbuf, buf + offset, len);
+
+  return len;
+}
+
+/* Collect data about semaphores recorded in /proc and write it
+   into READBUF.  */
+
+static LONGEST
+linux_xfer_osdata_sem (gdb_byte *readbuf,
+                      ULONGEST offset, LONGEST len)
+{
+  static const char *buf;
+  static LONGEST len_avail = -1;
+  static struct buffer buffer;
+
+  if (offset == 0)
+    {
+      FILE *fp;
+      
+      if (len_avail != -1 && len_avail != 0)
+       buffer_free (&buffer);
+      len_avail = 0;
+      buf = NULL;
+      buffer_init (&buffer);
+      buffer_grow_str (&buffer, "<osdata type=\"semaphores\">\n");
+
+      fp = fopen ("/proc/sysvipc/sem", "r");
+      if (fp)
+       {
+         char buf[8192];
+         
+         do
+           {
+             if (fgets (buf, sizeof (buf), fp))
+               {
+                 key_t key;
+                 uid_t uid, cuid;
+                 gid_t gid, cgid;
+                 unsigned int perms, nsems;
+                 int semid;
+                 TIME_T otime, ctime;
+                 int items_read;
+                 
+                 items_read = sscanf (buf,
+                                      "%d %d %o %u %d %d %d %d %lld %lld",
+                                      &key, &semid, &perms, &nsems,
+                                      &uid, &gid, &cuid, &cgid,
+                                      &otime, &ctime);
+                 
+                 if (items_read == 10)
+                   {
+                     char user[UT_NAMESIZE], group[UT_NAMESIZE];
+                     char cuser[UT_NAMESIZE], cgroup[UT_NAMESIZE];
+                     char otime_str[32], ctime_str[32];
+                     
+                     user_from_uid (user, sizeof (user), uid);
+                     group_from_gid (group, sizeof (group), gid);
+                     user_from_uid (cuser, sizeof (cuser), cuid);
+                     group_from_gid (cgroup, sizeof (cgroup), cgid);
+                     
+                     time_from_time_t (otime_str, sizeof (otime_str), otime);
+                     time_from_time_t (ctime_str, sizeof (ctime_str), ctime);
+                     
+                     buffer_xml_printf (
+                         &buffer,
+                         "<item>"
+                         "<column name=\"key\">%d</column>"
+                         "<column name=\"semid\">%d</column>"
+                         "<column name=\"permissions\">%o</column>"
+                         "<column name=\"num semaphores\">%u</column>"
+                         "<column name=\"user\">%s</column>"
+                         "<column name=\"group\">%s</column>"
+                         "<column name=\"creator user\">%s</column>"
+                         "<column name=\"creator group\">%s</column>"
+                         "<column name=\"last semop() time\">%s</column>"
+                         "<column name=\"last semctl() time\">%s</column>"
+                         "</item>",
+                         key,
+                         semid,
+                         perms,
+                         nsems,
+                         user,
+                         group,
+                         cuser,
+                         cgroup,
+                         otime_str,
+                         ctime_str);
+                   }
+               }
+           }
+         while (!feof (fp));
+
+         fclose (fp);
+       }
+
+      buffer_grow_str0 (&buffer, "</osdata>\n");
+      buf = buffer_finish (&buffer);
+      len_avail = strlen (buf);
+    }
+
+  if (offset >= len_avail)
+    {
+      /* Done.  Get rid of the buffer.  */
+      buffer_free (&buffer);
+      buf = NULL;
+      len_avail = 0;
+      return 0;
+    }
+
+  if (len > len_avail - offset)
+    len = len_avail - offset;
+  memcpy (readbuf, buf + offset, len);
+
+  return len;
+}
+
+/* Collect data about message queues recorded in /proc and write it
+   into READBUF.  */
+
+static LONGEST
+linux_xfer_osdata_msg (gdb_byte *readbuf,
+                      ULONGEST offset, LONGEST len)
+{
+  static const char *buf;
+  static LONGEST len_avail = -1;
+  static struct buffer buffer;
+
+  if (offset == 0)
+    {
+      FILE *fp;
+      
+      if (len_avail != -1 && len_avail != 0)
+       buffer_free (&buffer);
+      len_avail = 0;
+      buf = NULL;
+      buffer_init (&buffer);
+      buffer_grow_str (&buffer, "<osdata type=\"message queues\">\n");
+      
+      fp = fopen ("/proc/sysvipc/msg", "r");
+      if (fp)
+       {
+         char buf[8192];
+         
+         do
+           {
+             if (fgets (buf, sizeof (buf), fp))
+               {
+                 key_t key;
+                 PID_T lspid, lrpid;
+                 uid_t uid, cuid;
+                 gid_t gid, cgid;
+                 unsigned int perms, cbytes, qnum;
+                 int msqid;
+                 TIME_T stime, rtime, ctime;
+                 int items_read;
+                 
+                 items_read = sscanf (buf,
+                                      "%d %d %o %u %u %lld %lld %d %d %d %d %lld %lld %lld",
+                                      &key, &msqid, &perms, &cbytes, &qnum,
+                                      &lspid, &lrpid, &uid, &gid, &cuid, &cgid,
+                                      &stime, &rtime, &ctime);
+                 
+                 if (items_read == 14)
+                   {
+                     char user[UT_NAMESIZE], group[UT_NAMESIZE];
+                     char cuser[UT_NAMESIZE], cgroup[UT_NAMESIZE];
+                     char lscmd[32], lrcmd[32];
+                     char stime_str[32], rtime_str[32], ctime_str[32];
+                     
+                     user_from_uid (user, sizeof (user), uid);
+                     group_from_gid (group, sizeof (group), gid);
+                     user_from_uid (cuser, sizeof (cuser), cuid);
+                     group_from_gid (cgroup, sizeof (cgroup), cgid);
+                     
+                     command_from_pid (lscmd, sizeof (lscmd), lspid);
+                     command_from_pid (lrcmd, sizeof (lrcmd), lrpid);
+                     
+                     time_from_time_t (stime_str, sizeof (stime_str), stime);
+                     time_from_time_t (rtime_str, sizeof (rtime_str), rtime);
+                     time_from_time_t (ctime_str, sizeof (ctime_str), ctime);
+                     
+                     buffer_xml_printf (
+                         &buffer,
+                         "<item>"
+                         "<column name=\"key\">%d</column>"
+                         "<column name=\"msqid\">%d</column>"
+                         "<column name=\"permissions\">%o</column>"
+                         "<column name=\"num used bytes\">%u</column>"
+                         "<column name=\"num messages\">%u</column>"
+                         "<column name=\"last msgsnd() command\">%s</column>"
+                         "<column name=\"last msgrcv() command\">%s</column>"
+                         "<column name=\"user\">%s</column>"
+                         "<column name=\"group\">%s</column>"
+                         "<column name=\"creator user\">%s</column>"
+                         "<column name=\"creator group\">%s</column>"
+                         "<column name=\"last msgsnd() time\">%s</column>"
+                         "<column name=\"last msgrcv() time\">%s</column>"
+                         "<column name=\"last msgctl() time\">%s</column>"
+                         "</item>",
+                         key,
+                         msqid,
+                         perms,
+                         cbytes,
+                         qnum,
+                         lscmd,
+                         lrcmd,
+                         user,
+                         group,
+                         cuser,
+                         cgroup,
+                         stime_str,
+                         rtime_str,
+                         ctime_str);
+                   }
+               }
+           }
+         while (!feof (fp));
+
+         fclose (fp);
+       }
+
+      buffer_grow_str0 (&buffer, "</osdata>\n");
+      buf = buffer_finish (&buffer);
+      len_avail = strlen (buf);
+    }
+
+  if (offset >= len_avail)
+    {
+      /* Done.  Get rid of the buffer.  */
+      buffer_free (&buffer);
+      buf = NULL;
+      len_avail = 0;
+      return 0;
+    }
+
+  if (len > len_avail - offset)
+    len = len_avail - offset;
+  memcpy (readbuf, buf + offset, len);
+
+  return len;
+}
+
+/* Collect data about loaded kernel modules and write it into
+   READBUF.  */
+
+static LONGEST
+linux_xfer_osdata_modules (gdb_byte *readbuf,
+                          ULONGEST offset, LONGEST len)
+{
+  static const char *buf;
+  static LONGEST len_avail = -1;
+  static struct buffer buffer;
+
+  if (offset == 0)
+    {
+      FILE *fp;
+
+      if (len_avail != -1 && len_avail != 0)
+       buffer_free (&buffer);
+      len_avail = 0;
+      buf = NULL;
+      buffer_init (&buffer);
+      buffer_grow_str (&buffer, "<osdata type=\"modules\">\n");
+
+      fp = fopen ("/proc/modules", "r");
+      if (fp)
+       {
+         char buf[8192];
+         
+         do
+           {
+             if (fgets (buf, sizeof (buf), fp))
+               {
+                 char name[64], dependencies[256], status[16];
+                 unsigned int size;
+                 unsigned long long address;
+                 int uses;
+                 int items_read;
+                 
+                 items_read = sscanf (buf,
+                                      "%64s %d %d %256s %16s 0x%llx",
+                                      name, &size, &uses,
+                                      dependencies, status, &address);
+
+                 if (items_read == 6)
+                   buffer_xml_printf (
+                       &buffer,
+                       "<item>"
+                       "<column name=\"name\">%s</column>"
+                       "<column name=\"size\">%u</column>"
+                       "<column name=\"num uses\">%d</column>"
+                       "<column name=\"dependencies\">%s</column>"
+                       "<column name=\"status\">%s</column>"
+                       "<column name=\"address\">%llx</column>"
+                       "</item>",
+                       name,
+                       size,
+                       uses,
+                       dependencies,
+                       status,
+                       address);
+               }
+           }
+         while (!feof (fp));
+
+         fclose (fp);
+       }
+
+      buffer_grow_str0 (&buffer, "</osdata>\n");
+      buf = buffer_finish (&buffer);
+      len_avail = strlen (buf);
+    }
+
+  if (offset >= len_avail)
+    {
+      /* Done.  Get rid of the buffer.  */
+      buffer_free (&buffer);
+      buf = NULL;
+      len_avail = 0;
+      return 0;
+    }
+
+  if (len > len_avail - offset)
+    len = len_avail - offset;
+  memcpy (readbuf, buf + offset, len);
+
+  return len;
+}
+
 struct osdata_type {
   char *type;
   char *description;
   LONGEST (*getter) (gdb_byte *readbuf, ULONGEST offset, LONGEST len);
 } osdata_table[] = {
-  { "processes", "Listing of all processes", linux_xfer_osdata_processes },
-  { "threads", "Listing of all threads", linux_xfer_osdata_threads },
+  { "processes", "Listing of all processes",
+    linux_xfer_osdata_processes },
+  { "procgroups", "Listing of all process groups",
+    linux_xfer_osdata_processgroups },
+  { "threads", "Listing of all threads",
+    linux_xfer_osdata_threads },
+  { "files", "Listing of all file descriptors",
+    linux_xfer_osdata_fds },
+  { "sockets", "Listing of all internet-domain sockets",
+    linux_xfer_osdata_isockets },
+  { "shm", "Listing of all shared-memory regions",
+    linux_xfer_osdata_shm },
+  { "semaphores", "Listing of all semaphores",
+    linux_xfer_osdata_sem },
+  { "msg", "Listing of all message queues",
+    linux_xfer_osdata_msg },
+  { "modules", "Listing of all loaded kernel modules",
+    linux_xfer_osdata_modules },
   { NULL, NULL, NULL }
 };
 
index 40329ee67d405d14ff3ea44873d0ea96ea3f773d..995493f4b5fc720aaca9ff18048f31f07b2cf954 100644 (file)
@@ -1,3 +1,9 @@
+2012-05-11  Stan Shebs  <stan@codesourcery.com>
+           Kwok Cheung Yeung  <kcy@codesourcery.com>
+
+       * gdb.texinfo (Operating System Auxiliary Information): Document new
+       'info os' subcommands.
+
 2012-05-11  Jan Kratochvil  <jan.kratochvil@redhat.com>
 
        * gdb.texinfo (Auto-loading, Init File in the Current Directory)
index 38ef07947702650bdf8715c3f45fd1b3770f93eb..be004ab7ad2ffa51b83640e24e3d1477f356caf3 100644 (file)
@@ -9409,23 +9409,109 @@ most appropriate form for a recognized tag, and in hexadecimal for
 an unrecognized tag.
 @end table
 
-On some targets, @value{GDBN} can access operating-system-specific information
-and display it to user, without interpretation.  For remote targets,
-this functionality depends on the remote stub's support of the 
+On some targets, @value{GDBN} can access operating system-specific
+information and show it to you.  The types of information available
+will differ depending on the type of operating system running on the
+target.  The mechanism used to fetch the data is described in
+@ref{Operating System Information}.  For remote targets, this
+functionality depends on the remote stub's support of the
 @samp{qXfer:osdata:read} packet, see @ref{qXfer osdata read}.
 
 @table @code
 @kindex info os
-@item info os
-List the types of OS information available for the target.  If the
-target does not return a list of possible types, this command will
-report an error.
+@item info os @var{infotype}
+
+Display OS information of the requested type.
+
+On @sc{gnu}/Linux, the following values of @var{infotype} are valid:
 
+@anchor{linux info os infotypes}
+@table @code
 @kindex info os processes
-@item info os processes
+@item processes
 Display the list of processes on the target.  For each process,
-@value{GDBN} prints the process identifier, the name of the user, and
-the command corresponding to the process.
+@value{GDBN} prints the process identifier, the name of the user, the
+command corresponding to the process, and the list of processor cores
+that the process is currently running on.  (To understand what these
+properties mean, for this and the following info types, please consult
+the general @sc{gnu}/Linux documentation.)
+
+@kindex info os procgroups
+@item procgroups
+Display the list of process groups on the target.  For each process,
+@value{GDBN} prints the identifier of the process group that it belongs
+to, the command corresponding to the process group leader, the process
+identifier, and the command line of the process.  The list is sorted
+first by the process group identifier, then by the process identifier,
+so that processes belonging to the same process group are grouped together
+and the process group leader is listed first.
+
+@kindex info os threads
+@item threads
+Display the list of threads running on the target.  For each thread,
+@value{GDBN} prints the identifier of the process that the thread
+belongs to, the command of the process, the thread identifier, and the
+processor core that it is currently running on.  The main thread of a
+process is not listed.
+
+@kindex info os files
+@item files
+Display the list of open file descriptors on the target.  For each
+file descriptor, @value{GDBN} prints the identifier of the process
+owning the descriptor, the command of the owning process, the value
+of the descriptor, and the target of the descriptor.
+
+@kindex info os sockets
+@item sockets
+Display the list of Internet-domain sockets on the target.  For each
+socket, @value{GDBN} prints the address and port of the local and
+remote endpoints, the current state of the connection, the creator of
+the socket, the IP address family of the socket, and the type of the
+connection.
+
+@kindex info os shm
+@item shm
+Display the list of all System V shared-memory regions on the target.
+For each shared-memory region, @value{GDBN} prints the region key,
+the shared-memory identifier, the access permissions, the size of the
+region, the process that created the region, the process that last
+attached to or detached from the region, the current number of live
+attaches to the region, and the times at which the region was last
+attached to, detach from, and changed.
+
+@kindex info os semaphores
+@item semaphores
+Display the list of all System V semaphore sets on the target.  For each
+semaphore set, @value{GDBN} prints the semaphore set key, the semaphore
+set identifier, the access permissions, the number of semaphores in the
+set, the user and group of the owner and creator of the semaphore set,
+and the times at which the semaphore set was operated upon and changed.
+
+@kindex info os msg
+@item msg
+Display the list of all System V message queues on the target.  For each
+message queue, @value{GDBN} prints the message queue key, the message
+queue identifier, the access permissions, the current number of bytes
+on the queue, the current number of messages on the queue, the processes
+that last sent and received a message on the queue, the user and group
+of the owner and creator of the message queue, the times at which a
+message was last sent and received on the queue, and the time at which
+the message queue was last changed.
+
+@kindex info os modules
+@item modules
+Display the list of all loaded kernel modules on the target.  For each
+module, @value{GDBN} prints the module name, the size of the module in
+bytes, the number of times the module is used, the dependencies of the
+module, the status of the module, and the address of the loaded module
+in memory.
+@end table
+
+@item info os
+If @var{infotype} is omitted, then list the possible values for
+@var{infotype} and the kind of OS information available for each
+@var{infotype}.  If the target does not return a list of possible
+types, this command will report an error.
 @end table
 
 @node Memory Region Attributes
index 67192d9e7172ce2d659c52d64f6a0bd493a56218..b66ef43f57fbd3b9c2a90bc6db5ec218a28ef579 100644 (file)
@@ -1,3 +1,8 @@
+2011-12-26  Kwok Cheung Yeung  <kcy@codesourcery.com>
+
+       * gdb.base/info-os.exp: New file.
+       * gdb.base/info-os.c: New file.
+
 2012-05-10  Joel Brobecker  <brobecker@adacore.com>
 
        * config/djgpp/fnchange.lst: Add entries for print-file-var-lib1.c,
diff --git a/gdb/testsuite/gdb.base/info-os.c b/gdb/testsuite/gdb.base/info-os.c
new file mode 100644 (file)
index 0000000..2971671
--- /dev/null
@@ -0,0 +1,115 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2011 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <sys/shm.h>
+#include <sys/sem.h>
+#include <sys/msg.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void *
+thread_proc (void *args)
+{
+  pthread_mutex_lock (&mutex);
+  pthread_mutex_unlock (&mutex);
+}
+
+int
+main (void)
+{
+  const int flags = IPC_CREAT | 0666;
+  int shmid, semid, msqid;
+  FILE *fd;
+  pthread_t thread;
+  struct sockaddr_in sock_addr;
+  int sock;
+  unsigned short port;
+  socklen_t size;
+  int status;
+
+  if ((shmid = shmget (3925, 4096, flags | IPC_EXCL)) < 0)
+    {
+      /* Attempt to delete the existing shared-memory region, then
+        recreate it.  */
+      shmctl (shmget (3925, 4096, flags), IPC_RMID, NULL);
+      if ((shmid = shmget (3925, 4096, flags | IPC_EXCL)) < 0)
+       {
+         printf ("Cannot create shared-memory region.\n");
+         return 1;
+       }         
+    }
+
+  semid = semget (7428, 1, flags);
+  msqid = msgget (5294, flags);
+  fd = fopen ("/dev/null", "r");
+
+  /* Lock the mutex to prevent the new thread from finishing immediately.  */
+  pthread_mutex_lock (&mutex);
+  pthread_create (&thread, NULL, thread_proc, 0);
+  sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (sock < 0)
+    {
+      printf ("Cannot create socket.\n");
+      return 1;
+    }
+  sock_addr.sin_family = AF_INET;
+  sock_addr.sin_port = 0; /* Bind to a free port.  */
+  sock_addr.sin_addr.s_addr = htonl (INADDR_ANY);
+
+  status = bind (sock, (struct sockaddr *) &sock_addr, sizeof (sock_addr));
+  if (status < 0)
+    {
+      printf ("Cannot bind socket.\n");
+      return 1;
+    }
+
+  /* Find the assigned port number of the socket.  */
+  size = sizeof (sock_addr);
+  status = getsockname (sock, (struct sockaddr *) &sock_addr, &size);
+  if (status < 0)
+    {
+      printf ("Cannot find name of socket.\n");
+      return 1;
+    }
+  port = ntohs (sock_addr.sin_port);
+
+  status = listen (sock, 1);
+  if (status < 0)
+    {
+      printf ("Cannot listen on socket.\n");
+      return 1;
+    }
+
+  /* Set breakpoint here.  */
+
+  shmctl (shmid, IPC_RMID, NULL);
+  semctl (semid, 0, IPC_RMID, NULL);
+  msgctl (msqid, IPC_RMID, NULL);
+  fclose (fd);
+  close (sock);
+
+  pthread_mutex_unlock (&mutex);
+  pthread_join (thread, NULL);
+
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.base/info-os.exp b/gdb/testsuite/gdb.base/info-os.exp
new file mode 100644 (file)
index 0000000..e1f7224
--- /dev/null
@@ -0,0 +1,110 @@
+# Copyright 2011 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set testfile "info-os"
+set srcfile ${testfile}.c
+
+# This test is Linux-only.
+if ![istarget *-*-linux*] then {
+    unsupported "info-os.exp"
+    return -1
+}
+
+# Support for XML-output is needed to run this test.
+if [gdb_skip_xml_test] then {
+    unsupported "info-os.exp"
+    return -1
+}
+
+# Compile test program.
+if { [prepare_for_testing ${testfile}.exp $testfile $srcfile {debug additional_flags=-lpthread}] } {
+    fail "cannot compile test program"
+    return -1
+}
+
+if ![runto_main] then {
+    fail "cannot run to main"
+    return -1;
+}
+
+# Get PID of test program.
+set inferior_pid -1
+set test "get inferior process ID"
+gdb_test_multiple "call getpid()" $test {
+    -re ".* = ($decimal).*$gdb_prompt $" {
+       set inferior_pid $expect_out(1,string)
+       pass $test
+    }
+}
+
+gdb_breakpoint ${srcfile}:[gdb_get_line_number "Set breakpoint here"]
+gdb_continue_to_breakpoint "Set breakpoint here"
+
+# Get IDs of the IPC object instances.
+set shmid -1
+set test "get shared memory ID"
+gdb_test_multiple "print shmid" $test {
+    -re ".* = ($decimal).*$gdb_prompt $" {
+       set shmid $expect_out(1,string)
+       pass $test
+    }
+}
+
+set semid -1
+set test "get semaphore ID"
+gdb_test_multiple "print semid" $test {
+    -re ".* = ($decimal).*$gdb_prompt $" {
+       set semid $expect_out(1,string)
+       pass $test
+    }
+}
+
+set msqid -1
+set test "get message queue ID"
+gdb_test_multiple "print msqid" $test {
+    -re ".* = ($decimal).*$gdb_prompt $" {
+       set msqid $expect_out(1,string)
+       pass $test
+    }
+}
+
+# Get port number of test socket.
+set port -1
+set test "get socket port number"
+gdb_test_multiple "print port" $test {
+    -re ".* = ($decimal).*$gdb_prompt $" {
+       set port $expect_out(1,string)
+       pass $test
+    }
+}
+
+# Test output of the 'info os' commands against the expected results.
+gdb_test "info os processes" ".*pid +user +command +cores.*$inferior_pid +\\S+ +\\S*info-os +\[0-9\]+.*" "get process list"
+gdb_test "info os procgroups" ".*pgid +leader command +pid +command line.*$inferior_pid +info-os +$inferior_pid +\\S*info-os.*" "get process groups"
+gdb_test "info os threads" ".*pid +command +tid +core.*$inferior_pid +info-os +\\d+ +\\d+.*" "get threads"
+gdb_test "info os files" ".*pid +command +file descriptor +name.*$inferior_pid +info-os +\\d+ +/dev/null.*" "get file descriptors"
+gdb_test "info os sockets" ".*local address +local port +remote address +remote port +state +user +family +protocol.*0\\.0\\.0\\.0 +$port +0\\.0\\.0\\.0 +0 +LISTEN +\\S+ +INET +STREAM.*" "get internet-domain sockets"
+gdb_test "info os shm" ".*key +shmid +permissions +size +creator command +last op\\. command +num attached +user +group +creator user +creator group +last shmat\\(\\) time +last shmdt\\(\\) time +last shmctl\\(\\) time.*3925 +$shmid +666 +4096 +info-os +.*" "get shared-memory regions"
+gdb_test "info os semaphores" ".*key +semid +permissions +num semaphores +user +group +creator user +creator group +last semop\\(\\) time +last semctl\\(\\) time.*7428 +$semid +666 +1 +.*" "get semaphores"
+gdb_test "info os msg" ".*key +msqid +permissions +num used bytes +num messages +last msgsnd\\(\\) command +last msgrcv\\(\\) command +user +group +creator user +creator group +last msgsnd\\(\\) time +last msgrcv\\(\\) time +last msgctl\\(\\) time.*5294 +$msqid +666 +.*" "get message queues"
+
+# The SysV IPC primitives linger on after the creating process is killed
+# unless they are destroyed explicitly, so allow the test program to tidy
+# up after itself.  Note that the test program attempts to delete and
+# recreate the shared-memory region if it already exists, in case a
+# previous run failed before having a chance to clean up.  The tests for
+# semaphores and message queues should still work with primitives from
+# previous runs.
+send_gdb "continue\n"