1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
/* Test the lock upgrade path in tst-pututxline.
Copyright (C) 2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library 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.
The GNU C Library 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 the GNU C Library; see the file COPYING.LIB. If
not, see <https://www.gnu.org/licenses/>. */
/* pututxline upgrades the read lock on the file to a write lock.
This test verifies that if the lock upgrade fails, the utmp
subsystem remains in a consistent state, so that pututxline can be
called again. */
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <support/check.h>
#include <support/namespace.h>
#include <support/support.h>
#include <support/temp_file.h>
#include <support/xthread.h>
#include <support/xunistd.h>
#include <unistd.h>
#include <utmp.h>
#include <utmpx.h>
/* Path to the temporary utmp file. */
static char *path;
/* Used to synchronize the subprocesses. The barrier itself is
allocated in shared memory. */
static pthread_barrier_t *barrier;
/* Use pututxline to write an entry for PID. */
static struct utmpx *
write_entry (pid_t pid)
{
struct utmpx ut =
{
.ut_type = LOGIN_PROCESS,
.ut_id = "1",
.ut_user = "root",
.ut_pid = pid,
.ut_line = "entry",
.ut_host = "localhost",
};
return pututxline (&ut);
}
/* Create the initial entry in a subprocess, so that the utmp
subsystem in the original process is not disturbed. */
static void
subprocess_create_entry (void *closure)
{
TEST_COMPARE (utmpname (path), 0);
TEST_VERIFY (write_entry (101) != NULL);
}
/* Acquire an advisory read lock on PATH. */
__attribute__ ((noreturn)) static void
subprocess_lock_file (void)
{
int fd = xopen (path, O_RDONLY, 0);
struct flock64 fl =
{
.l_type = F_RDLCK,
fl.l_whence = SEEK_SET,
};
TEST_COMPARE (fcntl64 (fd, F_SETLKW, &fl), 0);
/* Signal to the main process that the lock has been acquired. */
xpthread_barrier_wait (barrier);
/* Wait for the unlock request from the main process. */
xpthread_barrier_wait (barrier);
/* Implicitly unlock the file. */
xclose (fd);
/* Overwrite the existing entry. */
TEST_COMPARE (utmpname (path), 0);
errno = 0;
setutxent ();
TEST_COMPARE (errno, 0);
TEST_VERIFY (write_entry (102) != NULL);
errno = 0;
endutxent ();
TEST_COMPARE (errno, 0);
_exit (0);
}
static int
do_test (void)
{
xclose (create_temp_file ("tst-pututxline-lockfail-", &path));
{
pthread_barrierattr_t attr;
xpthread_barrierattr_init (&attr);
xpthread_barrierattr_setpshared (&attr, PTHREAD_SCOPE_PROCESS);
barrier = support_shared_allocate (sizeof (*barrier));
xpthread_barrier_init (barrier, &attr, 2);
xpthread_barrierattr_destroy (&attr);
}
/* Write the initial entry. */
support_isolate_in_subprocess (subprocess_create_entry, NULL);
pid_t locker_pid = xfork ();
if (locker_pid == 0)
subprocess_lock_file ();
/* Wait for the file locking to complete. */
xpthread_barrier_wait (barrier);
/* Try to add another entry. This attempt will fail, with EINTR or
EAGAIN. */
TEST_COMPARE (utmpname (path), 0);
TEST_VERIFY (write_entry (102) == NULL);
if (errno != EINTR)
TEST_COMPARE (errno, EAGAIN);
/* Signal the subprocess to overwrite the entry. */
xpthread_barrier_wait (barrier);
/* Wait for write and unlock to complete. */
{
int status;
xwaitpid (locker_pid, &status, 0);
TEST_COMPARE (status, 0);
}
/* The file is no longer locked, so this operation will succeed. */
TEST_VERIFY (write_entry (103) != NULL);
errno = 0;
endutxent ();
TEST_COMPARE (errno, 0);
/* Check that there is just one entry with the expected contents.
If pututxline becomes desynchronized internally, the entry is not
overwritten (bug 24902). */
errno = 0;
setutxent ();
TEST_COMPARE (errno, 0);
struct utmpx *ut = getutxent ();
TEST_VERIFY_EXIT (ut != NULL);
TEST_COMPARE (ut->ut_type, LOGIN_PROCESS);
TEST_COMPARE_STRING (ut->ut_id, "1");
TEST_COMPARE_STRING (ut->ut_user, "root");
TEST_COMPARE (ut->ut_pid, 103);
TEST_COMPARE_STRING (ut->ut_line, "entry");
TEST_COMPARE_STRING (ut->ut_host, "localhost");
TEST_VERIFY (getutxent () == NULL);
errno = 0;
endutxent ();
TEST_COMPARE (errno, 0);
xpthread_barrier_destroy (barrier);
support_shared_free (barrier);
free (path);
return 0;
}
#include <support/test-driver.c>
|
