15090360166

Committed 17 May 2025 08:33PM UTC coverage: 72.228% (-0.05%) from 72.276%

Build # 15090360166

Build Type

push

github

Committed by

yuwata

Commit Message

core/manager: do not pop gc_unit_queue before unit_gc_sweep()

Follow-up for 52e3671bf

unit_gc_sweep() might try to add the unit to gc queue again.
While that becomes no-op as Unit.in_gc_queue is not cleared
yet, it induces minor inconsistency of states.

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

316 existing lines in 39 files now uncovered.

298370 of 413093 relevant lines covered (72.23%)

702554.86 hits per line

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

87.5

/src/basic/pidref.c

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

#include "errno-util.h"
#include "fd-util.h"
#include "log.h"
#include "missing_syscall.h"
#include "missing_wait.h"
#include "parse-util.h"
#include "pidfd-util.h"
#include "pidref.h"
#include "process-util.h"
#include "signal-util.h"

int pidref_acquire_pidfd_id(PidRef *pidref) {
        int r;

        assert(pidref);

        if (!pidref_is_set(pidref))
                return -ESRCH;

        if (pidref_is_remote(pidref))
                return -EREMOTE;

        if (pidref->fd < 0)
                return -ENOMEDIUM;

        if (pidref->fd_id > 0)
                return 0;

        r = pidfd_get_inode_id(pidref->fd, &pidref->fd_id);
        if (r < 0) {
                if (!ERRNO_IS_NEG_NOT_SUPPORTED(r))
                        log_debug_errno(r, "Failed to get inode number of pidfd for pid " PID_FMT ": %m",
                                        pidref->pid);
                return r;
        }

        return 0;
}

bool pidref_equal(PidRef *a, PidRef *b) {

        /* If this is the very same structure, it definitely refers to the same process */
        if (a == b)
                return true;

        if (!pidref_is_set(a))
                return !pidref_is_set(b);

        if (!pidref_is_set(b))
                return false;

        if (a->pid != b->pid)
                return false;

        if (pidref_is_remote(a)) {
                /* If one is remote and the other isn't, they are not the same */
                if (!pidref_is_remote(b))
                        return false;

                /* If both are remote, compare fd IDs if we have both, otherwise don't bother, and cut things short */
                if (a->fd_id == 0 || b->fd_id == 0)
                        return true;
        } else {
                /* If the other side is remote, then this is not the same */
                if (pidref_is_remote(b))
                        return false;

                /* PID1 cannot exit, hence it cannot change pidfs ids, hence no point in comparing them, we
                 * can shortcut things */
                if (a->pid == 1)
                        return true;

                /* Try to compare pidfds using their inode numbers. This way we can ensure that we
                 * don't spuriously consider two PidRefs equal if the pid has been reused once. Note
                 * that we ignore all errors here, not only EOPNOTSUPP, as fstat() might fail due to
                 * many reasons. */
                if (pidref_acquire_pidfd_id(a) < 0 || pidref_acquire_pidfd_id(b) < 0)
                        return true;
        }

        return a->fd_id == b->fd_id;
}

int pidref_set_pid(PidRef *pidref, pid_t pid) {
        uint64_t pidfdid = 0;
        int fd;

        assert(pidref);

        if (pid < 0)
                return -ESRCH;
        if (pid == 0) {
                pid = getpid_cached();
                (void) pidfd_get_inode_id_self_cached(&pidfdid);
        }

        fd = pidfd_open(pid, 0);
        if (fd < 0) {
                /* Graceful fallback in case the kernel is out of fds */
                if (!ERRNO_IS_RESOURCE(errno))
                        return log_debug_errno(errno, "Failed to open pidfd for pid " PID_FMT ": %m", pid);

                fd = -EBADF;
        }

        *pidref = (PidRef) {
                .fd = fd,
                .pid = pid,
                .fd_id = pidfdid,
        };

        return 0;
}

