/*
* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.jvmstat;
import java.io.*;
import java.util.*;
import java.util.regex.*;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.Files;
import java.nio.charset.*;
/*
* Linux specific implementation of the PlatformSupport routines
* providing process ID and temp directory support for host and
* cgroup container processes.
*/
public class PlatformSupportImpl extends PlatformSupport {
private static final String containerTmpPath = "/root" + getTemporaryDirectory();
private static final String pidPatternStr = "^[0-9]+$";
/*
* Return the temporary directories that the VM uses for the attach
* and perf data files. This function returns the traditional
* /tmp directory in addition to paths within the /proc file system
* allowing access to container tmp directories such as /proc/{pid}/root/tmp.
*
* It is important that this directory is well-known and the
* same for all VM instances. It cannot be affected by configuration
* variables such as java.io.tmpdir.
*
* Implementation Details:
*
* Java processes that run in docker containers are typically running
* under cgroups with separate pid namespaces which means that pids
* within the container are different that the pid which is visible
* from the host. The container pids typically start with 1 and
* increase. The java process running in the container will use these
* pids when creating the hsperfdata files. In order to locate java
* processes that are running in containers, we take advantage of
* the Linux proc file system which maps the containers tmp directory
* to the hosts under /proc/{hostpid}/root/tmp. We use the /proc status
* file /proc/{hostpid}/status to determine the containers pid and
* then access the hsperfdata file. The status file contains an
* entry "NSPid:" which shows the mapping from the hostpid to the
* containers pid.
*
* Example:
*
* NSPid: 24345 11
*
* In this example process 24345 is visible from the host,
* is running under the PID namespace and has a container specific
* pid of 11.
*
* The search for Java processes is done by first looking in the
* traditional /tmp for host process hsperfdata files and then
* the search will container in every /proc/{pid}/root/tmp directory.
* There are of course added complications to this search that
* need to be taken into account.
*
* 1. duplication of tmp directories
*
* /proc/{hostpid}/root/tmp directories exist for many processes
* that are running on a Linux kernel that has cgroups enabled even
* if they are not running in a container. To avoid this duplication,
* we compare the inode of the /proc tmp directories to /tmp and
* skip these duplicated directories.
*
* 2. Containerized processes without PID namespaces being enabled.
*
* If a container is running a Java process without namespaces being
* enabled, an hsperfdata file will only be located at
* /proc/{hostpid}/root/tmp/{hostpid}. This is handled by
* checking the last component in the path for both the hostpid
* and potential namespacepids (if one exists).
*/
public List<String> getTemporaryDirectories(int pid) {
FilenameFilter pidFilter;
Matcher pidMatcher;
Pattern pidPattern = Pattern.compile(pidPatternStr);
long tmpInode = 0;
File procdir = new File("/proc");
if (pid != 0) {
pidPattern = Pattern.compile(Integer.toString(pid));
}
else {
pidPattern = Pattern.compile(pidPatternStr);
}
pidMatcher = pidPattern.matcher("");
// Add the default temporary directory first
List<String> v = new ArrayList<>();
v.add(getTemporaryDirectory());
try {
File f = new File(getTemporaryDirectory());
tmpInode = (Long)Files.getAttribute(f.toPath(), "unix:ino");
}
catch (IOException e) {}
pidFilter = new FilenameFilter() {
public boolean accept(File dir, String name) {
if (!dir.isDirectory())
return false;
pidMatcher.reset(name);
return pidMatcher.matches();
}
};
File[] dirs = procdir.listFiles(pidFilter);
// Add all unique /proc/{pid}/root/tmp dirs that are not mapped to /tmp
for (File dir : dirs) {
String containerTmpDir = dir.getAbsolutePath() + containerTmpPath;
File containerFile = new File(containerTmpDir);
try {
long procInode = (Long)Files.getAttribute(containerFile.toPath(), "unix:ino");
if (containerFile.exists() && containerFile.isDirectory() &&
containerFile.canRead() && procInode != tmpInode) {
v.add(containerTmpDir);
}
}
catch (IOException e) {}
}
return v;
}
/*
* Extract either the host PID or the NameSpace PID
* from a file path.
*
* File path should be in 1 of these 2 forms:
*
* /proc/{pid}/root/tmp/hsperfdata_{user}/{nspid}
* or
* /tmp/hsperfdata_{user}/{pid}
*
* In either case we want to return {pid} and NOT {nspid}
*
* This function filters out host pids which do not have
* associated hsperfdata files. This is due to the fact that
* getTemporaryDirectories will return /proc/{pid}/root/tmp
* paths for all container processes whether they are java
* processes or not causing duplicate matches.
*/
public int getLocalVmId(File file) throws NumberFormatException {
String p = file.getAbsolutePath();
String s[] = p.split("\\/");
// Determine if this file is from a container
if (s.length == 7 && s[1].equals("proc")) {
int hostpid = Integer.parseInt(s[2]);
int nspid = Integer.parseInt(s[6]);
if (nspid == hostpid || nspid == getNamespaceVmId(hostpid)) {
return hostpid;
}
else {
return -1;
}
}
else {
return Integer.parseInt(file.getName());
}
}
/*
* Return the inner most namespaced PID if there is one,
* otherwise return the original PID.
*/
public int getNamespaceVmId(int pid) {
// Assuming a real procfs sits beneath, reading this doesn't block
// nor will it consume a lot of memory.
Path statusPath = Paths.get("/proc", Integer.toString(pid), "status");
if (Files.notExists(statusPath)) {
return pid; // Likely a bad pid, but this is properly handled later.
}
try {
for (String line : Files.readAllLines(statusPath, StandardCharsets.UTF_8)) {
String[] parts = line.split(":");
if (parts.length == 2 && parts[0].trim().equals("NSpid")) {
parts = parts[1].trim().split("\\s+");
// The last entry represents the PID the JVM "thinks" it is.
// Even in non-namespaced pids these entries should be
// valid. You could refer to it as the inner most pid.
int ns_pid = Integer.parseInt(parts[parts.length - 1]);
return ns_pid;
}
}
// Old kernels may not have NSpid field (i.e. 3.10).
// Fallback to original pid in the event we cannot deduce.
return pid;
} catch (NumberFormatException | IOException x) {
return pid;
}
}
}