processgroup.cpp revision 171df0a092157deb2cdf868beecc2ca3dcbeb548 
1/*
2 *  Copyright 2014 Google, Inc
3 *
4 *  Licensed under the Apache License, Version 2.0 (the "License");
5 *  you may not use this file except in compliance with the License.
6 *  You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 *  Unless required by applicable law or agreed to in writing, software
11 *  distributed under the License is distributed on an "AS IS" BASIS,
12 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 *  See the License for the specific language governing permissions and
14 *  limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "libprocessgroup"
19
20#include <assert.h>
21#include <dirent.h>
22#include <errno.h>
23#include <fcntl.h>
24#include <inttypes.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <sys/stat.h>
29#include <sys/types.h>
30
31#include <chrono>
32#include <memory>
33
34#include <android-base/logging.h>
35#include <private/android_filesystem_config.h>
36
37#include <processgroup/processgroup.h>
38#include "processgroup_priv.h"
39
40struct ctx {
41    bool initialized;
42    int fd;
43    char buf[128];
44    char *buf_ptr;
45    size_t buf_len;
46};
47
48static int convertUidToPath(char *path, size_t size, uid_t uid)
49{
50    return snprintf(path, size, "%s/%s%d",
51            PROCESSGROUP_CGROUP_PATH,
52            PROCESSGROUP_UID_PREFIX,
53            uid);
54}
55
56static int convertUidPidToPath(char *path, size_t size, uid_t uid, int pid)
57{
58    return snprintf(path, size, "%s/%s%d/%s%d",
59            PROCESSGROUP_CGROUP_PATH,
60            PROCESSGROUP_UID_PREFIX,
61            uid,
62            PROCESSGROUP_PID_PREFIX,
63            pid);
64}
65
66static int initCtx(uid_t uid, int pid, struct ctx *ctx)
67{
68    int ret;
69    char path[PROCESSGROUP_MAX_PATH_LEN] = {0};
70    convertUidPidToPath(path, sizeof(path), uid, pid);
71    strlcat(path, PROCESSGROUP_CGROUP_PROCS_FILE, sizeof(path));
72
73    int fd = open(path, O_RDONLY);
74    if (fd < 0) {
75        ret = -errno;
76        PLOG(WARNING) << "failed to open " << path;
77        return ret;
78    }
79
80    ctx->fd = fd;
81    ctx->buf_ptr = ctx->buf;
82    ctx->buf_len = 0;
83    ctx->initialized = true;
84
85    LOG(VERBOSE) << "Initialized context for " << path;
86
87    return 0;
88}
89
90static int refillBuffer(struct ctx *ctx)
91{
92    memmove(ctx->buf, ctx->buf_ptr, ctx->buf_len);
93    ctx->buf_ptr = ctx->buf;
94
95    ssize_t ret = read(ctx->fd, ctx->buf_ptr + ctx->buf_len,
96                sizeof(ctx->buf) - ctx->buf_len - 1);
97    if (ret < 0) {
98        return -errno;
99    } else if (ret == 0) {
100        return 0;
101    }
102
103    ctx->buf_len += ret;
104    ctx->buf[ctx->buf_len] = 0;
105    LOG(VERBOSE) << "Read " << ret << " to buffer: " << ctx->buf;
106
107    assert(ctx->buf_len <= sizeof(ctx->buf));
108
109    return ret;
110}
111
112static pid_t getOneAppProcess(uid_t uid, int appProcessPid, struct ctx *ctx)
113{
114    if (!ctx->initialized) {
115        int ret = initCtx(uid, appProcessPid, ctx);
116        if (ret < 0) {
117            return ret;
118        }
119    }
120
121    char *eptr;
122    while ((eptr = (char *)memchr(ctx->buf_ptr, '\n', ctx->buf_len)) == NULL) {
123        int ret = refillBuffer(ctx);
124        if (ret == 0) {
125            return -ERANGE;
126        }
127        if (ret < 0) {
128            return ret;
129        }
130    }
131
132    *eptr = '\0';
133    char *pid_eptr = NULL;
134    errno = 0;
135    long pid = strtol(ctx->buf_ptr, &pid_eptr, 10);
136    if (errno != 0) {
137        return -errno;
138    }
139    if (pid_eptr != eptr) {
140        return -EINVAL;
141    }
142
143    ctx->buf_len -= (eptr - ctx->buf_ptr) + 1;
144    ctx->buf_ptr = eptr + 1;
145
146    return (pid_t)pid;
147}
148
149static int removeProcessGroup(uid_t uid, int pid)
150{
151    int ret;
152    char path[PROCESSGROUP_MAX_PATH_LEN] = {0};
153
154    convertUidPidToPath(path, sizeof(path), uid, pid);
155    ret = rmdir(path);
156
157    convertUidToPath(path, sizeof(path), uid);
158    rmdir(path);
159
160    return ret;
161}
162
163static void removeUidProcessGroups(const char *uid_path)
164{
165    std::unique_ptr<DIR, decltype(&closedir)> uid(opendir(uid_path), closedir);
166    if (uid != NULL) {
167        struct dirent cur;
168        struct dirent *dir;
169        while ((readdir_r(uid.get(), &cur, &dir) == 0) && dir) {
170            char path[PROCESSGROUP_MAX_PATH_LEN];
171
172            if (dir->d_type != DT_DIR) {
173                continue;
174            }
175
176            if (strncmp(dir->d_name, PROCESSGROUP_PID_PREFIX, strlen(PROCESSGROUP_PID_PREFIX))) {
177                continue;
178            }
179
180            snprintf(path, sizeof(path), "%s/%s", uid_path, dir->d_name);
181            LOG(VERBOSE) << "removing " << path;
182            if (rmdir(path) == -1) PLOG(WARNING) << "failed to remove " << path;
183        }
184    }
185}
186
187void removeAllProcessGroups()
188{
189    LOG(VERBOSE) << "removeAllProcessGroups()";
190    std::unique_ptr<DIR, decltype(&closedir)> root(opendir(PROCESSGROUP_CGROUP_PATH), closedir);
191    if (root == NULL) {
192        PLOG(ERROR) << "failed to open " << PROCESSGROUP_CGROUP_PATH;
193    } else {
194        struct dirent cur;
195        struct dirent *dir;
196        while ((readdir_r(root.get(), &cur, &dir) == 0) && dir) {
197            char path[PROCESSGROUP_MAX_PATH_LEN];
198
199            if (dir->d_type != DT_DIR) {
200                continue;
201            }
202            if (strncmp(dir->d_name, PROCESSGROUP_UID_PREFIX, strlen(PROCESSGROUP_UID_PREFIX))) {
203                continue;
204            }
205
206            snprintf(path, sizeof(path), "%s/%s", PROCESSGROUP_CGROUP_PATH, dir->d_name);
207            removeUidProcessGroups(path);
208            LOG(VERBOSE) << "removing " << path;
209            if (rmdir(path) == -1) PLOG(WARNING) << "failed to remove " << path;
210        }
211    }
212}
213
214static int killProcessGroupOnce(uid_t uid, int initialPid, int signal)
215{
216    int processes = 0;
217    struct ctx ctx;
218    pid_t pid;
219
220    ctx.initialized = false;
221
222    while ((pid = getOneAppProcess(uid, initialPid, &ctx)) >= 0) {
223        processes++;
224        if (pid == 0) {
225            // Should never happen...  but if it does, trying to kill this
226            // will boomerang right back and kill us!  Let's not let that happen.
227            LOG(WARNING) << "Yikes, we've been told to kill pid 0!  How about we don't do that?";
228            continue;
229        }
230        LOG(VERBOSE) << "Killing pid " << pid << " in uid " << uid
231                     << " as part of process group " << initialPid;
232        if (kill(pid, signal) == -1) {
233            PLOG(WARNING) << "kill(" << pid << ", " << signal << ") failed";
234        }
235    }
236
237    if (ctx.initialized) {
238        close(ctx.fd);
239    }
240
241    return processes;
242}
243
244int killProcessGroup(uid_t uid, int initialPid, int signal)
245{
246    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
247
248    int retry = 40;
249    int processes;
250    while ((processes = killProcessGroupOnce(uid, initialPid, signal)) > 0) {
251        LOG(VERBOSE) << "killed " << processes << " processes for processgroup " << initialPid;
252        if (retry > 0) {
253            usleep(5 * 1000); // 5ms
254            --retry;
255        } else {
256            LOG(ERROR) << "failed to kill " << processes << " processes for processgroup "
257                       << initialPid;
258            break;
259        }
260    }
261
262    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
263
264    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
265    LOG(VERBOSE) << "Killed process group uid " << uid << " pid " << initialPid << " in "
266                 << static_cast<int>(ms) << "ms, " << processes << " procs remain";
267
268    if (processes == 0) {
269        return removeProcessGroup(uid, initialPid);
270    } else {
271        return -1;
272    }
273}
274
275static bool mkdirAndChown(const char *path, mode_t mode, uid_t uid, gid_t gid)
276{
277    if (mkdir(path, mode) == -1 && errno != EEXIST) {
278        return false;
279    }
280
281    if (chown(path, uid, gid) == -1) {
282        int saved_errno = errno;
283        rmdir(path);
284        errno = saved_errno;
285        return false;
286    }
287
288    return true;
289}
290
291int createProcessGroup(uid_t uid, int initialPid)
292{
293    char path[PROCESSGROUP_MAX_PATH_LEN] = {0};
294
295    convertUidToPath(path, sizeof(path), uid);
296
297    if (!mkdirAndChown(path, 0750, AID_SYSTEM, AID_SYSTEM)) {
298        PLOG(ERROR) << "failed to make and chown " << path;
299        return -errno;
300    }
301
302    convertUidPidToPath(path, sizeof(path), uid, initialPid);
303
304    if (!mkdirAndChown(path, 0750, AID_SYSTEM, AID_SYSTEM)) {
305        PLOG(ERROR) << "failed to make and chown " << path;
306        return -errno;
307    }
308
309    strlcat(path, PROCESSGROUP_CGROUP_PROCS_FILE, sizeof(path));
310
311    int fd = open(path, O_WRONLY);
312    if (fd == -1) {
313        int ret = -errno;
314        PLOG(ERROR) << "failed to open " << path;
315        return ret;
316    }
317
318    char pid[PROCESSGROUP_MAX_PID_LEN + 1] = {0};
319    int len = snprintf(pid, sizeof(pid), "%d", initialPid);
320
321    int ret = 0;
322    if (write(fd, pid, len) < 0) {
323        ret = -errno;
324        PLOG(ERROR) << "failed to write '" << pid << "' to " << path;
325    }
326
327    close(fd);
328    return ret;
329}
330