14815796853

Committed 02 May 2025 11:41AM UTC coverage: 72.24% (-0.003%) from 72.243%

Build # 14815796853

Build Type

push

github

Committed by

web-flow

Commit Message

Various changes to prepare for running IWYU on the repository (#37319)

These are various commits that were required to get things compiling
after running IWYU. I think all of them make sense on their own, hence
this split PR to merge them ahead of time.

Coverage Stats

81 of 96 new or added lines in 48 files covered. (84.38%)

209 existing lines in 39 files now uncovered.

297219 of 411432 relevant lines covered (72.24%)

693693.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.88

/src/resolve/resolved-socket-graveyard.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "resolved-manager.h"
#include "resolved-socket-graveyard.h"

#define SOCKET_GRAVEYARD_USEC (5 * USEC_PER_SEC)
#define SOCKET_GRAVEYARD_MAX 100

/* This implements a socket "graveyard" for UDP sockets. If a socket fd is added to the graveyard it is kept
 * open for a couple of more seconds, expecting one reply. Once the reply is received the fd is closed
 * immediately, or if none is received it is closed after the timeout. Why all this? So that if we contact a
 * DNS server, and it doesn't reply instantly, and we lose interest in the response and thus close the fd, we
 * don't end up sending back an ICMP error once the server responds but we aren't listening anymore. (See
 * https://github.com/systemd/systemd/issues/17421 for further information.)
 *
 * Note that we don't allocate any timer event source to clear up the graveyard once the socket's timeout is
 * reached. Instead we operate lazily: we close old entries when adding a new fd to the graveyard, or
 * whenever any code runs manager_socket_graveyard_process() — which the DNS transaction code does right
 * before allocating a new UDP socket. */

static SocketGraveyard* socket_graveyard_free(SocketGraveyard *g) {
        if (!g)
                return NULL;

        if (g->manager) {
                assert(g->manager->n_socket_graveyard > 0);
                g->manager->n_socket_graveyard--;

                if (g->manager->socket_graveyard_oldest == g)
                        g->manager->socket_graveyard_oldest = g->graveyard_prev;

                LIST_REMOVE(graveyard, g->manager->socket_graveyard, g);

                assert((g->manager->n_socket_graveyard > 0) == !!g->manager->socket_graveyard);
                assert((g->manager->n_socket_graveyard > 0) == !!g->manager->socket_graveyard_oldest);
        }

        if (g->io_event_source) {
                log_debug("Closing graveyard socket fd %i", sd_event_source_get_io_fd(g->io_event_source));
                sd_event_source_disable_unref(g->io_event_source);
        }

        return mfree(g);
}

DEFINE_TRIVIAL_CLEANUP_FUNC(SocketGraveyard*, socket_graveyard_free);

void manager_socket_graveyard_process(Manager *m) {
        usec_t n = USEC_INFINITY;

        assert(m);

        while (m->socket_graveyard_oldest) {
                SocketGraveyard *g = m->socket_graveyard_oldest;

                if (n == USEC_INFINITY)
                        assert_se(sd_event_now(m->event, CLOCK_BOOTTIME, &n) >= 0);

                if (g->deadline > n)
                        break;

                socket_graveyard_free(g);
        }
}

void manager_socket_graveyard_clear(Manager *m) {
        assert(m);

        while (m->socket_graveyard)
                socket_graveyard_free(m->socket_graveyard);
}

static int on_io_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
        SocketGraveyard *g = ASSERT_PTR(userdata);

        /* An IO event happened on the graveyard fd. We don't actually care which event that is, and we don't
         * read any incoming packet off the socket. We just close the fd, that's enough to not trigger the
         * ICMP unreachable port event */

        socket_graveyard_free(g);
        return 0;
}

static void manager_socket_graveyard_make_room(Manager *m) {
        assert(m);

        while (m->n_socket_graveyard >= SOCKET_GRAVEYARD_MAX)
                socket_graveyard_free(m->socket_graveyard_oldest);
}