int pidref_set_pidstr(PidRef *pidref, const char *pid) {
        pid_t nr;
        int r;

        assert(pidref);

        r = parse_pid(pid, &nr);
        if (r < 0)
                return r;

        return pidref_set_pid(pidref, nr);
}

int pidref_set_pidfd(PidRef *pidref, int fd) {
        int r;

        assert(pidref);

        if (fd < 0)
                return -EBADF;

        int fd_copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
        if (fd_copy < 0) {
                pid_t pid;

                if (!ERRNO_IS_RESOURCE(errno))
                        return -errno;

                /* Graceful fallback if we are out of fds */
                r = pidfd_get_pid(fd, &pid);
                if (r < 0)
                        return r;

                *pidref = PIDREF_MAKE_FROM_PID(pid);
                return 0;
        }

        return pidref_set_pidfd_consume(pidref, fd_copy);
}

int pidref_set_pidfd_take(PidRef *pidref, int fd) {
        pid_t pid;
        int r;

        assert(pidref);

        if (fd < 0)
                return -EBADF;

        r = pidfd_get_pid(fd, &pid);
        if (r < 0)
                return r;

        *pidref = (PidRef) {
                .fd = fd,
                .pid = pid,
        };

        return 0;
}

int pidref_set_pidfd_consume(PidRef *pidref, int fd) {
        int r;

        r = pidref_set_pidfd_take(pidref, fd);
        if (r < 0)
                safe_close(fd);

        return r;
}

int pidref_set_parent(PidRef *ret) {
        _cleanup_(pidref_done) PidRef parent = PIDREF_NULL;
        pid_t ppid;
        int r;

        assert(ret);

        /* Acquires a pidref to our parent process. Deals with the fact that parent processes might exit, and
         * we get reparented to other processes, with our old parent's PID already being recycled. */

        ppid = getppid();
        for (;;) {
                r = pidref_set_pid(&parent, ppid);
                if (r < 0)
                        return r;

                if (parent.fd < 0) /* If pidfds are not available, then we are done */
                        break;

                pid_t now_ppid = getppid();
                if (now_ppid == ppid) /* If our ppid is still the same, then we are done */
                        break;

                /* Otherwise let's try again with the new ppid */
                ppid = now_ppid;
                pidref_done(&parent);
        }

        *ret = TAKE_PIDREF(parent);
        return 0;
}

void pidref_done(PidRef *pidref) {
        assert(pidref);

        *pidref = (PidRef) {
                .fd = safe_close(pidref->fd),
        };
}

PidRef* pidref_free(PidRef *pidref) {
        /* Regularly, this is an embedded structure. But sometimes we want it on the heap too */
        if (!pidref)
                return NULL;

        pidref_done(pidref);
        return mfree(pidref);
}

int pidref_copy(const PidRef *pidref, PidRef *ret) {
        _cleanup_(pidref_done) PidRef copy = PIDREF_NULL;

        /* If NULL is passed we'll generate a PidRef that refers to no process. This makes it easy to
         * copy pidref fields that might or might not reference a process yet. */

        assert(ret);

        if (pidref) {
                if (pidref_is_remote(pidref)) /* Propagate remote flag */
                        copy.fd = -EREMOTE;
                else if (pidref->fd >= 0) {
                        copy.fd = fcntl(pidref->fd, F_DUPFD_CLOEXEC, 3);
                        if (copy.fd < 0) {
                                if (!ERRNO_IS_RESOURCE(errno))
                                        return -errno;

                                copy.fd = -EBADF;
                        }
                }

                copy.pid = pidref->pid;
                copy.fd_id = pidref->fd_id;
        }

        *ret = TAKE_PIDREF(copy);
        return 0;
}

int pidref_dup(const PidRef *pidref, PidRef **ret) {
        _cleanup_(pidref_freep) PidRef *dup_pidref = NULL;
        int r;

        /* Allocates a new PidRef on the heap, making it a copy of the specified pidref. This does not try to
         * acquire a pidfd if we don't have one yet! */

        assert(ret);

        dup_pidref = newdup(PidRef, &PIDREF_NULL, 1);
        if (!dup_pidref)
                return -ENOMEM;

        r = pidref_copy(pidref, dup_pidref);
        if (r < 0)
                return r;

        *ret = TAKE_PTR(dup_pidref);
        return 0;
}

