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 "gdb_stat.h"
  33
  34 #ifdef USE_WIN32API
  35 #include <winsock2.h>
  36 #include <windows.h>
  37 #define HAVE_SOCKETS 1
  38 #elif defined HAVE_SYS_SOCKET_H
  39 #include <sys/socket.h>
  40 /* Define HAVE_F_GETFD if we plan to use F_GETFD.  */
  41 #define HAVE_F_GETFD F_GETFD
  42 #define HAVE_SOCKETS 1
  43 #endif
  44
  45 #ifdef HAVE_SYS_RESOURCE_H
  46 #include <sys/resource.h>
  47 #endif /* HAVE_SYS_RESOURCE_H */
  48
  49 #ifndef O_CLOEXEC
  50 #define O_CLOEXEC 0
  51 #endif
  52
  53 #ifndef SOCK_CLOEXEC
  54 #define SOCK_CLOEXEC 0
  55 #endif
  56
  57 \f
  58
  59 #ifndef HAVE_FDWALK
  60
  61 #include "gdb_dirent.h"
  62
  63 /* Replacement for fdwalk, if the system doesn't define it.  Walks all
  64    open file descriptors (though this implementation may walk closed
  65    ones as well, depending on the host platform's capabilities) and
  66    call FUNC with ARG.  If FUNC returns non-zero, stops immediately
  67    and returns the same value.  Otherwise, returns zero when
  68    finished.  */
  69
  70 static int
  71 fdwalk (int (*func) (void *, int), void *arg)
  72 {
  73   /* Checking __linux__ isn't great but it isn't clear what would be
  74      better.  There doesn't seem to be a good way to check for this in
  75      configure.  */
  76 #ifdef __linux__
  77   DIR *dir;
  78
  79   dir = opendir ("/proc/self/fd");
  80   if (dir != NULL)
  81     {
  82       struct dirent *entry;
  83       int result = 0;
  84
  85       for (entry = readdir (dir); entry != NULL; entry = readdir (dir))
  86         {
  87           long fd;
  88           char *tail;
  89           int result;
  90
  91           errno = 0;
  92           fd = strtol (entry->d_name, &tail, 10);
  93           if (*tail != '\0' || errno != 0)
  94             continue;
  95           if ((int) fd != fd)
  96             {
  97               /* What can we do here really?  */
  98               continue;
  99             }
 100
 101           if (fd == dirfd (dir))
 102             continue;
 103
 104           result = func (arg, fd);
 105           if (result != 0)
 106             break;
 107         }
 108
 109       closedir (dir);
 110       return result;
 111     }
 112   /* We may fall through to the next case.  */
 113 #endif
 114
 115   {
 116     int max, fd;
 117
 118 #ifdef HAVE_GETRLIMIT
 119     struct rlimit rlim;
 120
 121     if (getrlimit (RLIMIT_NOFILE, &rlim) == 0 && rlim.rlim_max != RLIM_INFINITY)
 122       max = rlim.rlim_max;
 123     else
 124 #endif
 125       {
 126 #ifdef _SC_OPEN_MAX
 127         max = sysconf (_SC_OPEN_MAX);
 128 #else
 129         /* Whoops.  */
 130         return 0;
 131 #endif /* _SC_OPEN_MAX */
 132       }
 133
 134     for (fd = 0; fd < max; ++fd)
 135       {
 136         struct stat sb;
 137         int result;
 138
 139         /* Only call FUNC for open fds.  */
 140         if (fstat (fd, &sb) == -1)
 141           continue;
 142
 143         result = func (arg, fd);
 144         if (result != 0)
 145           return result;
 146       }
 147
 148     return 0;
 149   }
 150 }
 151
 152 #endif /* HAVE_FDWALK */
 153
 154 \f
 155
 156 /* A VEC holding all the fds open when notice_open_fds was called.  We
 157    don't use a hashtab because libiberty isn't linked into gdbserver;
 158    and anyway we don't expect there to be many open fds.  */
 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 /* See filestuff.h.  */
 181
 182 void
 183 mark_fd_no_cloexec (int fd)
 184 {
 185   do_mark_open_fd (NULL, fd);
 186 }
 187
 188 /* See filestuff.h.  */
 189
 190 void
 191 unmark_fd_no_cloexec (int fd)
 192 {
 193   int i, val;
 194
 195   for (i = 0; VEC_iterate (int, open_fds, i, val); ++i)
 196     {
 197       if (fd == val)
 198         {
 199           VEC_unordered_remove (int, open_fds, i);
 200           return;
 201         }
 202     }
 203
 204   gdb_assert_not_reached (_("fd not found in open_fds"));
 205 }
 206
 207 /* Helper function for close_most_fds that closes the file descriptor
 208    if appropriate.  */
 209
 210 static int
 211 do_close (void *ignore, int fd)
 212 {
 213   int i, val;
 214
 215   for (i = 0; VEC_iterate (int, open_fds, i, val); ++i)
 216     {
 217       if (fd == val)
 218         {
 219           /* Keep this one open.  */
 220           return 0;
 221         }
 222     }
 223
 224   close (fd);
 225   return 0;
 226 }
 227
 228 /* See filestuff.h.  */
 229
 230 void
 231 close_most_fds (void)
 232 {
 233   fdwalk (do_close, NULL);
 234 }
 235
 236 \f
 237
 238 /* This is a tri-state flag.  When zero it means we haven't yet tried
 239    O_CLOEXEC.  When positive it means that O_CLOEXEC works on this
 240    host.  When negative, it means that O_CLOEXEC doesn't work.  We
 241    track this state because, while gdb might have been compiled
 242    against a libc that supplies O_CLOEXEC, there is no guarantee that
 243    the kernel supports it.  */
 244
 245 static int trust_o_cloexec;
 246
 247 /* Mark FD as close-on-exec, ignoring errors.  Update
 248    TRUST_O_CLOEXEC.  */
 249
 250 static void
 251 mark_cloexec (int fd)
 252 {
 253 #ifdef HAVE_F_GETFD
 254   int old = fcntl (fd, F_GETFD, 0);
 255
 256   if (old != -1)
 257     {
 258       fcntl (fd, F_SETFD, old | FD_CLOEXEC);
 259
 260       if (trust_o_cloexec == 0)
 261         {
 262           if ((old & FD_CLOEXEC) != 0)
 263             trust_o_cloexec = 1;
 264           else
 265             trust_o_cloexec = -1;
 266         }
 267     }
 268 #endif /* HAVE_F_GETFD */
 269 }
 270
 271 /* Depending on TRUST_O_CLOEXEC, mark FD as close-on-exec.  */
 272
 273 static void
 274 maybe_mark_cloexec (int fd)
 275 {
 276   if (trust_o_cloexec <= 0)
 277     mark_cloexec (fd);
 278 }
 279
 280 #ifdef HAVE_SOCKETS
 281
 282 /* Like maybe_mark_cloexec, but for callers that use SOCK_CLOEXEC.  */
 283
 284 static void
 285 socket_mark_cloexec (int fd)
 286 {
 287   if (SOCK_CLOEXEC == 0 || trust_o_cloexec <= 0)
 288     mark_cloexec (fd);
 289 }
 290
 291 #endif
 292
 293 \f
 294
 295 /* See filestuff.h.  */
 296
 297 int
 298 gdb_open_cloexec (const char *filename, int flags, unsigned long mode)
 299 {
 300   int fd = open (filename, flags | O_CLOEXEC, mode);
 301
 302   if (fd >= 0)
 303     maybe_mark_cloexec (fd);
 304
 305   return fd;
 306 }
 307
 308 /* See filestuff.h.  */
 309
 310 FILE *
 311 gdb_fopen_cloexec (const char *filename, const char *opentype)
 312 {
 313   FILE *result = NULL;
 314   static int fopen_e_ever_failed;
 315
 316   if (!fopen_e_ever_failed)
 317     {
 318       char *copy;
 319
 320       copy = alloca (strlen (opentype) + 2);
 321       strcpy (copy, opentype);
 322       /* This is a glibc extension but we try it unconditionally on
 323          this path.  */
 324       strcat (copy, "e");
 325       result = fopen (filename, copy);
 326     }
 327
 328   if (result == NULL)
 329     {
 330       /* Fallback.  */
 331       result = fopen (filename, opentype);
 332       if (result != NULL)
 333         fopen_e_ever_failed = 1;
 334     }
 335
 336   if (result != NULL)
 337     maybe_mark_cloexec (fileno (result));
 338
 339   return result;
 340 }
 341
 342 #ifdef HAVE_SOCKETS
 343 /* See filestuff.h.  */
 344
 345 int
 346 gdb_socketpair_cloexec (int namespace, int style, int protocol, int filedes[2])
 347 {
 348 #ifdef HAVE_SOCKETPAIR
 349   int result = socketpair (namespace, style | SOCK_CLOEXEC, protocol, filedes);
 350
 351   if (result != -1)
 352     {
 353       socket_mark_cloexec (filedes[0]);
 354       socket_mark_cloexec (filedes[1]);
 355     }
 356
 357   return result;
 358 #else
 359   gdb_assert_not_reached (_("socketpair not available on this host"));
 360 #endif
 361 }
 362
 363 /* See filestuff.h.  */
 364
 365 int
 366 gdb_socket_cloexec (int namespace, int style, int protocol)
 367 {
 368   int result = socket (namespace, style | SOCK_CLOEXEC, protocol);
 369
 370   if (result != -1)
 371     socket_mark_cloexec (result);
 372
 373   return result;
 374 }
 375 #endif
 376
 377 /* See filestuff.h.  */
 378
 379 int
 380 gdb_pipe_cloexec (int filedes[2])
 381 {
 382   int result;
 383
 384 #ifdef HAVE_PIPE2
 385   result = pipe2 (filedes, O_CLOEXEC);
 386   if (result != -1)
 387     {
 388       maybe_mark_cloexec (filedes[0]);
 389       maybe_mark_cloexec (filedes[1]);
 390     }
 391 #else
 392 #ifdef HAVE_PIPE
 393   result = pipe (filedes);
 394   if (result != -1)
 395     {
 396       mark_cloexec (filedes[0]);
 397       mark_cloexec (filedes[1]);
 398     }
 399 #else /* HAVE_PIPE */
 400   gdb_assert_not_reached (_("pipe not available on this host"));
 401 #endif /* HAVE_PIPE */
 402 #endif /* HAVE_PIPE2 */
 403
 404   return result;
 405 }