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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
// Copyright 2009 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file implements BSD-style setproctitle() for Linux.
// It is written such that it can easily be compiled outside Chromium.
//
// The Linux kernel sets up two locations in memory to pass arguments and
// environment variables to processes. First, there are two char* arrays stored
// one after another: argv and environ. A pointer to argv is passed to main(),
// while glibc sets the global variable |environ| to point at the latter. Both
// of these arrays are terminated by a null pointer; the environment array is
// also followed by some empty space to allow additional variables to be added.
//
// These arrays contain pointers to a second location in memory, where the
// strings themselves are stored one after another: first all the arguments,
// then the environment variables.
//
// When the kernel reads the command line arguments for a process, it looks at
// the range of memory that it initially used for the argument list. If the
// terminating '\0' character is still where it expects, nothing further is
// done. If it has been overwritten, the kernel will scan up to the size of
// a page looking for another.
//
// Thus to change the process title, we must move any environment variables out
// of the way to make room for a potentially longer title, and then overwrite
// the memory pointed to by argv[0] with a single replacement string, making
// sure its size does not exceed the available space.
//
// See the following kernel commit for the details of the contract between
// kernel and setproctitle:
// https://github.com/torvalds/linux/commit/2954152298c37804dab49d630aa959625b50cf64
//
// It is perhaps worth noting that patches to add a system call to Linux for
// this, like in BSD, have never made it in: this is the "official" way to do
// this on Linux. Presumably it is not in glibc due to some disagreement over
// this position within the glibc project, leaving applications caught in the
// middle. (Also, only a very few applications need or want this anyway.)
#include "base/process/set_process_title_linux.h"
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "base/files/file_util.h"
#include "base/no_destructor.h"
#include "base/numerics/safe_conversions.h"
extern char** environ;
// g_orig_argv0 is the original process name found in argv[0].
// It is set to a copy of argv[0] in setproctitle_init. It is nullptr if
// setproctitle_init was unsuccessful or not called.
static const char* g_orig_argv0 = nullptr;
// Following pointers hold the initial argv/envp memory range.
// They are initialized in setproctitle_init and are used to overwrite the
// argv/envp memory range with a new process title to be read by the kernel.
// They are nullptr if setproctitle_init was unsuccessful or not called.
// Note that g_envp_start is not necessary because it is the same as g_argv_end.
static char* g_argv_start = nullptr;
static char* g_argv_end = nullptr;
static char* g_envp_end = nullptr;
void setproctitle(const char* fmt, ...) {
va_list ap;
// Sanity check before we try and set the process title.
// The BSD version allows a null fmt to restore the original title.
if (!g_orig_argv0 || !fmt) {
return;
}
// The title can be up to the end of envp.
const size_t avail_size =
base::checked_cast<size_t>(g_envp_end - g_argv_start - 1);
// Linux 4.18--5.2 have a bug where we can never set a process title
// shorter than the initial argv. Check if the bug exists in the current
// kernel on the first call of setproctitle.
static const bool buggy_kernel = [avail_size] {
// Attempt to set an empty title. This will set cmdline to:
// "" (on Linux --4.17)
// "\0\0\0...\0\0\0.\0" (on Linux 4.18--5.2)
// "\0" (on Linux 5.3--)
UNSAFE_TODO(memset(g_argv_start, 0, avail_size + 1));
UNSAFE_TODO(g_argv_end[-1]) = '.';
std::string cmdline;
if (!base::ReadFileToString(base::FilePath("/proc/self/cmdline"),
&cmdline)) {
return false;
}
return cmdline.size() >= 2;
}();
UNSAFE_TODO(memset(g_argv_start, 0, avail_size + 1));
size_t size;
va_start(ap, fmt);
if (fmt[0] == '-') {
size = base::checked_cast<size_t>(
UNSAFE_TODO(vsnprintf(g_argv_start, avail_size, &fmt[1], ap)));
} else {
size = base::checked_cast<size_t>(
UNSAFE_TODO(snprintf(g_argv_start, avail_size, "%s ", g_orig_argv0)));
if (size < avail_size) {
size += base::checked_cast<size_t>(UNSAFE_TODO(
vsnprintf(&g_argv_start[size], avail_size - size, fmt, ap)));
}
}
va_end(ap);
// Kernel looks for a null terminator instead of the initial argv space
// when the end of the space is not terminated with a null.
// https://github.com/torvalds/linux/commit/d26d0cd97c88eb1a5704b42e41ab443406807810
//
// If the length of the new title is shorter than the original argv space,
// set the last byte of the space to an arbitrary non-null character to tell
// the kernel that setproctitle was called.
//
// On buggy kernels we can never make the process title shorter than the
// initial argv. In that case, just leave the remaining bytes filled with
// null characters.
const size_t argv_size =
base::checked_cast<size_t>(g_argv_end - g_argv_start - 1);
if (!buggy_kernel && size < argv_size) {
UNSAFE_TODO(g_argv_end[-1]) = '.';
}
}
// A version of this built into glibc would not need this function, since
// it could stash the argv pointer in __libc_start_main(). But we need it.
void setproctitle_init(const char** main_argv) {
static bool init_called = false;
if (init_called) {
return;
}
init_called = true;
if (!main_argv) {
return;
}
// Verify that the memory layout matches expectation.
char** argv = const_cast<char**>(main_argv);
char* argv_start = argv[0];
char* p = argv_start;
for (size_t i = 0; UNSAFE_TODO(argv[i]); ++i) {
if (p != UNSAFE_TODO(argv[i])) {
return;
}
UNSAFE_TODO(p += strlen(p) + 1);
}
char* argv_end = p;
size_t environ_size = 0;
for (size_t i = 0; UNSAFE_TODO(environ[i]); ++i, ++environ_size) {
if (p != UNSAFE_TODO(environ[i])) {
return;
}
UNSAFE_TODO(p += strlen(p) + 1);
}
char* envp_end = p;
// Move the environment out of the way. Note that we are moving the values,
// not the environment array itself. Also note that we preallocate the entire
// vector, because a string's underlying data pointer is not stable under
// move operations, which could otherwise occur if building up the vector
// incrementally.
static base::NoDestructor<std::vector<std::string>> environ_copy(
environ_size);
for (size_t i = 0; UNSAFE_TODO(environ[i]); ++i) {
(*environ_copy)[i] = UNSAFE_TODO(environ[i]);
UNSAFE_TODO(environ[i]) = &(*environ_copy)[i][0];
}
if (!argv[0]) {
return;
}
static base::NoDestructor<std::string> argv0_storage(argv[0]);
g_orig_argv0 = argv0_storage->data();
g_argv_start = argv_start;
g_argv_end = argv_end;
g_envp_end = envp_end;
}
|
