From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 22402 invoked by alias); 23 Nov 2011 18:00:23 -0000 Received: (qmail 22368 invoked by uid 22791); 23 Nov 2011 18:00:16 -0000 X-SWARE-Spam-Status: No, hits=-0.5 required=5.0 tests=AWL,BAYES_50,TW_CP X-Spam-Check-By: sourceware.org Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 23 Nov 2011 17:59:57 +0000 Received: from svr-orw-fem-01.mgc.mentorg.com ([147.34.98.93]) by relay1.mentorg.com with esmtp id 1RTH6y-0006Xt-CZ from Kwok_Yeung@mentor.com ; Wed, 23 Nov 2011 09:59:56 -0800 Received: from SVR-IES-FEM-01.mgc.mentorg.com ([137.202.0.104]) by svr-orw-fem-01.mgc.mentorg.com over TLS secured channel with Microsoft SMTPSVC(6.0.3790.4675); Wed, 23 Nov 2011 09:59:56 -0800 Received: from [0.0.0.0] (137.202.0.76) by SVR-IES-FEM-01.mgc.mentorg.com (137.202.0.104) with Microsoft SMTP Server id 14.1.289.1; Wed, 23 Nov 2011 17:59:52 +0000 Message-ID: <4ECD3496.1070609@codesourcery.com> Date: Wed, 23 Nov 2011 18:00:00 -0000 From: Kwok Cheung Yeung User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:8.0) Gecko/20111105 Thunderbird/8.0 MIME-Version: 1.0 To: Tom Tromey CC: Subject: Re: [PATCH] Add extra 'info os' information types for Linux References: <4E95DC58.7030805@codesourcery.com> In-Reply-To: Content-Type: multipart/mixed; boundary="------------020805030109080704030600" Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2011-11/txt/msg00631.txt.bz2 --------------020805030109080704030600 Content-Type: text/plain; charset="ISO-8859-1"; format=flowed Content-Transfer-Encoding: 7bit Content-length: 3815 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_ 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. --------------020805030109080704030600 Content-Type: text/plain; name="os-awareness_2.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="os-awareness_2.patch" Content-length: 35502 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, "" - "%d" + "%lld" "%s" "%s" "%s" @@ -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, "\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, + "" + "%lld" + "%s" + "%lld" + "%s" + "", + pgid, + leader_command, + pid, + command_line ? command_line : ""); + + xfree (command_line); + } + + xfree (process_list); + } + + + buffer_grow_str0 (&buffer, "\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, "" - "%d" + "%lld" "%s" - "%d" + "%lld" "%d" "", 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, "\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, + "" + "%s" + "%s" + "%s" + "%s" + "", + dp->d_name, + command, + dp2->d_name, + (rslt >= 0 ? buf : dp2->d_name)); + } + + closedir (dirp2); + } + + xfree (pathname); + } + } + + closedir (dirp); + } + + buffer_grow_str0 (&buffer, "\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, + "" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "", + 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, "\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, "\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, "\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, + "" + "%d" + "%d" + "%o" + "%d" + "%s" + "%s" + "%d" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "", + 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, "\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, "\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, + "" + "%d" + "%d" + "%o" + "%u" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "", + key, + semid, + perms, + nsems, + user, + group, + cuser, + cgroup, + otime_str, + ctime_str); + } + } + } + while (!feof (fp)); + + fclose (fp); + } + + buffer_grow_str0 (&buffer, "\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, "\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, + "" + "%d" + "%d" + "%o" + "%u" + "%u" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "", + 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, "\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, "\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, + "" + "%s" + "%u" + "%d" + "%s" + "%s" + "%llx" + "", + name, + size, + uses, + dependencies, + status, + address); + } + } + while (!feof (fp)); + + fclose (fp); + } + + buffer_grow_str0 (&buffer, "\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); } --------------020805030109080704030600--