GDBserver
filestuff.c
Go to the documentation of this file.
1 /* Low-level file-handling.
2  Copyright (C) 2012-2015 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 #include "common-defs.h"
20 #include "filestuff.h"
21 #include "gdb_vecs.h"
22 #include <fcntl.h>
23 #include <unistd.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 
27 #ifdef USE_WIN32API
28 #include <winsock2.h>
29 #include <windows.h>
30 #define HAVE_SOCKETS 1
31 #elif defined HAVE_SYS_SOCKET_H
32 #include <sys/socket.h>
33 /* Define HAVE_F_GETFD if we plan to use F_GETFD. */
34 #define HAVE_F_GETFD F_GETFD
35 #define HAVE_SOCKETS 1
36 #endif
37 
38 #ifdef HAVE_SYS_RESOURCE_H
39 #include <sys/resource.h>
40 #endif /* HAVE_SYS_RESOURCE_H */
41 
42 #ifndef O_CLOEXEC
43 #define O_CLOEXEC 0
44 #endif
45 
46 #ifndef SOCK_CLOEXEC
47 #define SOCK_CLOEXEC 0
48 #endif
49 
50 
51 
52 #ifndef HAVE_FDWALK
53 
54 #include <dirent.h>
55 
56 /* Replacement for fdwalk, if the system doesn't define it. Walks all
57  open file descriptors (though this implementation may walk closed
58  ones as well, depending on the host platform's capabilities) and
59  call FUNC with ARG. If FUNC returns non-zero, stops immediately
60  and returns the same value. Otherwise, returns zero when
61  finished. */
62 
63 static int
64 fdwalk (int (*func) (void *, int), void *arg)
65 {
66  /* Checking __linux__ isn't great but it isn't clear what would be
67  better. There doesn't seem to be a good way to check for this in
68  configure. */
69 #ifdef __linux__
70  DIR *dir;
71 
72  dir = opendir ("/proc/self/fd");
73  if (dir != NULL)
74  {
75  struct dirent *entry;
76  int result = 0;
77 
78  for (entry = readdir (dir); entry != NULL; entry = readdir (dir))
79  {
80  long fd;
81  char *tail;
82  int result;
83 
84  errno = 0;
85  fd = strtol (entry->d_name, &tail, 10);
86  if (*tail != '\0' || errno != 0)
87  continue;
88  if ((int) fd != fd)
89  {
90  /* What can we do here really? */
91  continue;
92  }
93 
94  if (fd == dirfd (dir))
95  continue;
96 
97  result = func (arg, fd);
98  if (result != 0)
99  break;
100  }
101 
102  closedir (dir);
103  return result;
104  }
105  /* We may fall through to the next case. */
106 #endif
107 
108  {
109  int max, fd;
110 
111 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
112  struct rlimit rlim;
113 
114  if (getrlimit (RLIMIT_NOFILE, &rlim) == 0 && rlim.rlim_max != RLIM_INFINITY)
115  max = rlim.rlim_max;
116  else
117 #endif
118  {
119 #ifdef _SC_OPEN_MAX
120  max = sysconf (_SC_OPEN_MAX);
121 #else
122  /* Whoops. */
123  return 0;
124 #endif /* _SC_OPEN_MAX */
125  }
126 
127  for (fd = 0; fd < max; ++fd)
128  {
129  struct stat sb;
130  int result;
131 
132  /* Only call FUNC for open fds. */
133  if (fstat (fd, &sb) == -1)
134  continue;
135 
136  result = func (arg, fd);
137  if (result != 0)
138  return result;
139  }
140 
141  return 0;
142  }
143 }
144 
145 #endif /* HAVE_FDWALK */
146 
147 
148 
149 /* A VEC holding all the fds open when notice_open_fds was called. We
150  don't use a hashtab because libiberty isn't linked into gdbserver;
151  and anyway we don't expect there to be many open fds. */
152 
153 static VEC (int) *open_fds;
154 
155 /* An fdwalk callback function used by notice_open_fds. It puts the
156  given file descriptor into the vec. */
157 
158 static int
159 do_mark_open_fd (void *ignore, int fd)
160 {
161  VEC_safe_push (int, open_fds, fd);
162  return 0;
163 }
164 
165 /* See filestuff.h. */
166 
167 void
169 {
170  fdwalk (do_mark_open_fd, NULL);
171 }
172 
173 /* See filestuff.h. */
174 
175 void
177 {
178  do_mark_open_fd (NULL, fd);
179 }
180 
181 /* See filestuff.h. */
182 
183 void
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  VEC_unordered_remove (int, open_fds, i);
193  return;
194  }
195  }
196 
197  gdb_assert_not_reached (_("fd not found in open_fds"));
198 }
199 
200 /* Helper function for close_most_fds that closes the file descriptor
201  if appropriate. */
202 
203 static int
204 do_close (void *ignore, int fd)
205 {
206  int i, val;
207 
208  for (i = 0; VEC_iterate (int, open_fds, i, val); ++i)
209  {
210  if (fd == val)
211  {
212  /* Keep this one open. */
213  return 0;
214  }
215  }
216 
217  close (fd);
218  return 0;
219 }
220 
221 /* See filestuff.h. */
222 
223 void
225 {
226  fdwalk (do_close, NULL);
227 }
228 
229 
230 
231 /* This is a tri-state flag. When zero it means we haven't yet tried
232  O_CLOEXEC. When positive it means that O_CLOEXEC works on this
233  host. When negative, it means that O_CLOEXEC doesn't work. We
234  track this state because, while gdb might have been compiled
235  against a libc that supplies O_CLOEXEC, there is no guarantee that
236  the kernel supports it. */
237 
238 static int trust_o_cloexec;
239 
240 /* Mark FD as close-on-exec, ignoring errors. Update
241  TRUST_O_CLOEXEC. */
242 
243 static void
244 mark_cloexec (int fd)
245 {
246 #ifdef HAVE_F_GETFD
247  int old = fcntl (fd, F_GETFD, 0);
248 
249  if (old != -1)
250  {
251  fcntl (fd, F_SETFD, old | FD_CLOEXEC);
252 
253  if (trust_o_cloexec == 0)
254  {
255  if ((old & FD_CLOEXEC) != 0)
256  trust_o_cloexec = 1;
257  else
258  trust_o_cloexec = -1;
259  }
260  }
261 #endif /* HAVE_F_GETFD */
262 }
263 
264 /* Depending on TRUST_O_CLOEXEC, mark FD as close-on-exec. */
265 
266 static void
268 {
269  if (trust_o_cloexec <= 0)
270  mark_cloexec (fd);
271 }
272 
273 #ifdef HAVE_SOCKETS
274 
275 /* Like maybe_mark_cloexec, but for callers that use SOCK_CLOEXEC. */
276 
277 static void
278 socket_mark_cloexec (int fd)
279 {
280  if (SOCK_CLOEXEC == 0 || trust_o_cloexec <= 0)
281  mark_cloexec (fd);
282 }
283 
284 #endif
285 
286 
287 
288 /* See filestuff.h. */
289 
290 int
291 gdb_open_cloexec (const char *filename, int flags, unsigned long mode)
292 {
293  int fd = open (filename, flags | O_CLOEXEC, mode);
294 
295  if (fd >= 0)
296  maybe_mark_cloexec (fd);
297 
298  return fd;
299 }
300 
301 /* See filestuff.h. */
302 
303 FILE *
304 gdb_fopen_cloexec (const char *filename, const char *opentype)
305 {
306  FILE *result;
307  /* Probe for "e" support once. But, if we can tell the operating
308  system doesn't know about close on exec mode "e" without probing,
309  skip it. E.g., the Windows runtime issues an "Invalid parameter
310  passed to C runtime function" OutputDebugString warning for
311  unknown modes. Assume that if O_CLOEXEC is zero, then "e" isn't
312  supported. */
313  static int fopen_e_ever_failed_einval = O_CLOEXEC == 0;
314 
315  if (!fopen_e_ever_failed_einval)
316  {
317  char *copy;
318 
319  copy = alloca (strlen (opentype) + 2);
320  strcpy (copy, opentype);
321  /* This is a glibc extension but we try it unconditionally on
322  this path. */
323  strcat (copy, "e");
324  result = fopen (filename, copy);
325 
326  if (result == NULL && errno == EINVAL)
327  {
328  result = fopen (filename, opentype);
329  if (result != NULL)
330  fopen_e_ever_failed_einval = 1;
331  }
332  }
333  else
334  result = fopen (filename, opentype);
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 domain, int style, int protocol,
347  int filedes[2])
348 {
349 #ifdef HAVE_SOCKETPAIR
350  int result = socketpair (domain, style | SOCK_CLOEXEC, protocol, filedes);
351 
352  if (result != -1)
353  {
354  socket_mark_cloexec (filedes[0]);
355  socket_mark_cloexec (filedes[1]);
356  }
357 
358  return result;
359 #else
360  gdb_assert_not_reached (_("socketpair not available on this host"));
361 #endif
362 }
363 
364 /* See filestuff.h. */
365 
366 int
367 gdb_socket_cloexec (int domain, int style, int protocol)
368 {
369  int result = socket (domain, style | SOCK_CLOEXEC, protocol);
370 
371  if (result != -1)
372  socket_mark_cloexec (result);
373 
374  return result;
375 }
376 #endif
377 
378 /* See filestuff.h. */
379 
380 int
381 gdb_pipe_cloexec (int filedes[2])
382 {
383  int result;
384 
385 #ifdef HAVE_PIPE2
386  result = pipe2 (filedes, O_CLOEXEC);
387  if (result != -1)
388  {
389  maybe_mark_cloexec (filedes[0]);
390  maybe_mark_cloexec (filedes[1]);
391  }
392 #else
393 #ifdef HAVE_PIPE
394  result = pipe (filedes);
395  if (result != -1)
396  {
397  mark_cloexec (filedes[0]);
398  mark_cloexec (filedes[1]);
399  }
400 #else /* HAVE_PIPE */
401  gdb_assert_not_reached (_("pipe not available on this host"));
402 #endif /* HAVE_PIPE */
403 #endif /* HAVE_PIPE2 */
404 
405  return result;
406 }
407 
408 /* Helper function which does the work for make_cleanup_close. */
409 
410 static void
411 do_close_cleanup (void *arg)
412 {
413  int *fd = arg;
414 
415  close (*fd);
416 }
417 
418 /* See cleanup-utils.h. */
419 
420 struct cleanup *
422 {
423  int *saved_fd = xmalloc (sizeof (fd));
424 
425  *saved_fd = fd;
426  return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);
427 }
#define O_CLOEXEC
Definition: filestuff.c:43
static void mark_cloexec(int fd)
Definition: filestuff.c:244
int gdb_socketpair_cloexec(int domain, int style, int protocol, int filedes[2])
void notice_open_fds(void)
Definition: filestuff.c:168
static int fdwalk(int(*func)(void *, int), void *arg)
Definition: filestuff.c:64
static struct fd_list * open_fds
Definition: hostio.c:40
int gdb_socket_cloexec(int domain, int style, int protocol)
int gdb_pipe_cloexec(int filedes[2])
Definition: filestuff.c:381
#define VEC_unordered_remove(T, V, I)
Definition: vec.h:351
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
FILE * gdb_fopen_cloexec(const char *filename, const char *opentype)
Definition: filestuff.c:304
static VEC(int)
Definition: filestuff.c:153
#define _(String)
Definition: gdb_locale.h:40
static void do_close_cleanup(void *arg)
Definition: filestuff.c:411
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
void unmark_fd_no_cloexec(int fd)
Definition: filestuff.c:184
static int do_close(void *ignore, int fd)
Definition: filestuff.c:204
struct cleanup * make_cleanup_dtor(make_cleanup_ftype *function, void *arg, make_cleanup_dtor_ftype *dtor)
Definition: cleanups.c:126
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
struct cleanup * make_cleanup_close(int fd)
Definition: filestuff.c:421
void close_most_fds(void)
Definition: filestuff.c:224
#define errno
Definition: wincecompat.h:24
static int trust_o_cloexec
Definition: filestuff.c:238
void xfree(void *ptr)
Definition: common-utils.c:97
void * alloca(size_t)
#define SOCK_CLOEXEC
Definition: filestuff.c:47
int gdb_open_cloexec(const char *filename, int flags, unsigned long mode)
Definition: filestuff.c:291
PTR xmalloc(size_t size)
Definition: common-utils.c:34
void * arg
Definition: cleanups.c:43
void mark_fd_no_cloexec(int fd)
Definition: filestuff.c:176
static void maybe_mark_cloexec(int fd)
Definition: filestuff.c:267