13380515387

Committed 17 Feb 2025 09:20PM UTC coverage: 71.822% (+0.1%) from 71.714%

Build # 13380515387

Build Type

push

github

Committed by

DaanDeMeyer

Commit Message

ukify: print all remaining log-like output to stderr

We want to be able to capture stdout for json and such, so convert
all remaining logging to stderr.

Coverage Stats

293883 of 409184 relevant lines covered (71.82%)

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

systemd / systemd / 13380515387

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