[thirdparty/systemd.git] / src / test / test-process-util.c

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering
  Copyright 2013 Thomas H.P. Andersen

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <sched.h>
#include <sys/mount.h>
#include <sys/personality.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#ifdef HAVE_VALGRIND_VALGRIND_H
#include <valgrind/valgrind.h>
#endif

#include "alloc-util.h"
#include "architecture.h"
#include "fd-util.h"
#include "log.h"
#include "macro.h"
#include "parse-util.h"
#include "process-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "terminal-util.h"
#include "test-helper.h"
#include "util.h"
#include "virt.h"

static void test_get_process_comm(pid_t pid) {
        struct stat st;
        _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
        _cleanup_free_ char *env = NULL;
        char path[strlen("/proc//comm") + DECIMAL_STR_MAX(pid_t)];
        pid_t e;
        uid_t u;
        gid_t g;
        dev_t h;
        int r;

        xsprintf(path, "/proc/"PID_FMT"/comm", pid);

        if (stat(path, &st) == 0) {
                assert_se(get_process_comm(pid, &a) >= 0);
                log_info("PID"PID_FMT" comm: '%s'", pid, a);
        } else
                log_warning("%s not exist.", path);

        assert_se(get_process_cmdline(pid, 0, true, &c) >= 0);
        log_info("PID"PID_FMT" cmdline: '%s'", pid, c);

        assert_se(get_process_cmdline(pid, 8, false, &d) >= 0);
        log_info("PID"PID_FMT" cmdline truncated to 8: '%s'", pid, d);

        free(d);
        assert_se(get_process_cmdline(pid, 1, false, &d) >= 0);
        log_info("PID"PID_FMT" cmdline truncated to 1: '%s'", pid, d);

        assert_se(get_process_ppid(pid, &e) >= 0);
        log_info("PID"PID_FMT" PPID: "PID_FMT, pid, e);
        assert_se(pid == 1 ? e == 0 : e > 0);

        assert_se(is_kernel_thread(pid) == 0 || pid != 1);

        r = get_process_exe(pid, &f);
        assert_se(r >= 0 || r == -EACCES);
        log_info("PID"PID_FMT" exe: '%s'", pid, strna(f));

        assert_se(get_process_uid(pid, &u) == 0);
        log_info("PID"PID_FMT" UID: "UID_FMT, pid, u);
        assert_se(u == 0 || pid != 1);

        assert_se(get_process_gid(pid, &g) == 0);
        log_info("PID"PID_FMT" GID: "GID_FMT, pid, g);
        assert_se(g == 0 || pid != 1);

        r = get_process_environ(pid, &env);
        assert_se(r >= 0 || r == -EACCES);
        log_info("PID"PID_FMT" strlen(environ): %zi", pid, env ? (ssize_t)strlen(env) : (ssize_t)-errno);

        if (!detect_container())
                assert_se(get_ctty_devnr(pid, &h) == -ENXIO || pid != 1);

        getenv_for_pid(pid, "PATH", &i);
        log_info("PID"PID_FMT" $PATH: '%s'", pid, strna(i));
}

static void test_pid_is_unwaited(void) {
        pid_t pid;

        pid = fork();
        assert_se(pid >= 0);
        if (pid == 0) {
                _exit(EXIT_SUCCESS);
        } else {
                int status;

                waitpid(pid, &status, 0);
                assert_se(!pid_is_unwaited(pid));
        }
        assert_se(pid_is_unwaited(getpid()));
        assert_se(!pid_is_unwaited(-1));
}

static void test_pid_is_alive(void) {
        pid_t pid;

        pid = fork();
        assert_se(pid >= 0);
        if (pid == 0) {
                _exit(EXIT_SUCCESS);
        } else {
                int status;

                waitpid(pid, &status, 0);
                assert_se(!pid_is_alive(pid));
        }
        assert_se(pid_is_alive(getpid()));
        assert_se(!pid_is_alive(-1));
}