int pidref_new_from_pid(pid_t pid, PidRef **ret) {
        _cleanup_(pidref_freep) PidRef *n = NULL;
        int r;

        assert(ret);

        if (pid < 0)
                return -ESRCH;

        n = new(PidRef, 1);
        if (!n)
                return -ENOMEM;

        *n = PIDREF_NULL;

        r = pidref_set_pid(n, pid);
        if (r < 0)
                return r;

        *ret = TAKE_PTR(n);
        return 0;
}

int pidref_kill(const PidRef *pidref, int sig) {

        if (!pidref)
                return -ESRCH;

        if (pidref_is_remote(pidref))
                return -EREMOTE;

        if (pidref->fd >= 0)
                return RET_NERRNO(pidfd_send_signal(pidref->fd, sig, NULL, 0));

        if (pidref->pid > 0)
                return RET_NERRNO(kill(pidref->pid, sig));

        return -ESRCH;
}

int pidref_kill_and_sigcont(const PidRef *pidref, int sig) {
        int r;

        r = pidref_kill(pidref, sig);
        if (r < 0)
                return r;

        if (!IN_SET(sig, SIGCONT, SIGKILL))
                (void) pidref_kill(pidref, SIGCONT);

        return 0;
}

int pidref_sigqueue(const PidRef *pidref, int sig, int value) {

        if (!pidref)
                return -ESRCH;

        if (pidref_is_remote(pidref))
                return -EREMOTE;

        if (pidref->fd >= 0) {
                siginfo_t si;

                /* We can't use structured initialization here, since the structure contains various unions
                 * and these fields lie in overlapping (carefully aligned) unions that LLVM is allergic to
                 * allow assignments to */
                zero(si);
                si.si_signo = sig;
                si.si_code = SI_QUEUE;
                si.si_pid = getpid_cached();
                si.si_uid = getuid();
                si.si_value.sival_int = value;

                return RET_NERRNO(pidfd_send_signal(pidref->fd, sig, &si, 0));
        }

        if (pidref->pid > 0)
                return RET_NERRNO(sigqueue(pidref->pid, sig, (const union sigval) { .sival_int = value }));

        return -ESRCH;
}

int pidref_verify(const PidRef *pidref) {
        int r;

        /* This is a helper that is supposed to be called after reading information from procfs via a
         * PidRef. It ensures that the PID we track still matches the PIDFD we pin. If this value differs
         * after a procfs read, we might have read the data from a recycled PID. */

        if (!pidref_is_set(pidref))
                return -ESRCH;

        if (pidref_is_remote(pidref))
                return -EREMOTE;

        if (pidref->pid == 1)
                return 1; /* PID 1 can never go away, hence never be recycled to a different process → return 1 */

        if (pidref->fd < 0)
                return 0; /* If we don't have a pidfd we cannot validate it, hence we assume it's all OK → return 0 */

        r = pidfd_verify_pid(pidref->fd, pidref->pid);
        if (r < 0)
                return r;

        return 1; /* We have a pidfd and it still points to the PID we have, hence all is *really* OK → return 1 */
}

bool pidref_is_self(PidRef *pidref) {
        if (!pidref_is_set(pidref))
                return false;

        if (pidref_is_remote(pidref))
                return false;

        if (pidref->pid != getpid_cached())
                return false;

        /* PID1 cannot exit, hence no point in comparing pidfd IDs, they can never change */
        if (pidref->pid == 1)
                return true;

        /* Also compare pidfd ID if we can get it */
        if (pidref_acquire_pidfd_id(pidref) < 0)
                return true;

        uint64_t self_id;
        if (pidfd_get_inode_id_self_cached(&self_id) < 0)
                return true;

        return pidref->fd_id == self_id;
}

