mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 04:21:49 +08:00
16a447bec5
The new function will be used in a subsequent patch to read a different stat field. The new code is believed to be equivalent to the old code, so there should be no change in GDB behaviour. The only material change was to use std::string and string_printf rather than a fixed char array to build the path to the stat file. Also, take the opportunity to move the function's documentation comment to the header file, to conform with GDB practice. Reviewed-By: Luis Machado <luis.machado@arm.com> Approved-By: Pedro Alves <pedro@palves.net>
1404 lines
34 KiB
C
1404 lines
34 KiB
C
/* Linux-specific functions to retrieve OS data.
|
|
|
|
Copyright (C) 2009-2024 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
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 "linux-osdata.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/sysinfo.h>
|
|
#include <ctype.h>
|
|
#include <utmp.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <pwd.h>
|
|
#include <grp.h>
|
|
#include <netdb.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include "gdbsupport/xml-utils.h"
|
|
#include <dirent.h>
|
|
#include <sys/stat.h>
|
|
#include "gdbsupport/filestuff.h"
|
|
#include <algorithm>
|
|
#include "linux-procfs.h"
|
|
|
|
#define NAMELEN(dirent) strlen ((dirent)->d_name)
|
|
|
|
/* 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)
|
|
|
|
/* See linux-osdata.h. */
|
|
|
|
int
|
|
linux_common_core_of_thread (ptid_t ptid)
|
|
{
|
|
std::optional<std::string> field
|
|
= linux_proc_get_stat_field (ptid, LINUX_PROC_STAT_PROCESSOR);
|
|
int core;
|
|
|
|
if (!field.has_value () || sscanf (field->c_str (), "%d", &core) == 0)
|
|
return -1;
|
|
|
|
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)
|
|
{
|
|
std::string stat_path = string_printf ("/proc/%lld/stat", pid);
|
|
gdb_file_up fp = gdb_fopen_cloexec (stat_path, "r");
|
|
|
|
command[0] = '\0';
|
|
|
|
if (fp)
|
|
{
|
|
/* sizeof (cmd) should be greater or equal to TASK_COMM_LEN (in
|
|
include/linux/sched.h in the Linux kernel sources) plus two
|
|
(for the brackets). */
|
|
char cmd[18];
|
|
PID_T stat_pid;
|
|
int items_read = fscanf (fp.get (), "%lld %17s", &stat_pid, cmd);
|
|
|
|
if (items_read == 2 && pid == stat_pid)
|
|
{
|
|
cmd[strlen (cmd) - 1] = '\0'; /* Remove trailing parenthesis. */
|
|
strncpy (command, cmd + 1, maxlen); /* Ignore leading parenthesis. */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Return the PID if a /proc entry for the process cannot be found. */
|
|
snprintf (command, maxlen, "%lld", pid);
|
|
}
|
|
|
|
command[maxlen - 1] = '\0'; /* Ensure string is null-terminated. */
|
|
}
|
|
|
|
/* Returns the command-line of the process with the given PID. */
|
|
|
|
static std::string
|
|
commandline_from_pid (PID_T pid)
|
|
{
|
|
std::string pathname = string_printf ("/proc/%lld/cmdline", pid);
|
|
std::string commandline;
|
|
gdb_file_up f = gdb_fopen_cloexec (pathname, "r");
|
|
|
|
if (f)
|
|
{
|
|
while (!feof (f.get ()))
|
|
{
|
|
char buf[1024];
|
|
size_t read_bytes = fread (buf, 1, sizeof (buf), f.get ());
|
|
|
|
if (read_bytes)
|
|
commandline.append (buf, read_bytes);
|
|
}
|
|
|
|
if (!commandline.empty ())
|
|
{
|
|
/* Replace null characters with spaces. */
|
|
for (char &c : commandline)
|
|
if (c == '\0')
|
|
c = ' ';
|
|
}
|
|
else
|
|
{
|
|
/* Return the command in square brackets if the command-line
|
|
is empty. */
|
|
char cmd[32];
|
|
command_from_pid (cmd, 31, pid);
|
|
commandline = std::string ("[") + cmd + "]";
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
struct passwd *pwentry;
|
|
char buf[1024];
|
|
struct passwd pwd;
|
|
getpwuid_r (uid, &pwd, buf, sizeof (buf), &pwentry);
|
|
|
|
if (pwentry)
|
|
{
|
|
strncpy (user, pwentry->pw_name, maxlen - 1);
|
|
/* 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)
|
|
{
|
|
struct stat statbuf;
|
|
char procentry[sizeof ("/proc/") + MAX_PID_T_STRLEN];
|
|
|
|
sprintf (procentry, "/proc/%lld", pid);
|
|
|
|
if (stat (procentry, &statbuf) == 0 && S_ISDIR (statbuf.st_mode))
|
|
{
|
|
*owner = statbuf.st_uid;
|
|
return 0;
|
|
}
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
/* Find the CPU cores used by process PID and return them in CORES.
|
|
CORES points to an array of NUM_CORES elements. */
|
|
|
|
static int
|
|
get_cores_used_by_process (PID_T pid, int *cores, const int num_cores)
|
|
{
|
|
char taskdir[sizeof ("/proc/") + MAX_PID_T_STRLEN + sizeof ("/task") - 1];
|
|
DIR *dir;
|
|
struct dirent *dp;
|
|
int task_count = 0;
|
|
|
|
sprintf (taskdir, "/proc/%lld/task", pid);
|
|
dir = opendir (taskdir);
|
|
if (dir)
|
|
{
|
|
while ((dp = readdir (dir)) != NULL)
|
|
{
|
|
PID_T tid;
|
|
int core;
|
|
|
|
if (!isdigit (dp->d_name[0])
|
|
|| NAMELEN (dp) > MAX_PID_T_STRLEN)
|
|
continue;
|
|
|
|
sscanf (dp->d_name, "%lld", &tid);
|
|
core = linux_common_core_of_thread (ptid_t ((pid_t) pid,
|
|
(pid_t) tid));
|
|
|
|
if (core >= 0 && core < num_cores)
|
|
{
|
|
++cores[core];
|
|
++task_count;
|
|
}
|
|
}
|
|
|
|
closedir (dir);
|
|
}
|
|
|
|
return task_count;
|
|
}
|
|
|
|
/* get_core_array_size helper that uses /sys/devices/system/cpu/possible. */
|
|
|
|
static std::optional<size_t>
|
|
get_core_array_size_using_sys_possible ()
|
|
{
|
|
std::optional<std::string> possible
|
|
= read_text_file_to_string ("/sys/devices/system/cpu/possible");
|
|
|
|
if (!possible.has_value ())
|
|
return {};
|
|
|
|
/* The format is documented here:
|
|
|
|
https://www.kernel.org/doc/Documentation/admin-guide/cputopology.rst
|
|
|
|
For the purpose of this function, we assume the file can contain a complex
|
|
set of ranges, like `2,4-31,32-63`. Read all number, disregarding commands
|
|
and dashes, in order to find the largest possible core number. The size
|
|
of the array to allocate is that plus one. */
|
|
|
|
unsigned long max_id = 0;
|
|
for (std::string::size_type start = 0; start < possible->size ();)
|
|
{
|
|
const char *start_p = &(*possible)[start];
|
|
char *end_p;
|
|
|
|
/* Parse one number. */
|
|
errno = 0;
|
|
unsigned long id = strtoul (start_p, &end_p, 10);
|
|
if (errno != 0)
|
|
return {};
|
|
|
|
max_id = std::max (max_id, id);
|
|
|
|
start += end_p - start_p;
|
|
gdb_assert (start <= possible->size ());
|
|
|
|
/* Skip comma, dash, or new line (if we are at the end). */
|
|
++start;
|
|
}
|
|
|
|
return max_id + 1;
|
|
}
|
|
|
|
/* Return the array size to allocate in order to be able to index it using
|
|
CPU core numbers. This may be more than the actual number of cores if
|
|
the core numbers are not contiguous. */
|
|
|
|
static size_t
|
|
get_core_array_size ()
|
|
{
|
|
/* Using /sys/.../possible is preferred, because it handles the case where
|
|
we are in a container that has access to a subset of the host's cores.
|
|
It will return a size that considers all the CPU cores available to the
|
|
host. If that fails for some reason, fall back to sysconf. */
|
|
std::optional<size_t> count = get_core_array_size_using_sys_possible ();
|
|
if (count.has_value ())
|
|
return *count;
|
|
|
|
return sysconf (_SC_NPROCESSORS_ONLN);
|
|
}
|
|
|
|
static std::string
|
|
linux_xfer_osdata_processes ()
|
|
{
|
|
DIR *dirp;
|
|
std::string buffer = "<osdata type=\"processes\">\n";
|
|
|
|
dirp = opendir ("/proc");
|
|
if (dirp)
|
|
{
|
|
const int core_array_size = get_core_array_size ();
|
|
struct dirent *dp;
|
|
|
|
while ((dp = readdir (dirp)) != NULL)
|
|
{
|
|
PID_T pid;
|
|
uid_t owner;
|
|
char user[UT_NAMESIZE];
|
|
int *cores;
|
|
int task_count;
|
|
std::string cores_str;
|
|
int i;
|
|
|
|
if (!isdigit (dp->d_name[0])
|
|
|| NAMELEN (dp) > MAX_PID_T_STRLEN)
|
|
continue;
|
|
|
|
sscanf (dp->d_name, "%lld", &pid);
|
|
std::string command_line = commandline_from_pid (pid);
|
|
|
|
if (get_process_owner (&owner, pid) == 0)
|
|
user_from_uid (user, sizeof (user), owner);
|
|
else
|
|
strcpy (user, "?");
|
|
|
|
/* Find CPU cores used by the process. */
|
|
cores = XCNEWVEC (int, core_array_size);
|
|
task_count = get_cores_used_by_process (pid, cores, core_array_size);
|
|
|
|
for (i = 0; i < core_array_size && task_count > 0; ++i)
|
|
if (cores[i])
|
|
{
|
|
string_appendf (cores_str, "%d", i);
|
|
|
|
task_count -= cores[i];
|
|
if (task_count > 0)
|
|
cores_str += ",";
|
|
}
|
|
|
|
xfree (cores);
|
|
|
|
string_xml_appendf
|
|
(buffer,
|
|
"<item>"
|
|
"<column name=\"pid\">%lld</column>"
|
|
"<column name=\"user\">%s</column>"
|
|
"<column name=\"command\">%s</column>"
|
|
"<column name=\"cores\">%s</column>"
|
|
"</item>",
|
|
pid,
|
|
user,
|
|
command_line.c_str (),
|
|
cores_str.c_str());
|
|
}
|
|
|
|
closedir (dirp);
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* A simple PID/PGID pair. */
|
|
|
|
struct pid_pgid_entry
|
|
{
|
|
pid_pgid_entry (PID_T pid_, PID_T pgid_)
|
|
: pid (pid_), pgid (pgid_)
|
|
{}
|
|
|
|
/* Return true if this pid is the leader of its process group. */
|
|
|
|
bool is_leader () const
|
|
{
|
|
return pid == pgid;
|
|
}
|
|
|
|
bool operator< (const pid_pgid_entry &other) const
|
|
{
|
|
/* Sort by PGID. */
|
|
if (this->pgid != other.pgid)
|
|
return this->pgid < other.pgid;
|
|
|
|
/* Process group leaders always come first... */
|
|
if (this->is_leader ())
|
|
{
|
|
if (!other.is_leader ())
|
|
return true;
|
|
}
|
|
else if (other.is_leader ())
|
|
return false;
|
|
|
|
/* ...else sort by PID. */
|
|
return this->pid < other.pid;
|
|
}
|
|
|
|
PID_T pid, pgid;
|
|
};
|
|
|
|
/* Collect all process groups from /proc in BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_processgroups ()
|
|
{
|
|
DIR *dirp;
|
|
std::string buffer = "<osdata type=\"process groups\">\n";
|
|
|
|
dirp = opendir ("/proc");
|
|
if (dirp)
|
|
{
|
|
std::vector<pid_pgid_entry> process_list;
|
|
struct dirent *dp;
|
|
|
|
process_list.reserve (512);
|
|
|
|
/* 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.emplace_back (pid, pgid);
|
|
}
|
|
|
|
closedir (dirp);
|
|
|
|
/* Sort the process list. */
|
|
std::sort (process_list.begin (), process_list.end ());
|
|
|
|
for (const pid_pgid_entry &entry : process_list)
|
|
{
|
|
PID_T pid = entry.pid;
|
|
PID_T pgid = entry.pgid;
|
|
char leader_command[32];
|
|
|
|
command_from_pid (leader_command, sizeof (leader_command), pgid);
|
|
std::string command_line = commandline_from_pid (pid);
|
|
|
|
string_xml_appendf
|
|
(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.c_str ());
|
|
}
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* Collect all the threads in /proc by iterating through processes and
|
|
then tasks within each process. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_threads ()
|
|
{
|
|
DIR *dirp;
|
|
std::string buffer = "<osdata type=\"threads\">\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;
|
|
|
|
xsnprintf (procentry, sizeof (procentry), "/proc/%s",
|
|
dp->d_name);
|
|
if (stat (procentry, &statbuf) == 0
|
|
&& S_ISDIR (statbuf.st_mode))
|
|
{
|
|
DIR *dirp2;
|
|
PID_T pid;
|
|
char command[32];
|
|
|
|
std::string pathname
|
|
= string_printf ("/proc/%s/task", dp->d_name);
|
|
|
|
pid = atoi (dp->d_name);
|
|
command_from_pid (command, sizeof (command), pid);
|
|
|
|
dirp2 = opendir (pathname.c_str ());
|
|
|
|
if (dirp2)
|
|
{
|
|
struct dirent *dp2;
|
|
|
|
while ((dp2 = readdir (dirp2)) != NULL)
|
|
{
|
|
PID_T tid;
|
|
int core;
|
|
|
|
if (!isdigit (dp2->d_name[0])
|
|
|| NAMELEN (dp2) > sizeof ("4294967295") - 1)
|
|
continue;
|
|
|
|
tid = atoi (dp2->d_name);
|
|
core = linux_common_core_of_thread (ptid_t (pid, tid));
|
|
|
|
string_xml_appendf
|
|
(buffer,
|
|
"<item>"
|
|
"<column name=\"pid\">%lld</column>"
|
|
"<column name=\"command\">%s</column>"
|
|
"<column name=\"tid\">%lld</column>"
|
|
"<column name=\"core\">%d</column>"
|
|
"</item>",
|
|
pid,
|
|
command,
|
|
tid,
|
|
core);
|
|
}
|
|
|
|
closedir (dirp2);
|
|
}
|
|
}
|
|
}
|
|
|
|
closedir (dirp);
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* Collect data about the cpus/cores on the system in BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_cpus ()
|
|
{
|
|
int first_item = 1;
|
|
std::string buffer = "<osdata type=\"cpus\">\n";
|
|
|
|
gdb_file_up fp = gdb_fopen_cloexec ("/proc/cpuinfo", "r");
|
|
if (fp != NULL)
|
|
{
|
|
char buf[8192];
|
|
|
|
do
|
|
{
|
|
if (fgets (buf, sizeof (buf), fp.get ()))
|
|
{
|
|
char *key, *value;
|
|
int i = 0;
|
|
|
|
char *saveptr;
|
|
key = strtok_r (buf, ":", &saveptr);
|
|
if (key == NULL)
|
|
continue;
|
|
|
|
value = strtok_r (NULL, ":", &saveptr);
|
|
if (value == NULL)
|
|
continue;
|
|
|
|
while (key[i] != '\t' && key[i] != '\0')
|
|
i++;
|
|
|
|
key[i] = '\0';
|
|
|
|
i = 0;
|
|
while (value[i] != '\t' && value[i] != '\0')
|
|
i++;
|
|
|
|
value[i] = '\0';
|
|
|
|
if (strcmp (key, "processor") == 0)
|
|
{
|
|
if (first_item)
|
|
buffer += "<item>";
|
|
else
|
|
buffer += "</item><item>";
|
|
|
|
first_item = 0;
|
|
}
|
|
|
|
string_xml_appendf (buffer,
|
|
"<column name=\"%s\">%s</column>",
|
|
key,
|
|
value);
|
|
}
|
|
}
|
|
while (!feof (fp.get ()));
|
|
|
|
if (first_item == 0)
|
|
buffer += "</item>";
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* Collect all the open file descriptors found in /proc and put the details
|
|
found about them into BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_fds ()
|
|
{
|
|
DIR *dirp;
|
|
std::string 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;
|
|
|
|
xsnprintf (procentry, sizeof (procentry), "/proc/%s",
|
|
dp->d_name);
|
|
if (stat (procentry, &statbuf) == 0
|
|
&& S_ISDIR (statbuf.st_mode))
|
|
{
|
|
DIR *dirp2;
|
|
PID_T pid;
|
|
char command[32];
|
|
|
|
pid = atoi (dp->d_name);
|
|
command_from_pid (command, sizeof (command), pid);
|
|
|
|
std::string pathname
|
|
= string_printf ("/proc/%s/fd", dp->d_name);
|
|
dirp2 = opendir (pathname.c_str ());
|
|
|
|
if (dirp2)
|
|
{
|
|
struct dirent *dp2;
|
|
|
|
while ((dp2 = readdir (dirp2)) != NULL)
|
|
{
|
|
char buf[1000];
|
|
ssize_t rslt;
|
|
|
|
if (!isdigit (dp2->d_name[0]))
|
|
continue;
|
|
|
|
std::string fdname
|
|
= string_printf ("%s/%s", pathname.c_str (),
|
|
dp2->d_name);
|
|
rslt = readlink (fdname.c_str (), buf,
|
|
sizeof (buf) - 1);
|
|
if (rslt >= 0)
|
|
buf[rslt] = '\0';
|
|
|
|
string_xml_appendf
|
|
(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);
|
|
}
|
|
}
|
|
}
|
|
|
|
closedir (dirp);
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* 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, std::string &buffer)
|
|
{
|
|
const char *proc_file;
|
|
|
|
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;
|
|
|
|
gdb_file_up fp = gdb_fopen_cloexec (proc_file, "r");
|
|
if (fp)
|
|
{
|
|
char buf[8192];
|
|
|
|
do
|
|
{
|
|
if (fgets (buf, sizeof (buf), fp.get ()))
|
|
{
|
|
uid_t uid;
|
|
unsigned int local_port, remote_port, state;
|
|
char local_address[NI_MAXHOST], remote_address[NI_MAXHOST];
|
|
int result;
|
|
|
|
#if NI_MAXHOST <= 32
|
|
#error "local_address and remote_address buffers too small"
|
|
#endif
|
|
|
|
result = sscanf (buf,
|
|
"%*d: %32[0-9A-F]:%X %32[0-9A-F]:%X %X %*X:%*X %*X:%*X %*X %d %*d %*u %*s\n",
|
|
local_address, &local_port,
|
|
remote_address, &remote_port,
|
|
&state,
|
|
&uid);
|
|
|
|
if (result == 6)
|
|
{
|
|
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);
|
|
|
|
string_xml_appendf
|
|
(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.get ()));
|
|
}
|
|
}
|
|
|
|
/* Collect data about internet sockets and write it into BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_isockets ()
|
|
{
|
|
std::string 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 += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
/* Per the ctime_r manpage, this buffer needs to be at least 26
|
|
characters long. */
|
|
char buf[30];
|
|
const char *time_str = ctime_r (&t, buf);
|
|
strncpy (time, time_str, maxlen - 1);
|
|
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 - 1);
|
|
/* 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 BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_shm ()
|
|
{
|
|
std::string buffer = "<osdata type=\"shared memory\">\n";
|
|
|
|
gdb_file_up fp = gdb_fopen_cloexec ("/proc/sysvipc/shm", "r");
|
|
if (fp)
|
|
{
|
|
char buf[8192];
|
|
|
|
do
|
|
{
|
|
if (fgets (buf, sizeof (buf), fp.get ()))
|
|
{
|
|
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);
|
|
|
|
string_xml_appendf
|
|
(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.get ()));
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* Collect data about semaphores recorded in /proc and write it
|
|
into BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_sem ()
|
|
{
|
|
std::string buffer = "<osdata type=\"semaphores\">\n";
|
|
|
|
gdb_file_up fp = gdb_fopen_cloexec ("/proc/sysvipc/sem", "r");
|
|
if (fp)
|
|
{
|
|
char buf[8192];
|
|
|
|
do
|
|
{
|
|
if (fgets (buf, sizeof (buf), fp.get ()))
|
|
{
|
|
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);
|
|
|
|
string_xml_appendf
|
|
(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.get ()));
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* Collect data about message queues recorded in /proc and write it
|
|
into BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_msg ()
|
|
{
|
|
std::string buffer = "<osdata type=\"message queues\">\n";
|
|
|
|
gdb_file_up fp = gdb_fopen_cloexec ("/proc/sysvipc/msg", "r");
|
|
if (fp)
|
|
{
|
|
char buf[8192];
|
|
|
|
do
|
|
{
|
|
if (fgets (buf, sizeof (buf), fp.get ()))
|
|
{
|
|
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);
|
|
|
|
string_xml_appendf
|
|
(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.get ()));
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* Collect data about loaded kernel modules and write it into
|
|
BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_modules ()
|
|
{
|
|
std::string buffer = "<osdata type=\"modules\">\n";
|
|
|
|
gdb_file_up fp = gdb_fopen_cloexec ("/proc/modules", "r");
|
|
if (fp)
|
|
{
|
|
char buf[8192];
|
|
|
|
do
|
|
{
|
|
if (fgets (buf, sizeof (buf), fp.get ()))
|
|
{
|
|
char *name, *dependencies, *status, *tmp, *saveptr;
|
|
unsigned int size;
|
|
unsigned long long address;
|
|
int uses;
|
|
|
|
name = strtok_r (buf, " ", &saveptr);
|
|
if (name == NULL)
|
|
continue;
|
|
|
|
tmp = strtok_r (NULL, " ", &saveptr);
|
|
if (tmp == NULL)
|
|
continue;
|
|
if (sscanf (tmp, "%u", &size) != 1)
|
|
continue;
|
|
|
|
tmp = strtok_r (NULL, " ", &saveptr);
|
|
if (tmp == NULL)
|
|
continue;
|
|
if (sscanf (tmp, "%d", &uses) != 1)
|
|
continue;
|
|
|
|
dependencies = strtok_r (NULL, " ", &saveptr);
|
|
if (dependencies == NULL)
|
|
continue;
|
|
|
|
status = strtok_r (NULL, " ", &saveptr);
|
|
if (status == NULL)
|
|
continue;
|
|
|
|
tmp = strtok_r (NULL, "\n", &saveptr);
|
|
if (tmp == NULL)
|
|
continue;
|
|
if (sscanf (tmp, "%llx", &address) != 1)
|
|
continue;
|
|
|
|
string_xml_appendf (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.get ()));
|
|
}
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static std::string linux_xfer_osdata_info_os_types ();
|
|
|
|
static struct osdata_type {
|
|
const char *type;
|
|
const char *title;
|
|
const char *description;
|
|
std::string (*take_snapshot) ();
|
|
std::string buffer;
|
|
} osdata_table[] = {
|
|
{ "types", "Types", "Listing of info os types you can list",
|
|
linux_xfer_osdata_info_os_types },
|
|
{ "cpus", "CPUs", "Listing of all cpus/cores on the system",
|
|
linux_xfer_osdata_cpus },
|
|
{ "files", "File descriptors", "Listing of all file descriptors",
|
|
linux_xfer_osdata_fds },
|
|
{ "modules", "Kernel modules", "Listing of all loaded kernel modules",
|
|
linux_xfer_osdata_modules },
|
|
{ "msg", "Message queues", "Listing of all message queues",
|
|
linux_xfer_osdata_msg },
|
|
{ "processes", "Processes", "Listing of all processes",
|
|
linux_xfer_osdata_processes },
|
|
{ "procgroups", "Process groups", "Listing of all process groups",
|
|
linux_xfer_osdata_processgroups },
|
|
{ "semaphores", "Semaphores", "Listing of all semaphores",
|
|
linux_xfer_osdata_sem },
|
|
{ "shm", "Shared-memory regions", "Listing of all shared-memory regions",
|
|
linux_xfer_osdata_shm },
|
|
{ "sockets", "Sockets", "Listing of all internet-domain sockets",
|
|
linux_xfer_osdata_isockets },
|
|
{ "threads", "Threads", "Listing of all threads",
|
|
linux_xfer_osdata_threads },
|
|
{ NULL, NULL, NULL }
|
|
};
|
|
|
|
/* Collect data about all types info os can show in BUFFER. */
|
|
|
|
static std::string
|
|
linux_xfer_osdata_info_os_types ()
|
|
{
|
|
std::string buffer = "<osdata type=\"types\">\n";
|
|
|
|
/* Start the below loop at 1, as we do not want to list ourselves. */
|
|
for (int i = 1; osdata_table[i].type; ++i)
|
|
string_xml_appendf (buffer,
|
|
"<item>"
|
|
"<column name=\"Type\">%s</column>"
|
|
"<column name=\"Description\">%s</column>"
|
|
"<column name=\"Title\">%s</column>"
|
|
"</item>",
|
|
osdata_table[i].type,
|
|
osdata_table[i].description,
|
|
osdata_table[i].title);
|
|
|
|
buffer += "</osdata>\n";
|
|
|
|
return buffer;
|
|
}
|
|
|
|
|
|
/* Copies up to LEN bytes in READBUF from offset OFFSET in OSD->BUFFER.
|
|
If OFFSET is zero, first calls OSD->TAKE_SNAPSHOT. */
|
|
|
|
static LONGEST
|
|
common_getter (struct osdata_type *osd,
|
|
gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
|
|
{
|
|
gdb_assert (readbuf);
|
|
|
|
if (offset == 0)
|
|
osd->buffer = osd->take_snapshot ();
|
|
|
|
if (offset >= osd->buffer.size ())
|
|
{
|
|
/* Done. Get rid of the buffer. */
|
|
osd->buffer.clear ();
|
|
return 0;
|
|
}
|
|
|
|
len = std::min (len, osd->buffer.size () - offset);
|
|
memcpy (readbuf, &osd->buffer[offset], len);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
LONGEST
|
|
linux_common_xfer_osdata (const char *annex, gdb_byte *readbuf,
|
|
ULONGEST offset, ULONGEST len)
|
|
{
|
|
if (!annex || *annex == '\0')
|
|
{
|
|
return common_getter (&osdata_table[0],
|
|
readbuf, offset, len);
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; osdata_table[i].type; ++i)
|
|
{
|
|
if (strcmp (annex, osdata_table[i].type) == 0)
|
|
return common_getter (&osdata_table[i],
|
|
readbuf, offset, len);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}
|