support/support_descriptors.c

   1 /* Monitoring file descriptor usage.
   2    Copyright (C) 2018-2019 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <dirent.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <support/check.h>
  24 #include <support/support.h>
  25 #include <sys/stat.h>
  26 #include <sys/sysmacros.h>
  27 #include <xunistd.h>
  28
  29 struct procfs_descriptor
  30 {
  31   int fd;
  32   char *link_target;
  33   dev_t dev;
  34   ino64_t ino;
  35 };
  36
  37 /* Used with qsort.  */
  38 static int
  39 descriptor_compare (const void *l, const void *r)
  40 {
  41   const struct procfs_descriptor *left = l;
  42   const struct procfs_descriptor *right = r;
  43   /* Cannot overflow due to limited file descriptor range.  */
  44   return left->fd - right->fd;
  45 }
  46
  47 #define DYNARRAY_STRUCT descriptor_list
  48 #define DYNARRAY_ELEMENT struct procfs_descriptor
  49 #define DYNARRAY_PREFIX descriptor_list_
  50 #define DYNARRAY_ELEMENT_FREE(e) free ((e)->link_target)
  51 #define DYNARRAY_INITIAL_SIZE 0
  52 #include <malloc/dynarray-skeleton.c>
  53
  54 struct support_descriptors
  55 {
  56   struct descriptor_list list;
  57 };
  58
  59 struct support_descriptors *
  60 support_descriptors_list (void)
  61 {
  62   struct support_descriptors *result = xmalloc (sizeof (*result));
  63   descriptor_list_init (&result->list);
  64
  65   DIR *fds = opendir ("/proc/self/fd");
  66   if (fds == NULL)
  67     FAIL_EXIT1 ("opendir (\"/proc/self/fd\"): %m");
  68
  69   while (true)
  70     {
  71       errno = 0;
  72       struct dirent64 *e = readdir64 (fds);
  73       if (e == NULL)
  74         {
  75           if (errno != 0)
  76             FAIL_EXIT1 ("readdir: %m");
  77           break;
  78         }
  79
  80       if (e->d_name[0] == '.')
  81         continue;
  82
  83       char *endptr;
  84       long int fd = strtol (e->d_name, &endptr, 10);
  85       if (*endptr != '\0' || fd < 0 || fd > INT_MAX)
  86         FAIL_EXIT1 ("readdir: invalid file descriptor name: /proc/self/fd/%s",
  87                     e->d_name);
  88
  89       /* Skip the descriptor which is used to enumerate the
  90          descriptors.  */
  91       if (fd == dirfd (fds))
  92         continue;
  93
  94       char *target;
  95       {
  96         char *path = xasprintf ("/proc/self/fd/%ld", fd);
  97         target = xreadlink (path);
  98         free (path);
  99       }
 100       struct stat64 st;
 101       if (fstat64 (fd, &st) != 0)
 102         FAIL_EXIT1 ("readdir: fstat64 (%ld) failed: %m", fd);
 103
 104       struct procfs_descriptor *item = descriptor_list_emplace (&result->list);
 105       if (item == NULL)
 106         FAIL_EXIT1 ("descriptor_list_emplace: %m");
 107       item->fd = fd;
 108       item->link_target = target;
 109       item->dev = st.st_dev;
 110       item->ino = st.st_ino;
 111     }
 112
 113   closedir (fds);
 114
 115   /* Perform a merge join between descrs and current.  This assumes
 116      that the arrays are sorted by file descriptor.  */
 117
 118   qsort (descriptor_list_begin (&result->list),
 119          descriptor_list_size (&result->list),
 120          sizeof (struct procfs_descriptor), descriptor_compare);
 121
 122   return result;
 123 }
 124
 125 void
 126 support_descriptors_free (struct support_descriptors *descrs)
 127 {
 128   descriptor_list_free (&descrs->list);
 129   free (descrs);
 130 }
 131
 132 void
 133 support_descriptors_dump (struct support_descriptors *descrs,
 134                           const char *prefix, FILE *fp)
 135 {
 136   struct procfs_descriptor *end = descriptor_list_end (&descrs->list);
 137   for (struct procfs_descriptor *d = descriptor_list_begin (&descrs->list);
 138        d != end; ++d)
 139     {
 140       char *quoted = support_quote_string (d->link_target);
 141       fprintf (fp, "%s%d: target=\"%s\" major=%lld minor=%lld ino=%lld\n",
 142                prefix, d->fd, quoted,
 143                (long long int) major (d->dev),
 144                (long long int) minor (d->dev),
 145                (long long int) d->ino);
 146       free (quoted);
 147     }
 148 }
 149
 150 static void
 151 dump_mismatch (bool *first,
 152                struct support_descriptors *descrs,
 153                struct support_descriptors *current)
 154 {
 155   if (*first)
 156     *first = false;
 157   else
 158     return;
 159
 160   puts ("error: Differences found in descriptor set");
 161   puts ("Reference descriptor set:");
 162   support_descriptors_dump (descrs, "  ", stdout);
 163   puts ("Current descriptor set:");
 164   support_descriptors_dump (current, "  ", stdout);
 165   puts ("Differences:");
 166 }
 167
 168 static void
 169 report_closed_descriptor (bool *first,
 170                           struct support_descriptors *descrs,
 171                           struct support_descriptors *current,
 172                           struct procfs_descriptor *left)
 173 {
 174   support_record_failure ();
 175   dump_mismatch (first, descrs, current);
 176   printf ("error: descriptor %d was closed\n", left->fd);
 177 }
 178
 179 static void
 180 report_opened_descriptor (bool *first,
 181                           struct support_descriptors *descrs,
 182                           struct support_descriptors *current,
 183                           struct procfs_descriptor *right)
 184 {
 185   support_record_failure ();
 186   dump_mismatch (first, descrs, current);
 187   char *quoted = support_quote_string (right->link_target);
 188   printf ("error: descriptor %d was opened (\"%s\")\n", right->fd, quoted);
 189   free (quoted);
 190 }
 191
 192 void
 193 support_descriptors_check (struct support_descriptors *descrs)
 194 {
 195   struct support_descriptors *current = support_descriptors_list ();
 196
 197   /* Perform a merge join between descrs and current.  This assumes
 198      that the arrays are sorted by file descriptor.  */
 199
 200   struct procfs_descriptor *left = descriptor_list_begin (&descrs->list);
 201   struct procfs_descriptor *left_end = descriptor_list_end (&descrs->list);
 202   struct procfs_descriptor *right = descriptor_list_begin (&current->list);
 203   struct procfs_descriptor *right_end = descriptor_list_end (&current->list);
 204
 205   bool first = true;
 206   while (left != left_end && right != right_end)
 207     {
 208       if (left->fd == right->fd)
 209         {
 210           if (strcmp (left->link_target, right->link_target) != 0)
 211             {
 212               support_record_failure ();
 213               char *left_quoted = support_quote_string (left->link_target);
 214               char *right_quoted = support_quote_string (right->link_target);
 215               dump_mismatch (&first, descrs, current);
 216               printf ("error: descriptor %d changed from \"%s\" to \"%s\"\n",
 217                       left->fd, left_quoted, right_quoted);
 218               free (left_quoted);
 219               free (right_quoted);
 220             }
 221           if (left->dev != right->dev)
 222             {
 223               support_record_failure ();
 224               dump_mismatch (&first, descrs, current);
 225               printf ("error: descriptor %d changed device"
 226                       " from %lld:%lld to %lld:%lld\n",
 227                       left->fd,
 228                       (long long int) major (left->dev),
 229                       (long long int) minor (left->dev),
 230                       (long long int) major (right->dev),
 231                       (long long int) minor (right->dev));
 232             }
 233           if (left->ino != right->ino)
 234             {
 235               support_record_failure ();
 236               dump_mismatch (&first, descrs, current);
 237               printf ("error: descriptor %d changed ino from %lld to %lld\n",
 238                       left->fd,
 239                       (long long int) left->ino, (long long int) right->ino);
 240             }
 241           ++left;
 242           ++right;
 243         }
 244       else if (left->fd < right->fd)
 245         {
 246           /* Gap on the right.  */
 247           report_closed_descriptor (&first, descrs, current, left);
 248           ++left;
 249         }
 250       else
 251         {
 252           /* Gap on the left.  */
 253           TEST_VERIFY_EXIT (left->fd > right->fd);
 254           report_opened_descriptor (&first, descrs, current, right);
 255           ++right;
 256         }
 257     }
 258
 259   while (left != left_end)
 260     {
 261       /* Closed descriptors (more descriptors on the left).  */
 262       report_closed_descriptor (&first, descrs, current, left);
 263       ++left;
 264     }
 265
 266   while (right != right_end)
 267     {
 268       /* Opened descriptors (more descriptors on the right).  */
 269       report_opened_descriptor (&first, descrs, current, right);
 270       ++right;
 271     }
 272
 273   support_descriptors_free (current);
 274 }