int pidref_wait(PidRef *pidref, siginfo_t *ret, int options) {
        int r;

        if (!pidref_is_set(pidref))
                return -ESRCH;

        if (pidref_is_remote(pidref))
                return -EREMOTE;

        if (pidref->pid == 1 || pidref_is_self(pidref))
                return -ECHILD;

        siginfo_t si = {};
        if (pidref->fd >= 0)
                r = RET_NERRNO(waitid(P_PIDFD, pidref->fd, &si, options));
        else
                r = RET_NERRNO(waitid(P_PID, pidref->pid, &si, options));
        if (r < 0)
                return r;

        if (ret)
                *ret = si;

        return 0;
}

int pidref_wait_for_terminate(PidRef *pidref, siginfo_t *ret) {
        int r;

        for (;;) {
                r = pidref_wait(pidref, ret, WEXITED);
                if (r != -EINTR)
                        return r;
        }
}

bool pidref_is_automatic(const PidRef *pidref) {
        return pidref && pid_is_automatic(pidref->pid);
}

void pidref_hash_func(const PidRef *pidref, struct siphash *state) {
        siphash24_compress_typesafe(pidref->pid, state);
}

int pidref_compare_func(const PidRef *a, const PidRef *b) {
        int r;

        assert(a);
        assert(b);

        r = CMP(pidref_is_set(a), pidref_is_set(b));
        if (r != 0)
                return r;

        r = CMP(pidref_is_automatic(a), pidref_is_automatic(b));
        if (r != 0)
                return r;

        r = CMP(pidref_is_remote(a), pidref_is_remote(b));
        if (r != 0)
                return r;

        r = CMP(a->pid, b->pid);
        if (r != 0)
                return r;

        if (a->fd_id != 0 && b->fd_id != 0)
                return CMP(a->fd_id, b->fd_id);

        return 0;
}

DEFINE_HASH_OPS(pidref_hash_ops, PidRef, pidref_hash_func, pidref_compare_func);

DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(pidref_hash_ops_free,
                                    PidRef, pidref_hash_func, pidref_compare_func,
                                    pidref_free);

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "errno-util.h"
4	#include "fd-util.h"
5	#include "log.h"
6	#include "missing_syscall.h"
7	#include "missing_wait.h"
8	#include "parse-util.h"
9	#include "pidfd-util.h"
10	#include "pidref.h"
11	#include "process-util.h"
12	#include "signal-util.h"
13
14	int pidref_acquire_pidfd_id(PidRef *pidref) {	9,288✔
15	int r;	9,288✔
16
17	assert(pidref);	9,288✔
18
19	if (!pidref_is_set(pidref))	9,288✔
20	return -ESRCH;
21
22	if (pidref_is_remote(pidref))	9,288✔
23	return -EREMOTE;
24
25	if (pidref->fd < 0)	9,288✔
26	return -ENOMEDIUM;
27
28	if (pidref->fd_id > 0)	9,281✔
29	return 0;
30
31	r = pidfd_get_inode_id(pidref->fd, &pidref->fd_id);	5,176✔
32	if (r < 0) {	5,176✔
33	if (!ERRNO_IS_NEG_NOT_SUPPORTED(r))	×
34	log_debug_errno(r, "Failed to get inode number of pidfd for pid " PID_FMT ": %m",	×
35	pidref->pid);
36	return r;	×
37	}
38
39	return 0;
40	}
41
42	bool pidref_equal(PidRef a, PidRef b) {	20,346✔
43
44	/* If this is the very same structure, it definitely refers to the same process */
45	if (a == b)	20,346✔
46	return true;
47
48	if (!pidref_is_set(a))	20,343✔
49	return !pidref_is_set(b);	5,994✔
50
51	if (!pidref_is_set(b))	17,346✔
52	return false;
53
54	if (a->pid != b->pid)	17,340✔
55	return false;
56
57	if (pidref_is_remote(a)) {	3,698✔
58	/* If one is remote and the other isn't, they are not the same */
59	if (!pidref_is_remote(b))	×
60	return false;
61
62	/* If both are remote, compare fd IDs if we have both, otherwise don't bother, and cut things short */
63	if (a->fd_id == 0 \|\| b->fd_id == 0)	×
64	return true;
65	} else {
66	/* If the other side is remote, then this is not the same */
67	if (pidref_is_remote(b))	3,698✔
68	return false;
69
70	/* PID1 cannot exit, hence it cannot change pidfs ids, hence no point in comparing them, we
71	* can shortcut things */
72	if (a->pid == 1)	3,697✔
73	return true;
74
75	/* Try to compare pidfds using their inode numbers. This way we can ensure that we
76	* don't spuriously consider two PidRefs equal if the pid has been reused once. Note
77	* that we ignore all errors here, not only EOPNOTSUPP, as fstat() might fail due to
78	* many reasons. */
79	if (pidref_acquire_pidfd_id(a) < 0 \|\| pidref_acquire_pidfd_id(b) < 0)	3,579✔
80	return true;	2✔
81	}
82
83	return a->fd_id == b->fd_id;	3,577✔
84	}
85
86	int pidref_set_pid(PidRef *pidref, pid_t pid) {	60,929✔
87	uint64_t pidfdid = 0;	60,929✔
88	int fd;	60,929✔
89
90	assert(pidref);	60,929✔
91
92	if (pid < 0)	60,929✔
93	return -ESRCH;	60,929✔
94	if (pid == 0) {	60,929✔
95	pid = getpid_cached();	37,759✔
96	(void) pidfd_get_inode_id_self_cached(&pidfdid);	37,759✔
97	}
98
99	fd = pidfd_open(pid, 0);	60,929✔
100	if (fd < 0) {	60,929✔
101	/* Graceful fallback in case the kernel is out of fds */
UNCOV 102	if (!ERRNO_IS_RESOURCE(errno))	×
UNCOV 103	return log_debug_errno(errno, "Failed to open pidfd for pid " PID_FMT ": %m", pid);	×
104
105	fd = -EBADF;
106	}
107
108	*pidref = (PidRef) {	60,929✔
109	.fd = fd,
110	.pid = pid,
111	.fd_id = pidfdid,
112	};
113
114	return 0;	60,929✔
115	}
116
117	int pidref_set_pidstr(PidRef pidref, const char pid) {	4✔
118	pid_t nr;	4✔
119	int r;	4✔
120
121	assert(pidref);	4✔
122
123	r = parse_pid(pid, &nr);	4✔
124	if (r < 0)	4✔
125	return r;	4✔
126
127	return pidref_set_pid(pidref, nr);	4✔
128	}
129
130	int pidref_set_pidfd(PidRef *pidref, int fd) {	592✔
131	int r;	592✔
132
133	assert(pidref);	592✔
134
135	if (fd < 0)	592✔
136	return -EBADF;
137
138	int fd_copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);	592✔
139	if (fd_copy < 0) {	592✔
140	pid_t pid;	×
141
142	if (!ERRNO_IS_RESOURCE(errno))	×
143	return -errno;	×
144
145	/* Graceful fallback if we are out of fds */
146	r = pidfd_get_pid(fd, &pid);	×
147	if (r < 0)	×
148	return r;
149
150	*pidref = PIDREF_MAKE_FROM_PID(pid);	×
151	return 0;	×
152	}
153
154	return pidref_set_pidfd_consume(pidref, fd_copy);	592✔
155	}
156
157	int pidref_set_pidfd_take(PidRef *pidref, int fd) {	2,860✔
158	pid_t pid;	2,860✔
159	int r;	2,860✔
160
161	assert(pidref);	2,860✔
162
163	if (fd < 0)	2,860✔
164	return -EBADF;	2,860✔
165
166	r = pidfd_get_pid(fd, &pid);	2,860✔
167	if (r < 0)	2,860✔
168	return r;
169
170	*pidref = (PidRef) {	2,860✔
171	.fd = fd,
172	.pid = pid,
173	};
174
175	return 0;	2,860✔
176	}
177
178	int pidref_set_pidfd_consume(PidRef *pidref, int fd) {	2,831✔
179	int r;	2,831✔
180
181	r = pidref_set_pidfd_take(pidref, fd);	2,831✔
182	if (r < 0)	2,831✔
183	safe_close(fd);	×
184
185	return r;	2,831✔
186	}
187
188	int pidref_set_parent(PidRef *ret) {	1,099✔
189	_cleanup_(pidref_done) PidRef parent = PIDREF_NULL;	1,099✔
190	pid_t ppid;	1,099✔
191	int r;	1,099✔
192
193	assert(ret);	1,099✔
194
195	/* Acquires a pidref to our parent process. Deals with the fact that parent processes might exit, and
196	* we get reparented to other processes, with our old parent's PID already being recycled. */
197
198	ppid = getppid();	1,099✔
199	for (;;) {	1,099✔
200	r = pidref_set_pid(&parent, ppid);	1,099✔
201	if (r < 0)	1,099✔
202	return r;
203
204	if (parent.fd < 0) /* If pidfds are not available, then we are done */	1,099✔
205	break;
206
207	pid_t now_ppid = getppid();	1,099✔
208	if (now_ppid == ppid) /* If our ppid is still the same, then we are done */	1,099✔
209	break;
210
211	/* Otherwise let's try again with the new ppid */
212	ppid = now_ppid;	×
213	pidref_done(&parent);	×
214	}
215
216	*ret = TAKE_PIDREF(parent);	1,099✔
217	return 0;	1,099✔
218	}
219
220	void pidref_done(PidRef *pidref) {	215,351✔
221	assert(pidref);	215,351✔
222
223	*pidref = (PidRef) {	430,702✔
224	.fd = safe_close(pidref->fd),	215,351✔
225	};
226	}	215,351✔
227
228	PidRef* pidref_free(PidRef *pidref) {	2,898✔
229	/* Regularly, this is an embedded structure. But sometimes we want it on the heap too */
230	if (!pidref)	2,898✔
231	return NULL;
232
233	pidref_done(pidref);	2,898✔
234	return mfree(pidref);	2,898✔
235	}
236
237	int pidref_copy(const PidRef pidref, PidRef ret) {	2,899✔
238	_cleanup_(pidref_done) PidRef copy = PIDREF_NULL;	2,899✔
239
240	/* If NULL is passed we'll generate a PidRef that refers to no process. This makes it easy to
241	* copy pidref fields that might or might not reference a process yet. */
242
243	assert(ret);	2,899✔
244
245	if (pidref) {	2,899✔
246	if (pidref_is_remote(pidref)) /* Propagate remote flag */	2,897✔
247	copy.fd = -EREMOTE;	×
248	else if (pidref->fd >= 0) {	2,897✔
249	copy.fd = fcntl(pidref->fd, F_DUPFD_CLOEXEC, 3);	2,891✔
250	if (copy.fd < 0) {	2,891✔
251	if (!ERRNO_IS_RESOURCE(errno))	×
252	return -errno;	×
253
254	copy.fd = -EBADF;	×
255	}
256	}
257
258	copy.pid = pidref->pid;	2,897✔
259	copy.fd_id = pidref->fd_id;	2,897✔
260	}
261
262	*ret = TAKE_PIDREF(copy);	2,899✔
263	return 0;	2,899✔
264	}
265
266	int pidref_dup(const PidRef pidref, PidRef *ret) {	2,895✔
267	_cleanup_(pidref_freep) PidRef *dup_pidref = NULL;	2,895✔
268	int r;	2,895✔
269
270	/* Allocates a new PidRef on the heap, making it a copy of the specified pidref. This does not try to
271	* acquire a pidfd if we don't have one yet! */
272
273	assert(ret);	2,895✔
274
275	dup_pidref = newdup(PidRef, &PIDREF_NULL, 1);	2,895✔
276	if (!dup_pidref)	2,895✔
277	return -ENOMEM;
278
279	r = pidref_copy(pidref, dup_pidref);	2,895✔
280	if (r < 0)	2,895✔
281	return r;
282
283	*ret = TAKE_PTR(dup_pidref);	2,895✔
284	return 0;	2,895✔
285	}
286
287	int pidref_new_from_pid(pid_t pid, PidRef **ret) {	4✔
288	_cleanup_(pidref_freep) PidRef *n = NULL;	4✔
289	int r;	4✔
290
291	assert(ret);	4✔
292
293	if (pid < 0)	4✔
294	return -ESRCH;
295
296	n = new(PidRef, 1);	3✔
297	if (!n)	3✔
298	return -ENOMEM;
299
300	*n = PIDREF_NULL;	3✔
301
302	r = pidref_set_pid(n, pid);	3✔
303	if (r < 0)	3✔
304	return r;
305
306	*ret = TAKE_PTR(n);	3✔
307	return 0;	3✔
308	}
309
310	int pidref_kill(const PidRef *pidref, int sig) {	16,076✔
311
312	if (!pidref)	16,076✔
313	return -ESRCH;
314
315	if (pidref_is_remote(pidref))	16,076✔
316	return -EREMOTE;
317
318	if (pidref->fd >= 0)	16,074✔
319	return RET_NERRNO(pidfd_send_signal(pidref->fd, sig, NULL, 0));	8,065✔
320
321	if (pidref->pid > 0)	8,009✔
322	return RET_NERRNO(kill(pidref->pid, sig));	14,949✔
323
324	return -ESRCH;
325	}
326
327	int pidref_kill_and_sigcont(const PidRef *pidref, int sig) {	587✔
328	int r;	587✔
329
330	r = pidref_kill(pidref, sig);	587✔
331	if (r < 0)	587✔
332	return r;
333
334	if (!IN_SET(sig, SIGCONT, SIGKILL))	586✔
335	(void) pidref_kill(pidref, SIGCONT);	586✔
336
337	return 0;
338	}
339
340	int pidref_sigqueue(const PidRef *pidref, int sig, int value) {	9,716✔
341
342	if (!pidref)	9,716✔
343	return -ESRCH;
344
345	if (pidref_is_remote(pidref))	9,716✔
346	return -EREMOTE;
347
348	if (pidref->fd >= 0) {	9,716✔
349	siginfo_t si;	9,716✔
350
351	/* We can't use structured initialization here, since the structure contains various unions
352	* and these fields lie in overlapping (carefully aligned) unions that LLVM is allergic to
353	* allow assignments to */
354	zero(si);	9,716✔
355	si.si_signo = sig;	9,716✔
356	si.si_code = SI_QUEUE;	9,716✔
357	si.si_pid = getpid_cached();	9,716✔
358	si.si_uid = getuid();	9,716✔
359	si.si_value.sival_int = value;	9,716✔
360
361	return RET_NERRNO(pidfd_send_signal(pidref->fd, sig, &si, 0));	9,716✔
362	}
363
364	if (pidref->pid > 0)	×
365	return RET_NERRNO(sigqueue(pidref->pid, sig, (const union sigval) { .sival_int = value }));	×
366
367	return -ESRCH;
368	}
369
370	int pidref_verify(const PidRef *pidref) {	64,540✔
371	int r;	64,540✔
372
373	/* This is a helper that is supposed to be called after reading information from procfs via a
374	* PidRef. It ensures that the PID we track still matches the PIDFD we pin. If this value differs
375	* after a procfs read, we might have read the data from a recycled PID. */
376
377	if (!pidref_is_set(pidref))	64,540✔
378	return -ESRCH;
379
380	if (pidref_is_remote(pidref))	64,538✔
381	return -EREMOTE;
382
383	if (pidref->pid == 1)	64,537✔
384	return 1; /* PID 1 can never go away, hence never be recycled to a different process → return 1 */
385
386	if (pidref->fd < 0)	50,114✔
387	return 0; /* If we don't have a pidfd we cannot validate it, hence we assume it's all OK → return 0 */
388
389	r = pidfd_verify_pid(pidref->fd, pidref->pid);	32,697✔
390	if (r < 0)	32,697✔
391	return r;	2,018✔
392
393	return 1; /* We have a pidfd and it still points to the PID we have, hence all is really OK → return 1 */
394	}
395
396	bool pidref_is_self(PidRef *pidref) {	38,232✔
397	if (!pidref_is_set(pidref))	38,232✔
398	return false;	38,232✔
399
400	if (pidref_is_remote(pidref))	38,230✔
401	return false;
402
403	if (pidref->pid != getpid_cached())	38,230✔
404	return false;
405
406	/* PID1 cannot exit, hence no point in comparing pidfd IDs, they can never change */
407	if (pidref->pid == 1)	652✔
408	return true;
409
410	/* Also compare pidfd ID if we can get it */
411	if (pidref_acquire_pidfd_id(pidref) < 0)	652✔
412	return true;
413
414	uint64_t self_id;	647✔
415	if (pidfd_get_inode_id_self_cached(&self_id) < 0)	647✔
416	return true;
417
418	return pidref->fd_id == self_id;	647✔
419	}
420
421	int pidref_wait(PidRef pidref, siginfo_t ret, int options) {	13,703✔
422	int r;	13,703✔
423
424	if (!pidref_is_set(pidref))	13,703✔
425	return -ESRCH;	13,703✔
426
427	if (pidref_is_remote(pidref))	13,703✔
428	return -EREMOTE;
429
430	if (pidref->pid == 1 \|\| pidref_is_self(pidref))	13,702✔
431	return -ECHILD;	×
432
433	siginfo_t si = {};	13,702✔
434	if (pidref->fd >= 0)	13,702✔
435	r = RET_NERRNO(waitid(P_PIDFD, pidref->fd, &si, options));	4,987✔
436	else
437	r = RET_NERRNO(waitid(P_PID, pidref->pid, &si, options));	8,715✔
438	if (r < 0)	×
439	return r;
440
441	if (ret)	13,702✔
442	*ret = si;	9,730✔
443
444	return 0;
445	}
446
447	int pidref_wait_for_terminate(PidRef pidref, siginfo_t ret) {	13,703✔
448	int r;	13,703✔
449
450	for (;;) {	13,703✔
451	r = pidref_wait(pidref, ret, WEXITED);	13,703✔
452	if (r != -EINTR)	13,703✔
453	return r;	13,703✔
454	}
455	}
456
457	bool pidref_is_automatic(const PidRef *pidref) {	178,460✔
458	return pidref && pid_is_automatic(pidref->pid);	178,460✔
459	}
460
461	void pidref_hash_func(const PidRef pidref, struct siphash state) {	83,906✔
462	siphash24_compress_typesafe(pidref->pid, state);	83,906✔
463	}	83,906✔
464
465	int pidref_compare_func(const PidRef a, const PidRef b) {	89,204✔
466	int r;	89,204✔
467
468	assert(a);	89,204✔
469	assert(b);	89,204✔
470
471	r = CMP(pidref_is_set(a), pidref_is_set(b));	267,612✔
472	if (r != 0)	89,204✔
473	return r;	×
474
475	r = CMP(pidref_is_automatic(a), pidref_is_automatic(b));	89,204✔
476	if (r != 0)	89,204✔
477	return r;	×
478
479	r = CMP(pidref_is_remote(a), pidref_is_remote(b));	178,408✔
480	if (r != 0)	89,204✔
481	return r;	×
482
483	r = CMP(a->pid, b->pid);	89,204✔
484	if (r != 0)	69,624✔
485	return r;	21,926✔
486
487	if (a->fd_id != 0 && b->fd_id != 0)	67,278✔
488	return CMP(a->fd_id, b->fd_id);	468✔
489
490	return 0;
491	}
492
493	DEFINE_HASH_OPS(pidref_hash_ops, PidRef, pidref_hash_func, pidref_compare_func);
494
495	DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(pidref_hash_ops_free,	×
496	PidRef, pidref_hash_func, pidref_compare_func,
497	pidref_free);

systemd / systemd / 15090360166

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