275 lines
8.3 KiB
C
275 lines
8.3 KiB
C
/* Monitoring file descriptor usage.
|
|
Copyright (C) 2018-2019 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library 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
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <dirent.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <support/check.h>
|
|
#include <support/support.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/sysmacros.h>
|
|
#include <xunistd.h>
|
|
|
|
struct procfs_descriptor
|
|
{
|
|
int fd;
|
|
char *link_target;
|
|
dev_t dev;
|
|
ino64_t ino;
|
|
};
|
|
|
|
/* Used with qsort. */
|
|
static int
|
|
descriptor_compare (const void *l, const void *r)
|
|
{
|
|
const struct procfs_descriptor *left = l;
|
|
const struct procfs_descriptor *right = r;
|
|
/* Cannot overflow due to limited file descriptor range. */
|
|
return left->fd - right->fd;
|
|
}
|
|
|
|
#define DYNARRAY_STRUCT descriptor_list
|
|
#define DYNARRAY_ELEMENT struct procfs_descriptor
|
|
#define DYNARRAY_PREFIX descriptor_list_
|
|
#define DYNARRAY_ELEMENT_FREE(e) free ((e)->link_target)
|
|
#define DYNARRAY_INITIAL_SIZE 0
|
|
#include <malloc/dynarray-skeleton.c>
|
|
|
|
struct support_descriptors
|
|
{
|
|
struct descriptor_list list;
|
|
};
|
|
|
|
struct support_descriptors *
|
|
support_descriptors_list (void)
|
|
{
|
|
struct support_descriptors *result = xmalloc (sizeof (*result));
|
|
descriptor_list_init (&result->list);
|
|
|
|
DIR *fds = opendir ("/proc/self/fd");
|
|
if (fds == NULL)
|
|
FAIL_EXIT1 ("opendir (\"/proc/self/fd\"): %m");
|
|
|
|
while (true)
|
|
{
|
|
errno = 0;
|
|
struct dirent64 *e = readdir64 (fds);
|
|
if (e == NULL)
|
|
{
|
|
if (errno != 0)
|
|
FAIL_EXIT1 ("readdir: %m");
|
|
break;
|
|
}
|
|
|
|
if (e->d_name[0] == '.')
|
|
continue;
|
|
|
|
char *endptr;
|
|
long int fd = strtol (e->d_name, &endptr, 10);
|
|
if (*endptr != '\0' || fd < 0 || fd > INT_MAX)
|
|
FAIL_EXIT1 ("readdir: invalid file descriptor name: /proc/self/fd/%s",
|
|
e->d_name);
|
|
|
|
/* Skip the descriptor which is used to enumerate the
|
|
descriptors. */
|
|
if (fd == dirfd (fds))
|
|
continue;
|
|
|
|
char *target;
|
|
{
|
|
char *path = xasprintf ("/proc/self/fd/%ld", fd);
|
|
target = xreadlink (path);
|
|
free (path);
|
|
}
|
|
struct stat64 st;
|
|
if (fstat64 (fd, &st) != 0)
|
|
FAIL_EXIT1 ("readdir: fstat64 (%ld) failed: %m", fd);
|
|
|
|
struct procfs_descriptor *item = descriptor_list_emplace (&result->list);
|
|
if (item == NULL)
|
|
FAIL_EXIT1 ("descriptor_list_emplace: %m");
|
|
item->fd = fd;
|
|
item->link_target = target;
|
|
item->dev = st.st_dev;
|
|
item->ino = st.st_ino;
|
|
}
|
|
|
|
closedir (fds);
|
|
|
|
/* Perform a merge join between descrs and current. This assumes
|
|
that the arrays are sorted by file descriptor. */
|
|
|
|
qsort (descriptor_list_begin (&result->list),
|
|
descriptor_list_size (&result->list),
|
|
sizeof (struct procfs_descriptor), descriptor_compare);
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
support_descriptors_free (struct support_descriptors *descrs)
|
|
{
|
|
descriptor_list_free (&descrs->list);
|
|
free (descrs);
|
|
}
|
|
|
|
void
|
|
support_descriptors_dump (struct support_descriptors *descrs,
|
|
const char *prefix, FILE *fp)
|
|
{
|
|
struct procfs_descriptor *end = descriptor_list_end (&descrs->list);
|
|
for (struct procfs_descriptor *d = descriptor_list_begin (&descrs->list);
|
|
d != end; ++d)
|
|
{
|
|
char *quoted = support_quote_string (d->link_target);
|
|
fprintf (fp, "%s%d: target=\"%s\" major=%lld minor=%lld ino=%lld\n",
|
|
prefix, d->fd, quoted,
|
|
(long long int) major (d->dev),
|
|
(long long int) minor (d->dev),
|
|
(long long int) d->ino);
|
|
free (quoted);
|
|
}
|
|
}
|
|
|
|
static void
|
|
dump_mismatch (bool *first,
|
|
struct support_descriptors *descrs,
|
|
struct support_descriptors *current)
|
|
{
|
|
if (*first)
|
|
*first = false;
|
|
else
|
|
return;
|
|
|
|
puts ("error: Differences found in descriptor set");
|
|
puts ("Reference descriptor set:");
|
|
support_descriptors_dump (descrs, " ", stdout);
|
|
puts ("Current descriptor set:");
|
|
support_descriptors_dump (current, " ", stdout);
|
|
puts ("Differences:");
|
|
}
|
|
|
|
static void
|
|
report_closed_descriptor (bool *first,
|
|
struct support_descriptors *descrs,
|
|
struct support_descriptors *current,
|
|
struct procfs_descriptor *left)
|
|
{
|
|
support_record_failure ();
|
|
dump_mismatch (first, descrs, current);
|
|
printf ("error: descriptor %d was closed\n", left->fd);
|
|
}
|
|
|
|
static void
|
|
report_opened_descriptor (bool *first,
|
|
struct support_descriptors *descrs,
|
|
struct support_descriptors *current,
|
|
struct procfs_descriptor *right)
|
|
{
|
|
support_record_failure ();
|
|
dump_mismatch (first, descrs, current);
|
|
char *quoted = support_quote_string (right->link_target);
|
|
printf ("error: descriptor %d was opened (\"%s\")\n", right->fd, quoted);
|
|
free (quoted);
|
|
}
|
|
|
|
void
|
|
support_descriptors_check (struct support_descriptors *descrs)
|
|
{
|
|
struct support_descriptors *current = support_descriptors_list ();
|
|
|
|
/* Perform a merge join between descrs and current. This assumes
|
|
that the arrays are sorted by file descriptor. */
|
|
|
|
struct procfs_descriptor *left = descriptor_list_begin (&descrs->list);
|
|
struct procfs_descriptor *left_end = descriptor_list_end (&descrs->list);
|
|
struct procfs_descriptor *right = descriptor_list_begin (¤t->list);
|
|
struct procfs_descriptor *right_end = descriptor_list_end (¤t->list);
|
|
|
|
bool first = true;
|
|
while (left != left_end && right != right_end)
|
|
{
|
|
if (left->fd == right->fd)
|
|
{
|
|
if (strcmp (left->link_target, right->link_target) != 0)
|
|
{
|
|
support_record_failure ();
|
|
char *left_quoted = support_quote_string (left->link_target);
|
|
char *right_quoted = support_quote_string (right->link_target);
|
|
dump_mismatch (&first, descrs, current);
|
|
printf ("error: descriptor %d changed from \"%s\" to \"%s\"\n",
|
|
left->fd, left_quoted, right_quoted);
|
|
free (left_quoted);
|
|
free (right_quoted);
|
|
}
|
|
if (left->dev != right->dev)
|
|
{
|
|
support_record_failure ();
|
|
dump_mismatch (&first, descrs, current);
|
|
printf ("error: descriptor %d changed device"
|
|
" from %lld:%lld to %lld:%lld\n",
|
|
left->fd,
|
|
(long long int) major (left->dev),
|
|
(long long int) minor (left->dev),
|
|
(long long int) major (right->dev),
|
|
(long long int) minor (right->dev));
|
|
}
|
|
if (left->ino != right->ino)
|
|
{
|
|
support_record_failure ();
|
|
dump_mismatch (&first, descrs, current);
|
|
printf ("error: descriptor %d changed ino from %lld to %lld\n",
|
|
left->fd,
|
|
(long long int) left->ino, (long long int) right->ino);
|
|
}
|
|
++left;
|
|
++right;
|
|
}
|
|
else if (left->fd < right->fd)
|
|
{
|
|
/* Gap on the right. */
|
|
report_closed_descriptor (&first, descrs, current, left);
|
|
++left;
|
|
}
|
|
else
|
|
{
|
|
/* Gap on the left. */
|
|
TEST_VERIFY_EXIT (left->fd > right->fd);
|
|
report_opened_descriptor (&first, descrs, current, right);
|
|
++right;
|
|
}
|
|
}
|
|
|
|
while (left != left_end)
|
|
{
|
|
/* Closed descriptors (more descriptors on the left). */
|
|
report_closed_descriptor (&first, descrs, current, left);
|
|
++left;
|
|
}
|
|
|
|
while (right != right_end)
|
|
{
|
|
/* Opened descriptors (more descriptors on the right). */
|
|
report_opened_descriptor (&first, descrs, current, right);
|
|
++right;
|
|
}
|
|
|
|
support_descriptors_free (current);
|
|
}
|