static void test_personality(void) {

        assert_se(personality_to_string(PER_LINUX));
        assert_se(!personality_to_string(PERSONALITY_INVALID));

        assert_se(streq(personality_to_string(PER_LINUX), architecture_to_string(native_architecture())));

        assert_se(personality_from_string(personality_to_string(PER_LINUX)) == PER_LINUX);
        assert_se(personality_from_string(architecture_to_string(native_architecture())) == PER_LINUX);

#ifdef __x86_64__
        assert_se(streq_ptr(personality_to_string(PER_LINUX), "x86-64"));
        assert_se(streq_ptr(personality_to_string(PER_LINUX32), "x86"));

        assert_se(personality_from_string("x86-64") == PER_LINUX);
        assert_se(personality_from_string("x86") == PER_LINUX32);
        assert_se(personality_from_string("ia64") == PERSONALITY_INVALID);
        assert_se(personality_from_string(NULL) == PERSONALITY_INVALID);

        assert_se(personality_from_string(personality_to_string(PER_LINUX32)) == PER_LINUX32);
#endif
}

static void test_get_process_cmdline_harder(void) {
        char path[] = "/tmp/test-cmdlineXXXXXX";
        _cleanup_close_ int fd = -1;
        _cleanup_free_ char *line = NULL;
        pid_t pid;

        if (geteuid() != 0)
                return;

#ifdef HAVE_VALGRIND_VALGRIND_H
        /* valgrind patches open(/proc//cmdline)
         * so, test_get_process_cmdline_harder fails always
         * See https://github.com/systemd/systemd/pull/3555#issuecomment-226564908 */
        if (RUNNING_ON_VALGRIND)
                return;
#endif

        pid = fork();
        if (pid > 0) {
                siginfo_t si;

                (void) wait_for_terminate(pid, &si);

                assert_se(si.si_code == CLD_EXITED);
                assert_se(si.si_status == 0);

                return;
        }

        assert_se(pid == 0);
        assert_se(unshare(CLONE_NEWNS) >= 0);

        fd = mkostemp(path, O_CLOEXEC);
        assert_se(fd >= 0);

        if (mount(path, "/proc/self/cmdline", "bind", MS_BIND, NULL) < 0) {
                /* This happens under selinux… Abort the test in this case. */
                log_warning_errno(errno, "mount(..., \"/proc/self/cmdline\", \"bind\", ...) failed: %m");
                assert(errno == EACCES);
                return;
        }

        assert_se(unlink(path) >= 0);

        assert_se(prctl(PR_SET_NAME, "testa") >= 0);

        assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);

        assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
        assert_se(streq(line, "[testa]"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 1, true, &line) >= 0);
        assert_se(streq(line, ""));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 2, true, &line) >= 0);
        assert_se(streq(line, "["));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 3, true, &line) >= 0);
        assert_se(streq(line, "[."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 4, true, &line) >= 0);
        assert_se(streq(line, "[.."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 5, true, &line) >= 0);
        assert_se(streq(line, "[..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 6, true, &line) >= 0);
        assert_se(streq(line, "[...]"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 7, true, &line) >= 0);
        assert_se(streq(line, "[t...]"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 8, true, &line) >= 0);
        assert_se(streq(line, "[testa]"));
        line = mfree(line);

        assert_se(write(fd, "\0\0\0\0\0\0\0\0\0", 10) == 10);

        assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);

        assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
        assert_se(streq(line, "[testa]"));
        line = mfree(line);

        assert_se(write(fd, "foo\0bar\0\0\0\0\0", 10) == 10);

        assert_se(get_process_cmdline(getpid(), 0, false, &line) >= 0);
        assert_se(streq(line, "foo bar"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
        assert_se(streq(line, "foo bar"));
        line = mfree(line);

        assert_se(write(fd, "quux", 4) == 4);
        assert_se(get_process_cmdline(getpid(), 0, false, &line) >= 0);
        assert_se(streq(line, "foo bar quux"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
        assert_se(streq(line, "foo bar quux"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 1, true, &line) >= 0);
        assert_se(streq(line, ""));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 2, true, &line) >= 0);
        assert_se(streq(line, "."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 3, true, &line) >= 0);
        assert_se(streq(line, ".."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 4, true, &line) >= 0);
        assert_se(streq(line, "..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 5, true, &line) >= 0);
        assert_se(streq(line, "f..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 6, true, &line) >= 0);
        assert_se(streq(line, "fo..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 7, true, &line) >= 0);
        assert_se(streq(line, "foo..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 8, true, &line) >= 0);
        assert_se(streq(line, "foo..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 9, true, &line) >= 0);
        assert_se(streq(line, "foo b..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 10, true, &line) >= 0);
        assert_se(streq(line, "foo ba..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 11, true, &line) >= 0);
        assert_se(streq(line, "foo bar..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 12, true, &line) >= 0);
        assert_se(streq(line, "foo bar..."));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 13, true, &line) >= 0);
        assert_se(streq(line, "foo bar quux"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 14, true, &line) >= 0);
        assert_se(streq(line, "foo bar quux"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 1000, true, &line) >= 0);
        assert_se(streq(line, "foo bar quux"));
        line = mfree(line);

        assert_se(ftruncate(fd, 0) >= 0);
        assert_se(prctl(PR_SET_NAME, "aaaa bbbb cccc") >= 0);

        assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);

        assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
        assert_se(streq(line, "[aaaa bbbb cccc]"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 10, true, &line) >= 0);
        assert_se(streq(line, "[aaaa...]"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 11, true, &line) >= 0);
        assert_se(streq(line, "[aaaa...]"));
        line = mfree(line);

        assert_se(get_process_cmdline(getpid(), 12, true, &line) >= 0);
        assert_se(streq(line, "[aaaa b...]"));
        line = mfree(line);

        safe_close(fd);
        _exit(0);
}

int main(int argc, char *argv[]) {
        log_parse_environment();
        log_open();

        if (argc > 1) {
                pid_t pid = 0;

                (void) parse_pid(argv[1], &pid);
                test_get_process_comm(pid);
        } else {
                TEST_REQ_RUNNING_SYSTEMD(test_get_process_comm(1));
                test_get_process_comm(getpid());
        }

        test_pid_is_unwaited();
        test_pid_is_alive();
        test_personality();
        test_get_process_cmdline_harder();

        return 0;
}
Commit	Line	Data
0b452006 RC	1	/***
	2	This file is part of systemd.
	3
	4	Copyright 2010 Lennart Poettering
	5	Copyright 2013 Thomas H.P. Andersen
	6
	7	systemd is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU Lesser General Public License as published by
	9	the Free Software Foundation; either version 2.1 of the License, or
	10	(at your option) any later version.
	11
	12	systemd is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public License
	18	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	19	***/
	20
69281c49 LP	21	#include <sched.h>
69281c49 LP	22	#include <sys/mount.h>
26fbedd7	23	#include <sys/personality.h>
69281c49	24	#include <sys/prctl.h>
0b452006	25	#include <sys/stat.h>
07630cea	26	#include <sys/types.h>
0b452006 RC	27	#include <sys/wait.h>
0b452006 RC	28	#include <unistd.h>
b3d69149 EV	29	#ifdef HAVE_VALGRIND_VALGRIND_H
	30	#include <valgrind/valgrind.h>
	31	#endif
0b452006	32
b5efdb8a	33	#include "alloc-util.h"
26fbedd7	34	#include "architecture.h"
69281c49	35	#include "fd-util.h"
0b452006	36	#include "log.h"
0b452006	37	#include "macro.h"
18dade5a	38	#include "parse-util.h"
07630cea	39	#include "process-util.h"
9a140c35	40	#include "stdio-util.h"
07630cea	41	#include "string-util.h"
288a74cc	42	#include "terminal-util.h"
76c19e9f	43	#include "test-helper.h"
07630cea LP	44	#include "util.h"
07630cea LP	45	#include "virt.h"
0b452006	46
9a140c35	47	static void test_get_process_comm(pid_t pid) {
0b452006	48	struct stat st;
ba19c6e1	49	_cleanup_free_ char a = NULL, c = NULL, d = NULL, f = NULL, *i = NULL;
0b452006	50	_cleanup_free_ char *env = NULL;
9a140c35	51	char path[strlen("/proc//comm") + DECIMAL_STR_MAX(pid_t)];
0b452006 RC	52	pid_t e;
	53	uid_t u;
	54	gid_t g;
	55	dev_t h;
	56	int r;
0b452006	57
9a140c35 ZJS	58	xsprintf(path, "/proc/"PID_FMT"/comm", pid);
	59
	60	if (stat(path, &st) == 0) {
	61	assert_se(get_process_comm(pid, &a) >= 0);
	62	log_info("PID"PID_FMT" comm: '%s'", pid, a);
cfeaa44a	63	} else
9a140c35	64	log_warning("%s not exist.", path);
0b452006	65
9a140c35 ZJS	66	assert_se(get_process_cmdline(pid, 0, true, &c) >= 0);
9a140c35 ZJS	67	log_info("PID"PID_FMT" cmdline: '%s'", pid, c);
0b452006	68
9a140c35	69	assert_se(get_process_cmdline(pid, 8, false, &d) >= 0);
69281c49 LP	70	log_info("PID"PID_FMT" cmdline truncated to 8: '%s'", pid, d);
	71
	72	free(d);
	73	assert_se(get_process_cmdline(pid, 1, false, &d) >= 0);
	74	log_info("PID"PID_FMT" cmdline truncated to 1: '%s'", pid, d);
0b452006	75
9a140c35 ZJS	76	assert_se(get_process_ppid(pid, &e) >= 0);
	77	log_info("PID"PID_FMT" PPID: "PID_FMT, pid, e);
	78	assert_se(pid == 1 ? e == 0 : e > 0);
0b452006	79
9a140c35	80	assert_se(is_kernel_thread(pid) == 0 \|\| pid != 1);
0b452006	81
9a140c35	82	r = get_process_exe(pid, &f);
0b452006	83	assert_se(r >= 0 \|\| r == -EACCES);
9a140c35	84	log_info("PID"PID_FMT" exe: '%s'", pid, strna(f));
0b452006	85
9a140c35 ZJS	86	assert_se(get_process_uid(pid, &u) == 0);
	87	log_info("PID"PID_FMT" UID: "UID_FMT, pid, u);
	88	assert_se(u == 0 \|\| pid != 1);
0b452006	89
9a140c35 ZJS	90	assert_se(get_process_gid(pid, &g) == 0);
	91	log_info("PID"PID_FMT" GID: "GID_FMT, pid, g);
	92	assert_se(g == 0 \|\| pid != 1);
0b452006	93
9a140c35	94	r = get_process_environ(pid, &env);
0b452006	95	assert_se(r >= 0 \|\| r == -EACCES);
9a140c35	96	log_info("PID"PID_FMT" strlen(environ): %zi", pid, env ? (ssize_t)strlen(env) : (ssize_t)-errno);
0b452006	97
75f86906	98	if (!detect_container())
9a140c35	99	assert_se(get_ctty_devnr(pid, &h) == -ENXIO \|\| pid != 1);
0b452006	100
9a140c35 ZJS	101	getenv_for_pid(pid, "PATH", &i);
9a140c35 ZJS	102	log_info("PID"PID_FMT" $PATH: '%s'", pid, strna(i));
0b452006 RC	103	}
	104
	105	static void test_pid_is_unwaited(void) {
	106	pid_t pid;
	107
	108	pid = fork();
	109	assert_se(pid >= 0);
	110	if (pid == 0) {
	111	_exit(EXIT_SUCCESS);
	112	} else {
	113	int status;
	114
	115	waitpid(pid, &status, 0);
	116	assert_se(!pid_is_unwaited(pid));
	117	}
	118	assert_se(pid_is_unwaited(getpid()));
	119	assert_se(!pid_is_unwaited(-1));
	120	}
	121
	122	static void test_pid_is_alive(void) {
	123	pid_t pid;
	124
	125	pid = fork();
	126	assert_se(pid >= 0);
	127	if (pid == 0) {
	128	_exit(EXIT_SUCCESS);
	129	} else {
	130	int status;
	131
	132	waitpid(pid, &status, 0);
	133	assert_se(!pid_is_alive(pid));
	134	}
	135	assert_se(pid_is_alive(getpid()));
	136	assert_se(!pid_is_alive(-1));
	137	}
	138
26fbedd7 LP	139	static void test_personality(void) {
	140
	141	assert_se(personality_to_string(PER_LINUX));
	142	assert_se(!personality_to_string(PERSONALITY_INVALID));
	143
	144	assert_se(streq(personality_to_string(PER_LINUX), architecture_to_string(native_architecture())));
	145
	146	assert_se(personality_from_string(personality_to_string(PER_LINUX)) == PER_LINUX);
	147	assert_se(personality_from_string(architecture_to_string(native_architecture())) == PER_LINUX);
	148
	149	#ifdef __x86_64__
	150	assert_se(streq_ptr(personality_to_string(PER_LINUX), "x86-64"));
	151	assert_se(streq_ptr(personality_to_string(PER_LINUX32), "x86"));
	152
	153	assert_se(personality_from_string("x86-64") == PER_LINUX);
	154	assert_se(personality_from_string("x86") == PER_LINUX32);
	155	assert_se(personality_from_string("ia64") == PERSONALITY_INVALID);
	156	assert_se(personality_from_string(NULL) == PERSONALITY_INVALID);
	157
	158	assert_se(personality_from_string(personality_to_string(PER_LINUX32)) == PER_LINUX32);
	159	#endif
	160	}
	161
69281c49 LP	162	static void test_get_process_cmdline_harder(void) {
	163	char path[] = "/tmp/test-cmdlineXXXXXX";
	164	_cleanup_close_ int fd = -1;
	165	_cleanup_free_ char *line = NULL;
	166	pid_t pid;
	167
	168	if (geteuid() != 0)
	169	return;
	170
b3d69149 EV	171	#ifdef HAVE_VALGRIND_VALGRIND_H
	172	/* valgrind patches open(/proc//cmdline)
	173	* so, test_get_process_cmdline_harder fails always
	174	* See https://github.com/systemd/systemd/pull/3555#issuecomment-226564908 */
	175	if (RUNNING_ON_VALGRIND)
	176	return;
	177	#endif
	178
69281c49 LP	179	pid = fork();
	180	if (pid > 0) {
	181	siginfo_t si;
	182
	183	(void) wait_for_terminate(pid, &si);
	184
	185	assert_se(si.si_code == CLD_EXITED);
	186	assert_se(si.si_status == 0);
	187
	188	return;
	189	}
	190
	191	assert_se(pid == 0);
	192	assert_se(unshare(CLONE_NEWNS) >= 0);
	193
	194	fd = mkostemp(path, O_CLOEXEC);
	195	assert_se(fd >= 0);
347ebd02 ZJS	196
	197	if (mount(path, "/proc/self/cmdline", "bind", MS_BIND, NULL) < 0) {
	198	/* This happens under selinux… Abort the test in this case. */
	199	log_warning_errno(errno, "mount(..., \"/proc/self/cmdline\", \"bind\", ...) failed: %m");
	200	assert(errno == EACCES);
	201	return;
	202	}
	203
69281c49 LP	204	assert_se(unlink(path) >= 0);
	205
	206	assert_se(prctl(PR_SET_NAME, "testa") >= 0);
	207
	208	assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);
	209
	210	assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
	211	assert_se(streq(line, "[testa]"));
	212	line = mfree(line);
	213
	214	assert_se(get_process_cmdline(getpid(), 1, true, &line) >= 0);
	215	assert_se(streq(line, ""));
	216	line = mfree(line);
	217
	218	assert_se(get_process_cmdline(getpid(), 2, true, &line) >= 0);
	219	assert_se(streq(line, "["));
	220	line = mfree(line);
	221
	222	assert_se(get_process_cmdline(getpid(), 3, true, &line) >= 0);
	223	assert_se(streq(line, "[."));
	224	line = mfree(line);
	225
	226	assert_se(get_process_cmdline(getpid(), 4, true, &line) >= 0);
	227	assert_se(streq(line, "[.."));
	228	line = mfree(line);
	229
	230	assert_se(get_process_cmdline(getpid(), 5, true, &line) >= 0);
	231	assert_se(streq(line, "[..."));
	232	line = mfree(line);
	233
	234	assert_se(get_process_cmdline(getpid(), 6, true, &line) >= 0);
	235	assert_se(streq(line, "[...]"));
	236	line = mfree(line);
	237
	238	assert_se(get_process_cmdline(getpid(), 7, true, &line) >= 0);
	239	assert_se(streq(line, "[t...]"));
	240	line = mfree(line);
	241
	242	assert_se(get_process_cmdline(getpid(), 8, true, &line) >= 0);
	243	assert_se(streq(line, "[testa]"));
	244	line = mfree(line);
	245
	246	assert_se(write(fd, "\0\0\0\0\0\0\0\0\0", 10) == 10);
	247
	248	assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);
	249
	250	assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
	251	assert_se(streq(line, "[testa]"));
	252	line = mfree(line);
	253
	254	assert_se(write(fd, "foo\0bar\0\0\0\0\0", 10) == 10);
	255
	256	assert_se(get_process_cmdline(getpid(), 0, false, &line) >= 0);
	257	assert_se(streq(line, "foo bar"));
	258	line = mfree(line);
	259
	260	assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
	261	assert_se(streq(line, "foo bar"));
	262	line = mfree(line);
	263
	264	assert_se(write(fd, "quux", 4) == 4);
	265	assert_se(get_process_cmdline(getpid(), 0, false, &line) >= 0);
	266	assert_se(streq(line, "foo bar quux"));
	267	line = mfree(line);
268
269	assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
270	assert_se(streq(line, "foo bar quux"));
271	line = mfree(line);
272
273	assert_se(get_process_cmdline(getpid(), 1, true, &line) >= 0);
274	assert_se(streq(line, ""));
275	line = mfree(line);
276
277	assert_se(get_process_cmdline(getpid(), 2, true, &line) >= 0);
278	assert_se(streq(line, "."));
279	line = mfree(line);
280
281	assert_se(get_process_cmdline(getpid(), 3, true, &line) >= 0);
282	assert_se(streq(line, ".."));
283	line = mfree(line);
284
285	assert_se(get_process_cmdline(getpid(), 4, true, &line) >= 0);
286	assert_se(streq(line, "..."));
287	line = mfree(line);
288
289	assert_se(get_process_cmdline(getpid(), 5, true, &line) >= 0);
290	assert_se(streq(line, "f..."));
291	line = mfree(line);
292
293	assert_se(get_process_cmdline(getpid(), 6, true, &line) >= 0);
294	assert_se(streq(line, "fo..."));
295	line = mfree(line);
296
297	assert_se(get_process_cmdline(getpid(), 7, true, &line) >= 0);
298	assert_se(streq(line, "foo..."));
299	line = mfree(line);
300
301	assert_se(get_process_cmdline(getpid(), 8, true, &line) >= 0);
302	assert_se(streq(line, "foo..."));
303	line = mfree(line);
304
305	assert_se(get_process_cmdline(getpid(), 9, true, &line) >= 0);
306	assert_se(streq(line, "foo b..."));
307	line = mfree(line);
308
309	assert_se(get_process_cmdline(getpid(), 10, true, &line) >= 0);
310	assert_se(streq(line, "foo ba..."));
311	line = mfree(line);
312
313	assert_se(get_process_cmdline(getpid(), 11, true, &line) >= 0);
314	assert_se(streq(line, "foo bar..."));
315	line = mfree(line);
316
317	assert_se(get_process_cmdline(getpid(), 12, true, &line) >= 0);
318	assert_se(streq(line, "foo bar..."));
319	line = mfree(line);
320
321	assert_se(get_process_cmdline(getpid(), 13, true, &line) >= 0);
322	assert_se(streq(line, "foo bar quux"));
323	line = mfree(line);
324
325	assert_se(get_process_cmdline(getpid(), 14, true, &line) >= 0);
326	assert_se(streq(line, "foo bar quux"));
327	line = mfree(line);
328
329	assert_se(get_process_cmdline(getpid(), 1000, true, &line) >= 0);
330	assert_se(streq(line, "foo bar quux"));
331	line = mfree(line);
332
333	assert_se(ftruncate(fd, 0) >= 0);
334	assert_se(prctl(PR_SET_NAME, "aaaa bbbb cccc") >= 0);
335
336	assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);
337
338	assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
339	assert_se(streq(line, "[aaaa bbbb cccc]"));
340	line = mfree(line);
341
342	assert_se(get_process_cmdline(getpid(), 10, true, &line) >= 0);
343	assert_se(streq(line, "[aaaa...]"));
344	line = mfree(line);
345
346	assert_se(get_process_cmdline(getpid(), 11, true, &line) >= 0);
347	assert_se(streq(line, "[aaaa...]"));
348	line = mfree(line);
349
350	assert_se(get_process_cmdline(getpid(), 12, true, &line) >= 0);
351	assert_se(streq(line, "[aaaa b...]"));
352	line = mfree(line);
353
354	safe_close(fd);
355	_exit(0);
356	}
357
0b452006 RC	358	int main(int argc, char *argv[]) {
	359	log_parse_environment();
	360	log_open();
	361
18dade5a ZJS	362	if (argc > 1) {
	363	pid_t pid = 0;
	364
	365	(void) parse_pid(argv[1], &pid);
	366	test_get_process_comm(pid);
	367	} else {
76c19e9f	368	TEST_REQ_RUNNING_SYSTEMD(test_get_process_comm(1));
18dade5a ZJS	369	test_get_process_comm(getpid());
	370	}
	371
0b452006 RC	372	test_pid_is_unwaited();
0b452006 RC	373	test_pid_is_alive();
26fbedd7	374	test_personality();
69281c49	375	test_get_process_cmdline_harder();
0b452006 RC	376
	377	return 0;
	378	}