int manager_add_socket_to_graveyard(Manager *m, int fd) {
        _cleanup_(socket_graveyard_freep) SocketGraveyard *g = NULL;
        int r;

        assert(m);
        assert(fd >= 0);

        manager_socket_graveyard_process(m);
        manager_socket_graveyard_make_room(m);

        g = new(SocketGraveyard, 1);
        if (!g)
                return log_oom();

        *g = (SocketGraveyard) {
                .manager = m,
        };

        LIST_PREPEND(graveyard, m->socket_graveyard, g);
        if (!m->socket_graveyard_oldest)
                m->socket_graveyard_oldest = g;

        m->n_socket_graveyard++;

        assert_se(sd_event_now(m->event, CLOCK_BOOTTIME, &g->deadline) >= 0);
        g->deadline += SOCKET_GRAVEYARD_USEC;

        r = sd_event_add_io(m->event, &g->io_event_source, fd, EPOLLIN, on_io_event, g);
        if (r < 0)
                return log_error_errno(r, "Failed to create graveyard IO source: %m");

        r = sd_event_source_set_io_fd_own(g->io_event_source, true);
        if (r < 0)
                return log_error_errno(r, "Failed to enable graveyard IO source fd ownership: %m");

        (void) sd_event_source_set_description(g->io_event_source, "graveyard");

        log_debug("Added socket %i to graveyard", fd);

        TAKE_PTR(g);
        return 0;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "resolved-manager.h"
4	#include "resolved-socket-graveyard.h"
5
6	#define SOCKET_GRAVEYARD_USEC (5 * USEC_PER_SEC)
7	#define SOCKET_GRAVEYARD_MAX 100
8
9	/* This implements a socket "graveyard" for UDP sockets. If a socket fd is added to the graveyard it is kept
10	* open for a couple of more seconds, expecting one reply. Once the reply is received the fd is closed
11	* immediately, or if none is received it is closed after the timeout. Why all this? So that if we contact a
12	* DNS server, and it doesn't reply instantly, and we lose interest in the response and thus close the fd, we
13	* don't end up sending back an ICMP error once the server responds but we aren't listening anymore. (See
14	* https://github.com/systemd/systemd/issues/17421 for further information.)
15	*
16	* Note that we don't allocate any timer event source to clear up the graveyard once the socket's timeout is
17	* reached. Instead we operate lazily: we close old entries when adding a new fd to the graveyard, or
18	* whenever any code runs manager_socket_graveyard_process() — which the DNS transaction code does right
19	* before allocating a new UDP socket. */
20
21	static SocketGraveyard* socket_graveyard_free(SocketGraveyard *g) {	186✔
22	if (!g)	186✔
23	return NULL;
24
25	if (g->manager) {	186✔
26	assert(g->manager->n_socket_graveyard > 0);	186✔
27	g->manager->n_socket_graveyard--;	186✔
28
29	if (g->manager->socket_graveyard_oldest == g)	186✔
30	g->manager->socket_graveyard_oldest = g->graveyard_prev;	175✔
31
32	LIST_REMOVE(graveyard, g->manager->socket_graveyard, g);	186✔
33
34	assert((g->manager->n_socket_graveyard > 0) == !!g->manager->socket_graveyard);	186✔
35	assert((g->manager->n_socket_graveyard > 0) == !!g->manager->socket_graveyard_oldest);	186✔
36	}
37
38	if (g->io_event_source) {	186✔
39	log_debug("Closing graveyard socket fd %i", sd_event_source_get_io_fd(g->io_event_source));	186✔
40	sd_event_source_disable_unref(g->io_event_source);	186✔
41	}
42
43	return mfree(g);	186✔
44	}
45
46	DEFINE_TRIVIAL_CLEANUP_FUNC(SocketGraveyard*, socket_graveyard_free);	187✔
47
48	void manager_socket_graveyard_process(Manager *m) {	12,661✔
49	usec_t n = USEC_INFINITY;	12,661✔
50
51	assert(m);	12,661✔
52
53	while (m->socket_graveyard_oldest) {	12,829✔
54	SocketGraveyard *g = m->socket_graveyard_oldest;	3,138✔
55
56	if (n == USEC_INFINITY)	3,138✔
57	assert_se(sd_event_now(m->event, CLOCK_BOOTTIME, &n) >= 0);	3,027✔
58
59	if (g->deadline > n)	3,138✔
60	break;
61
62	socket_graveyard_free(g);	168✔
63	}
64	}	12,661✔
65
66	void manager_socket_graveyard_clear(Manager *m) {	165✔
67	assert(m);	165✔
68
69	while (m->socket_graveyard)	183✔
70	socket_graveyard_free(m->socket_graveyard);	18✔
71	}	165✔
72
UNCOV 73	static int on_io_event(sd_event_source s, int fd, uint32_t revents, void userdata) {	×
UNCOV 74	SocketGraveyard *g = ASSERT_PTR(userdata);	×
75
76	/* An IO event happened on the graveyard fd. We don't actually care which event that is, and we don't
77	* read any incoming packet off the socket. We just close the fd, that's enough to not trigger the
78	* ICMP unreachable port event */
79
UNCOV 80	socket_graveyard_free(g);	×
UNCOV 81	return 0;	×
82	}
83
84	static void manager_socket_graveyard_make_room(Manager *m) {	187✔
85	assert(m);	187✔
86
87	while (m->n_socket_graveyard >= SOCKET_GRAVEYARD_MAX)	187✔
88	socket_graveyard_free(m->socket_graveyard_oldest);	×
89	}	187✔
90
91	int manager_add_socket_to_graveyard(Manager *m, int fd) {	187✔
92	_cleanup_(socket_graveyard_freep) SocketGraveyard *g = NULL;	187✔
93	int r;	187✔
94
95	assert(m);	187✔
96	assert(fd >= 0);	187✔
97
98	manager_socket_graveyard_process(m);	187✔
99	manager_socket_graveyard_make_room(m);	187✔
100
101	g = new(SocketGraveyard, 1);	187✔
102	if (!g)	187✔
103	return log_oom();	×
104
105	*g = (SocketGraveyard) {	187✔
106	.manager = m,
107	};
108
109	LIST_PREPEND(graveyard, m->socket_graveyard, g);	187✔
110	if (!m->socket_graveyard_oldest)	187✔
111	m->socket_graveyard_oldest = g;	65✔
112
113	m->n_socket_graveyard++;	187✔
114
115	assert_se(sd_event_now(m->event, CLOCK_BOOTTIME, &g->deadline) >= 0);	187✔
116	g->deadline += SOCKET_GRAVEYARD_USEC;	187✔
117
118	r = sd_event_add_io(m->event, &g->io_event_source, fd, EPOLLIN, on_io_event, g);	187✔
119	if (r < 0)	187✔
120	return log_error_errno(r, "Failed to create graveyard IO source: %m");	×
121
122	r = sd_event_source_set_io_fd_own(g->io_event_source, true);	187✔
123	if (r < 0)	187✔
124	return log_error_errno(r, "Failed to enable graveyard IO source fd ownership: %m");	×
125
126	(void) sd_event_source_set_description(g->io_event_source, "graveyard");	187✔
127
128	log_debug("Added socket %i to graveyard", fd);	187✔
129
130	TAKE_PTR(g);	187✔
131	return 0;	187✔
132	}

systemd / systemd / 14815796853

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous