libprocinfo: introduce. (911d729c) · Commits · e / os / android_system_core

libprocinfo/.clang-format

0 → 100644

+14 −0

Original line number	Diff line number	Diff line
		BasedOnStyle: Google
		AllowShortBlocksOnASingleLine: false
		AllowShortFunctionsOnASingleLine: false

		ColumnLimit: 100
		CommentPragmas: NOLINT:.*
		DerivePointerAlignment: false
		IndentWidth: 2
		PointerAlignment: Left
		TabWidth: 2
		UseTab: Never
		PenaltyExcessCharacter: 32

		Cpp11BracedListStyle: false

libprocinfo/Android.bp

0 → 100644

+73 −0

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2015 The Android Open Source Project
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		//

		libprocinfo_cppflags = [
		"-Wall",
		"-Wextra",
		"-Werror",
		]

		cc_library {
		name: "libprocinfo",
		host_supported: true,
		srcs: [
		"process.cpp",
		],
		cppflags: libprocinfo_cppflags,

		local_include_dirs: ["include"],
		export_include_dirs: ["include"],
		shared_libs: ["libbase"],
		target: {
		darwin: {
		enabled: false,
		},
		windows: {
		enabled: false,
		},
		},
		}

		// Tests
		// ------------------------------------------------------------------------------
		cc_test {
		name: "libprocinfo_test",
		host_supported: true,
		srcs: [
		"process_test.cpp",
		],
		target: {
		darwin: {
		enabled: false,
		},
		windows: {
		enabled: false,
		},
		},

		cppflags: libprocinfo_cppflags,
		shared_libs: ["libbase", "libprocinfo"],

		compile_multilib: "both",
		multilib: {
		lib32: {
		suffix: "32",
		},
		lib64: {
		suffix: "64",
		},
		},
		}

libprocinfo/include/procinfo/process.h

0 → 100644

+106 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

		#include <dirent.h>
		#include <fcntl.h>
		#include <stdlib.h>
		#include <sys/types.h>
		#include <unistd.h>

		#include <memory>
		#include <string>
		#include <type_traits>

		#include <android-base/logging.h>
		#include <android-base/parseint.h>
		#include <android-base/unique_fd.h>

		namespace android {
		namespace procinfo {

		#if defined(__linux__)

		struct ProcessInfo {
		std::string name;
		pid_t tid;
		pid_t pid;
		pid_t ppid;
		pid_t tracer;
		uid_t uid;
		uid_t gid;
		};

		// Parse the contents of /proc/<tid>/status into \|process_info\|.
		bool GetProcessInfo(pid_t tid, ProcessInfo* process_info);

		// Parse the contents of <fd>/status into \|process_info\|.
		// \|fd\| should be an fd pointing at a /proc/<pid> directory.
		bool GetProcessInfoFromProcPidFd(int fd, ProcessInfo* process_info);

		// Fetch the list of threads from a given process's /proc/<pid> directory.
		// \|fd\| should be an fd pointing at a /proc/<pid> directory.
		template <typename Collection>
		auto GetProcessTidsFromProcPidFd(int fd, Collection* out) ->
		typename std::enable_if<sizeof(typename Collection::value_type) >= sizeof(pid_t), bool>::type {
		out->clear();

		int task_fd = openat(fd, "task", O_DIRECTORY \| O_RDONLY \| O_CLOEXEC);
		std::unique_ptr<DIR, int ()(DIR)> dir(fdopendir(task_fd), closedir);
		if (!dir) {
		PLOG(ERROR) << "failed to open task directory";
		return false;
		}

		struct dirent* dent;
		while ((dent = readdir(dir.get()))) {
		if (strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0) {
		pid_t tid;
		if (!android::base::ParseInt(dent->d_name, &tid, 1, std::numeric_limits<pid_t>::max())) {
		LOG(ERROR) << "failed to parse task id: " << dent->d_name;
		return false;
		}

		out->insert(out->end(), tid);
		}
		}

		return true;
		}

		template <typename Collection>
		auto GetProcessTids(pid_t pid, Collection* out) ->
		typename std::enable_if<sizeof(typename Collection::value_type) >= sizeof(pid_t), bool>::type {
		char task_path[PATH_MAX];
		if (snprintf(task_path, PATH_MAX, "/proc/%d", pid) >= PATH_MAX) {
		LOG(ERROR) << "task path overflow (pid = " << pid << ")";
		return false;
		}

		android::base::unique_fd fd(open(task_path, O_DIRECTORY \| O_RDONLY \| O_CLOEXEC));
		if (fd == -1) {
		PLOG(ERROR) << "failed to open " << task_path;
		return false;
		}

		return GetProcessTidsFromProcPidFd(fd.get(), out);
		}

		#endif

		} /* namespace procinfo */
		} /* namespace android */

libprocinfo/process.cpp

0 → 100644

+109 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <procinfo/process.h>

		#include <fcntl.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <unistd.h>

		#include <string>

		#include <android-base/unique_fd.h>

		using android::base::unique_fd;

		namespace android {
		namespace procinfo {

		bool GetProcessInfo(pid_t tid, ProcessInfo* process_info) {
		char path[PATH_MAX];
		snprintf(path, sizeof(path), "/proc/%d", tid);

		unique_fd dirfd(open(path, O_DIRECTORY \| O_RDONLY));
		if (dirfd == -1) {
		PLOG(ERROR) << "failed to open " << path;
		return false;
		}

		return GetProcessInfoFromProcPidFd(dirfd.get(), process_info);
		}

		bool GetProcessInfoFromProcPidFd(int fd, ProcessInfo* process_info) {
		int status_fd = openat(fd, "status", O_RDONLY \| O_CLOEXEC);

		if (status_fd == -1) {
		PLOG(ERROR) << "failed to open status fd in GetProcessInfoFromProcPidFd";
		return false;
		}

		std::unique_ptr<FILE, decltype(&fclose)> fp(fdopen(status_fd, "r"), fclose);
		if (!fp) {
		PLOG(ERROR) << "failed to open status file in GetProcessInfoFromProcPidFd";
		close(status_fd);
		return false;
		}

		int field_bitmap = 0;
		static constexpr int finished_bitmap = 127;
		char* line = nullptr;
		size_t len = 0;

		while (getline(&line, &len, fp.get()) != -1 && field_bitmap != finished_bitmap) {
		char* tab = strchr(line, '\t');
		if (tab == nullptr) {
		continue;
		}

		size_t header_len = tab - line;
		std::string header = std::string(line, header_len);
		if (header == "Name:") {
		std::string name = line + header_len + 1;

		// line includes the trailing newline.
		name.pop_back();
		process_info->name = std::move(name);

		field_bitmap \|= 1;
		} else if (header == "Pid:") {
		process_info->tid = atoi(tab + 1);
		field_bitmap \|= 2;
		} else if (header == "Tgid:") {
		process_info->pid = atoi(tab + 1);
		field_bitmap \|= 4;
		} else if (header == "PPid:") {
		process_info->ppid = atoi(tab + 1);
		field_bitmap \|= 8;
		} else if (header == "TracerPid:") {
		process_info->tracer = atoi(tab + 1);
		field_bitmap \|= 16;
		} else if (header == "Uid:") {
		process_info->uid = atoi(tab + 1);
		field_bitmap \|= 32;
		} else if (header == "Gid:") {
		process_info->gid = atoi(tab + 1);
		field_bitmap \|= 64;
		}
		}

		free(line);
		return field_bitmap == finished_bitmap;
		}

		} /* namespace procinfo */
		} /* namespace android */

libprocinfo/process_test.cpp

0 → 100644

+84 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <procinfo/process.h>

		#include <fcntl.h>
		#include <stdlib.h>
		#include <sys/types.h>
		#include <unistd.h>

		#include <set>
		#include <thread>
		#include <vector>

		#include <gtest/gtest.h>

		#include <android-base/stringprintf.h>

		#if !defined(__BIONIC__)
		#include <syscall.h>
		static pid_t gettid() {
		return syscall(__NR_gettid);
		}
		#endif

		TEST(process_info, process_info_smoke) {
		android::procinfo::ProcessInfo self;
		ASSERT_TRUE(android::procinfo::GetProcessInfo(gettid(), &self));
		ASSERT_EQ(gettid(), self.tid);
		ASSERT_EQ(getpid(), self.pid);
		ASSERT_EQ(getppid(), self.ppid);
		ASSERT_EQ(getuid(), self.uid);
		ASSERT_EQ(getgid(), self.gid);
		}

		TEST(process_info, process_info_proc_pid_fd_smoke) {
		android::procinfo::ProcessInfo self;
		int fd = open(android::base::StringPrintf("/proc/%d", gettid()).c_str(), O_DIRECTORY \| O_RDONLY);
		ASSERT_NE(-1, fd);
		ASSERT_TRUE(android::procinfo::GetProcessInfoFromProcPidFd(fd, &self));

		// Process name is capped at 15 bytes.
		ASSERT_EQ("libprocinfo_tes", self.name);
		ASSERT_EQ(gettid(), self.tid);
		ASSERT_EQ(getpid(), self.pid);
		ASSERT_EQ(getppid(), self.ppid);
		ASSERT_EQ(getuid(), self.uid);
		ASSERT_EQ(getgid(), self.gid);
		close(fd);
		}

		TEST(process_info, process_tids_smoke) {
		pid_t main_tid = gettid();
		std::thread([main_tid]() {
		pid_t thread_tid = gettid();

		{
		std::vector<pid_t> vec;
		ASSERT_TRUE(android::procinfo::GetProcessTids(getpid(), &vec));
		ASSERT_EQ(1, std::count(vec.begin(), vec.end(), main_tid));
		ASSERT_EQ(1, std::count(vec.begin(), vec.end(), thread_tid));
		}

		{
		std::set<pid_t> set;
		ASSERT_TRUE(android::procinfo::GetProcessTids(getpid(), &set));
		ASSERT_EQ(1, std::count(set.begin(), set.end(), main_tid));
		ASSERT_EQ(1, std::count(set.begin(), set.end(), thread_tid));
		}
		}).join();
		}