gdb/common/filestuff.c

   1 /* Low-level file-handling.
   2    Copyright (C) 2012, 2013 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #ifdef GDBSERVER
  20 #include "server.h"
  21 #else
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #endif
  25 #include "filestuff.h"
  26 #include "gdb_vecs.h"
  27
  28 #include <string.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33
  34 #ifdef USE_WIN32API
  35 #include <winsock2.h>
  36 #include <windows.h>
  37 #else
  38 #include <sys/socket.h>
  39 /* Define HAVE_F_GETFD if we plan to use F_GETFD.  */
  40 #define HAVE_F_GETFD F_GETFD
  41 #endif
  42
  43 #ifdef HAVE_SYS_RESOURCE_H
  44 #include <sys/resource.h>
  45 #endif /* HAVE_SYS_RESOURCE_H */
  46
  47 #ifndef O_CLOEXEC
  48 #define O_CLOEXEC 0
  49 #endif
  50
  51 #ifndef SOCK_CLOEXEC
  52 #define SOCK_CLOEXEC 0
  53 #endif
  54
  55 \f
  56
  57 #ifndef HAVE_FDWALK
  58
  59 #include <dirent.h>
  60
  61 /* Replacement for fdwalk, if the system doesn't define it.  Walks all
  62    open file descriptors (though this implementation may walk closed
  63    ones as well, depending on the host platform's capabilities) and
  64    call FUNC with ARG.  If FUNC returns non-zero, stops immediately
  65    and returns the same value.  Otherwise, returns zero when
  66    finished.  */
  67
  68 static int
  69 fdwalk (int (*func) (void *, int), void *arg)
  70 {
  71   /* Checking __linux__ isn't great but it isn't clear what would be
  72      better.  There doesn't seem to be a good way to check for this in
  73      configure.  */
  74 #ifdef __linux__
  75   DIR *dir;
  76
  77   dir = opendir ("/proc/self/fd");
  78   if (dir != NULL)
  79     {
  80       struct dirent *entry;
  81       int result = 0;
  82
  83       for (entry = readdir (dir); entry != NULL; entry = readdir (dir))
  84         {
  85           long fd;
  86           char *tail;
  87           int result;
  88
  89           errno = 0;
  90           fd = strtol (entry->d_name, &tail, 10);
  91           if (*tail != '\0' || errno != 0)
  92             continue;
  93           if ((int) fd != fd)
  94             {
  95               /* What can we do here really?  */
  96               continue;
  97             }
  98
  99           if (fd == dirfd (dir))
 100             continue;
 101
 102           result = func (arg, fd);
 103           if (result != 0)
 104             break;
 105         }
 106
 107       closedir (dir);
 108       return result;
 109     }
 110   /* We may fall through to the next case.  */
 111 #endif
 112
 113   {
 114     int max, fd;
 115
 116 #ifdef HAVE_GETRLIMIT
 117     struct rlimit rlim;
 118
 119     if (getrlimit (RLIMIT_NOFILE, &rlim) == 0 && rlim.rlim_max != RLIM_INFINITY)
 120       max = rlim.rlim_max;
 121     else
 122 #endif
 123       {
 124 #ifdef _SC_OPEN_MAX
 125         max = sysconf (_SC_OPEN_MAX);
 126 #else
 127         /* Whoops.  */
 128         return 0;
 129 #endif /* _SC_OPEN_MAX */
 130       }
 131
 132     for (fd = 0; fd < max; ++fd)
 133       {
 134         struct stat sb;
 135         int result;
 136
 137         /* Only call FUNC for open fds.  */
 138         if (fstat (fd, &sb) == -1)
 139           continue;
 140
 141         result = func (arg, fd);
 142         if (result != 0)
 143           return result;
 144       }
 145
 146     return 0;
 147   }
 148 }
 149
 150 #endif /* HAVE_FDWALK */
 151
 152 \f
 153
 154 /* A VEC holding all the fds open when notice_open_fds was called.  We
 155    don't use a hashtab because libiberty isn't linked into gdbserver;
 156    and anyway we don't expect there to be many open fds.  */
 157
 158 DEF_VEC_I (int);
 159
 160 static VEC (int) *open_fds;
 161
 162 /* An fdwalk callback function used by notice_open_fds.  It puts the
 163    given file descriptor into the vec.  */
 164
 165 static int
 166 do_mark_open_fd (void *ignore, int fd)
 167 {
 168   VEC_safe_push (int, open_fds, fd);
 169   return 0;
 170 }
 171
 172 /* See filestuff.h.  */
 173
 174 void
 175 notice_open_fds (void)
 176 {
 177   fdwalk (do_mark_open_fd, NULL);
 178 }
 179
 180 /* Helper function for close_most_fds that closes the file descriptor
 181    if appropriate.  */
 182
 183 static int
 184 do_close (void *ignore, int fd)
 185 {
 186   int i, val;
 187
 188   for (i = 0; VEC_iterate (int, open_fds, i, val); ++i)
 189     {
 190       if (fd == val)
 191         {
 192           /* Keep this one open.  */
 193           return 0;
 194         }
 195     }
 196
 197   close (fd);
 198   return 0;
 199 }
 200
 201 /* See filestuff.h.  */
 202
 203 void
 204 close_most_fds (void)
 205 {
 206   fdwalk (do_close, NULL);
 207 }
 208
 209 \f
 210
 211 /* This is a tri-state flag.  When zero it means we haven't yet tried
 212    O_CLOEXEC.  When positive it means that O_CLOEXEC works on this
 213    host.  When negative, it means that O_CLOEXEC doesn't work.  We
 214    track this state because, while gdb might have been compiled
 215    against a libc that supplies O_CLOEXEC, there is no guarantee that
 216    the kernel supports it.  */
 217
 218 static int trust_o_cloexec;
 219
 220 /* Mark FD as close-on-exec, ignoring errors.  Update
 221    TRUST_O_CLOEXEC.  */
 222
 223 static void
 224 mark_cloexec (int fd)
 225 {
 226 #ifdef HAVE_F_GETFD
 227   int old = fcntl (fd, F_GETFD, 0);
 228
 229   if (old != -1)
 230     {
 231       fcntl (fd, F_SETFD, old | FD_CLOEXEC);
 232
 233       if (trust_o_cloexec == 0)
 234         {
 235           if ((old & FD_CLOEXEC) != 0)
 236             trust_o_cloexec = 1;
 237           else
 238             trust_o_cloexec = -1;
 239         }
 240     }
 241 #endif /* HAVE_F_GETFD */
 242 }
 243
 244 /* Depending on TRUST_O_CLOEXEC, mark FD as close-on-exec.  */
 245
 246 static void
 247 maybe_mark_cloexec (int fd)
 248 {
 249   if (trust_o_cloexec <= 0)
 250     mark_cloexec (fd);
 251 }
 252
 253 /* Like maybe_mark_cloexec, but for callers that use SOCK_CLOEXEC.  */
 254
 255 static void
 256 socket_mark_cloexec (int fd)
 257 {
 258   if (SOCK_CLOEXEC == 0 || trust_o_cloexec <= 0)
 259     mark_cloexec (fd);
 260 }
 261
 262 \f
 263
 264 /* See filestuff.h.  */
 265
 266 int
 267 gdb_open_cloexec (const char *filename, int flags, unsigned long mode)
 268 {
 269   int fd = open (filename, flags | O_CLOEXEC, mode);
 270
 271   if (fd >= 0)
 272     maybe_mark_cloexec (fd);
 273
 274   return fd;
 275 }
 276
 277 /* See filestuff.h.  */
 278
 279 FILE *
 280 gdb_fopen_cloexec (const char *filename, const char *opentype)
 281 {
 282   FILE *result = NULL;
 283   static int fopen_e_ever_failed;
 284
 285   if (!fopen_e_ever_failed)
 286     {
 287       char *copy;
 288
 289       copy = alloca (strlen (opentype) + 2);
 290       strcpy (copy, opentype);
 291       /* This is a glibc extension but we try it unconditionally on
 292          this path.  */
 293       strcat (copy, "e");
 294       result = fopen (filename, copy);
 295     }
 296
 297   if (result == NULL)
 298     {
 299       /* Fallback.  */
 300       result = fopen (filename, opentype);
 301       if (result != NULL)
 302         fopen_e_ever_failed = 1;
 303     }
 304
 305   if (result != NULL)
 306     maybe_mark_cloexec (fileno (result));
 307
 308   return result;
 309 }
 310
 311 /* See filestuff.h.  */
 312
 313 int
 314 gdb_socketpair_cloexec (int namespace, int style, int protocol, int filedes[2])
 315 {
 316 #ifdef HAVE_SOCKETPAIR
 317   int result = socketpair (namespace, style | SOCK_CLOEXEC, protocol, filedes);
 318
 319   if (result != -1)
 320     {
 321       socket_mark_cloexec (filedes[0]);
 322       socket_mark_cloexec (filedes[1]);
 323     }
 324
 325   return result;
 326 #else
 327   gdb_assert_not_reached (_("socketpair not available on this host"));
 328 #endif
 329 }
 330
 331 /* See filestuff.h.  */
 332
 333 int
 334 gdb_socket_cloexec (int namespace, int style, int protocol)
 335 {
 336   int result = socket (namespace, style | SOCK_CLOEXEC, protocol);
 337
 338   if (result != -1)
 339     socket_mark_cloexec (result);
 340
 341   return result;
 342 }
 343
 344 /* See filestuff.h.  */
 345
 346 int
 347 gdb_pipe_cloexec (int filedes[2])
 348 {
 349   int result;
 350
 351 #ifdef HAVE_PIPE2
 352   result = pipe2 (filedes, O_CLOEXEC);
 353   if (result != -1)
 354     {
 355       maybe_mark_cloexec (filedes[0]);
 356       maybe_mark_cloexec (filedes[1]);
 357     }
 358 #else
 359 #ifdef HAVE_PIPE
 360   result = pipe (filedes);
 361   if (result != -1)
 362     {
 363       mark_cloexec (filedes[0]);
 364       mark_cloexec (filedes[1]);
 365     }
 366 #else /* HAVE_PIPE */
 367   gdb_assert_not_reached (_("pipe not available on this host"));
 368 #endif /* HAVE_PIPE */
 369 #endif /* HAVE_PIPE2 */
 370
 371   return result;
 372 }