Re: [PATCH] Add extra 'info os' information types for Linux

[Kwok Cheung Yeung <kcy@codesourcery.com>]

[-- Attachment #1: Type: text/plain, Size: 3815 bytes --]

Sorry for the late reply - I was busy on another project.

On 21/10/2011 9:57 PM, Tom Tromey wrote:
>>> +static int
>>> +compare_processes (const void *process1, const void *process2)
>
> Most of the new functions need introductory comments.
>

I've now commented all the auxilliary functions used by the 
linux_xfer_osdata_<data type> functions.

>>> +  static struct buffer buffer;
>
> Wow, another growable buffer type.  I didn't know about this one.
> Let's see.. VEC, dynstr, obstack, buffer... can we have a 5th?  :)
>

buffer was used in the gdbserver implementation of Linux osdata, while obstacks 
were used in the gdb implementation. When combining the two, I went with buffer 
since it was self-contained in GDB (it is implemented in gdb/common/buffer.[hc]).

>>> +	      char procentry[sizeof ("/proc/4294967295")];
>
> One occasionally hears talk of 64 bit PIDs.
>
>>> +static void
>>> +time_from_int (char *time, int maxlen, int seconds)
>
> Why int and not just time_t?
> ...
>
>>> +		  items_read = sscanf (buf,
>>> +				       "%d %d %o %d %d %d %d %u %u %u %u %d %d %d",
>>> +				&key,&shmid,&perms,&size,
>>> +				&cpid,&lpid,
>>> +				&nattch,
>>> +				&uid,&gid,&cuid,&cgid,
>>> +				&atime,&dtime,&ctime);
> [...]
>>> +		      char atime_str[32], dtime_str[32], ctime_str[32];
> [...]
>>> +		      time_from_int (atime_str, sizeof (atime_str), atime);
>>> +		      time_from_int (dtime_str, sizeof (dtime_str), dtime);
>>> +		      time_from_int (ctime_str, sizeof (ctime_str), ctime);
>
> I think it is probably better to use long at least.
>

I have worked around the issue of the sizes of time_t and pid_t by defining my 
own local versions (TIME_T and PID_T) which are of a known type. The code in 
linux-osdata.c works with these types and cast to/from time_t/pid_t when calling 
external functions. I have also changed buffer_xml_printf to be able to handle 
long and long long format specifiers in the format string.

 >>> +#if 0
 >>> +			  struct stat statbuf;
 >>> +			  stat (dp2->d_name,&statbuf);
 >>> +#endif
 >
 > No new #if 0 code.
 >

Now removed.

Kwok


ChangeLog:

gdb/
	* common/linux-osdata.c (PID_T, TIME_T): Add local versions of pid_t and
	time_t to avoid problems with the size of the native versions.
	(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): Auxiliary function for
	linux_xfer_osdata_processgroups.
	(linux_xfer_osdata_processgroups): New function to
	look up process groups.
	(linux_xfer_osdata_threads): Change to use PID_T.
	(linux_xfer_osdata_fds): New function to look up file descriptors.
	(format_socket_state, print_sockets): Auxiliary functions for
	linux_xfer_osdata_isockets.
	(union socket_addr): New union used to avoid strict-aliasing problems.
	(linux_xfer_osdata_isockets): New function to look up internet sockets.
	(time_from_time_t, group_from_gid): New convenience functions for
	converting between data types.	
	(linux_xfer_osdata_shm): New function to look up shared memory for IPC.
	(linux_xfer_osdata_sem): New function to look up semaphores for IPC.
	(linux_xfer_osdata_msg): New function to look up message queues for
	IPC.
	(linux_xfer_osdata_modules): New function to look up loaded kernel
	modules.
	(osdata_table): Add new entries.
	* common/buffer.c (buffer_xml_printf): Add support for long and
	long long format specifiers.

[-- Attachment #2: os-awareness_2.patch --]
[-- Type: text/plain, Size: 35502 bytes --]

Index: gdb/common/linux-osdata.c
===================================================================
RCS file: /cvs/src/src/gdb/common/linux-osdata.c,v
retrieving revision 1.2
diff -u -p -r1.2 linux-osdata.c
--- gdb/common/linux-osdata.c	26 Aug 2011 18:58:04 -0000	1.2
+++ gdb/common/linux-osdata.c	23 Nov 2011 17:55:53 -0000
@@ -45,12 +45,19 @@
 #include "gdb_assert.h"
 #include "gdb_dirent.h"
 
+/* PID_T/TIME_T are used in place of pid_t/time_t to avoid making
+   assumptions about the size of the native versions.  */
+typedef long long  PID_T;
+typedef long long  TIME_T;
+
+#define MAX_PID_T_STRLEN  (sizeof ("-9223372036854775808") - 1)
+
+/* Returns the CPU core that thread PTID is currently running on.  */
+					  
 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;
@@ -59,8 +66,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;
@@ -102,10 +109,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';
@@ -116,8 +127,8 @@ command_from_pid (char *command, int max
 	 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)
 	{
@@ -130,7 +141,7 @@ command_from_pid (char *command, int max
   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.  */
@@ -142,9 +153,9 @@ command_from_pid (char *command, int max
    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");
 
@@ -196,6 +207,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)
 {
@@ -210,13 +224,16 @@ user_from_uid (char *user, int maxlen, u
     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))
     {
@@ -227,6 +244,8 @@ get_process_owner (uid_t *owner, pid_t p
     return -1;
 }
 
+/* Returns the number of CPU cores found on the system.  */
+
 static int
 get_number_of_cpu_cores (void)
 {
@@ -247,31 +266,32 @@ 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)
 	    {
@@ -314,7 +334,7 @@ linux_xfer_osdata_processes (gdb_byte *r
 
 	  while ((dp = readdir (dirp)) != NULL)
 	    {
-	      pid_t pid;
+	      PID_T pid;
 	      uid_t owner;
 	      char user[UT_NAMESIZE];
 	      char *command_line;
@@ -324,10 +344,10 @@ linux_xfer_osdata_processes (gdb_byte *r
 	      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)
@@ -343,7 +363,7 @@ linux_xfer_osdata_processes (gdb_byte *r
 	      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);
@@ -358,7 +378,7 @@ linux_xfer_osdata_processes (gdb_byte *r
 	      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>"
@@ -396,6 +416,151 @@ linux_xfer_osdata_processes (gdb_byte *r
   return len;
 }
 
+/* Auxilliary 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;
+    }
+}
+
+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;
+}
+
 static LONGEST
 linux_xfer_osdata_threads (gdb_byte *readbuf,
 			   ULONGEST offset, LONGEST len)
@@ -436,7 +601,7 @@ linux_xfer_osdata_threads (gdb_byte *rea
 		{
 		  DIR *dirp2;
 		  char *pathname;
-		  pid_t pid;
+		  PID_T pid;
 		  char command[32];
 
 		  pathname = xstrprintf ("/proc/%s/task", dp->d_name);
@@ -452,7 +617,7 @@ linux_xfer_osdata_threads (gdb_byte *rea
 
 		      while ((dp2 = readdir (dirp2)) != NULL)
 			{
-			  pid_t tid;
+			  PID_T tid;
 			  int core;
 
 			  if (!isdigit (dp2->d_name[0])
@@ -465,9 +630,9 @@ linux_xfer_osdata_threads (gdb_byte *rea
 			  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,
@@ -507,13 +672,843 @@ linux_xfer_osdata_threads (gdb_byte *rea
   return len;
 }
 
+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;
+  };
+
+/* Auxilliary 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, txq, rxq, trun, retn;
+	      char local_address[NI_MAXHOST], remote_address[NI_MAXHOST], 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);
+    }
+}
+
+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);
+      group[maxlen - 1] = '\0'; /* Ensure that the group name is null-terminated.  */
+    }
+  else
+    group[0] = '\0';
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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 },
+  { "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: gdb/common/buffer.c
===================================================================
RCS file: /cvs/src/src/gdb/common/buffer.c,v
retrieving revision 1.1
diff -u -p -r1.1 buffer.c
--- gdb/common/buffer.c	21 Jul 2011 23:46:09 -0000	1.1
+++ gdb/common/buffer.c	23 Nov 2011 17:55:53 -0000
@@ -101,6 +101,7 @@ buffer_xml_printf (struct buffer *buffer
 	  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
 	    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);
@@ -137,7 +180,7 @@ buffer_xml_printf (struct buffer *buffer
       else if (*f == '%')
 	percent = 1;
     }
-
+  
   buffer_grow_str (buffer, prev);
   va_end (ap);
 }