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
|
/* Wait for process state.
Copyright (C) 2020-2026 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; if not, see
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <array_length.h>
#include <intprops.h>
#include <support/process_state.h>
#include <support/xstdio.h>
#include <support/check.h>
static enum support_process_state
support_process_state_wait_common (FILE *fstatus,
enum support_process_state state)
{
#ifdef __linux__
/* For Linux it does a polling check on /proc/<pid>/status checking on
third field. */
/* It mimics the kernel states from fs/proc/array.c */
static const struct process_states
{
enum support_process_state s;
char v;
} process_states[] = {
{ support_process_state_running, 'R' },
{ support_process_state_sleeping, 'S' },
{ support_process_state_disk_sleep, 'D' },
{ support_process_state_stopped, 'T' },
{ support_process_state_tracing_stop, 't' },
{ support_process_state_dead, 'X' },
{ support_process_state_zombie, 'Z' },
{ support_process_state_parked, 'P' },
};
char *line = NULL;
size_t linesiz = 0;
for (;;)
{
char cur_state = CHAR_MAX;
ssize_t r;
while ((r = getline (&line, &linesiz, fstatus)) > 0)
if (strncmp (line, "State:", strlen ("State:")) == 0)
{
TEST_COMPARE (sscanf (line, "%*s %c", &cur_state), 1);
break;
}
/* The procfs file for the /proc/self/task/tid might be removed by the
kernel if the thread exits before the getline call. In this case
returns that the thread is dead. */
if (r == -1 && errno == ESRCH)
{
free (line);
fclose (fstatus);
return support_process_state_dead;
}
TEST_VERIFY (ferror (fstatus) == 0);
/* Fallback to nanosleep for invalid state. */
if (cur_state == CHAR_MAX)
break;
for (size_t i = 0; i < array_length (process_states); ++i)
if (state & process_states[i].s && cur_state == process_states[i].v)
{
free (line);
fclose (fstatus);
return process_states[i].s;
}
rewind (fstatus);
fflush (fstatus);
if (nanosleep (&(struct timespec) { 0, 10000000 }, NULL) != 0)
FAIL_EXIT1 ("nanosleep: %m");
}
free (line);
fclose (fstatus);
/* Fallback to nanosleep if an invalid state is found. */
#endif
nanosleep (&(struct timespec) { 1, 0 }, NULL);
return support_process_state_invalid;
}
enum support_process_state
support_process_state_wait (pid_t pid, enum support_process_state state)
{
FILE *fstatus = NULL;
#ifdef __linux__
/* For Linux it does a polling check on /proc/<pid>/status checking on
third field. */
char path[sizeof ("/proc/")
+ INT_STRLEN_BOUND (pid_t)
+ sizeof ("/status") + 1];
snprintf (path, sizeof (path), "/proc/%i/status", pid);
fstatus = xfopen (path, "r");
#endif
return support_process_state_wait_common (fstatus, state);
}
enum support_process_state
support_thread_state_wait (pid_t tid, enum support_process_state state)
{
FILE *fstatus = NULL;
#ifdef __linux__
/* For Linux it does a polling check on /proc/<getpid()>/task/<tid>/status
checking on third field. */
char path[sizeof ("/proc/")
+ INT_STRLEN_BOUND (pid_t) + 1 /* <getpid()>/ */
+ sizeof ("task/")
+ INT_STRLEN_BOUND (pid_t) + 1 /* <tid>/ */
+ sizeof ("/status") + 1];
snprintf (path, sizeof (path), "/proc/%i/task/%i/status", getpid (), tid);
fstatus = fopen (path, "r");
/* The thread might already being terminated and there is no check whether
tid is a valid descriptior. */
if (fstatus == NULL)
return support_process_state_dead;
#endif
return support_process_state_wait_common (fstatus, state);
}
|
