tests/tests/security/src/android/security/cts/SELinuxDomainTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2014 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.
  */

 package android.security.cts;

 import junit.framework.TestCase;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
 import java.io.FileNotFoundException;
 import java.io.InputStreamReader;
 import java.lang.Runtime;
 import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.Scanner;
 import java.util.Set;

 /**
  * Verify that the processes running within an SELinux domain are sane.
  *
  * TODO: Author the tests for the app contexts.
  *
  */
 public class SELinuxDomainTest extends TestCase {

     /**
      * Asserts that no processes are running in a domain.
      *
      * @param domain
      *  The domain or SELinux context to check.
      */
     private void assertDomainEmpty(String domain) throws FileNotFoundException {
         List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
         String msg = "Expected no processes in SELinux domain \"" + domain + "\""
                 + " Found: \"" + procs + "\"";
         assertNull(msg, procs);
     }

     /**
      * Asserts that a domain exists and that only one, well defined, process is
      * running in that domain.
      *
      * @param domain
      *  The domain or SELinux context to check.
      * @param executable
      *  The path of the executable or application package name.
      */
     private void assertDomainOne(String domain, String executable) throws FileNotFoundException {
         List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
         String msg = "Expected 1 process in SELinux domain \"" + domain + "\""
                 + " Found \"" + procs + "\"";
         assertNotNull(msg, procs);
         assertEquals(msg, 1, procs.size());

         msg = "Expected executable \"" + executable + "\" in SELinux domain \"" + domain + "\""
                 + "Found: \"" + procs + "\"";
         assertEquals(msg, executable, procs.get(0).procTitle);
     }

     /**
      * Asserts that a domain may exist. If a domain exists, the cardinality of
      * the domain is verified to be 1 and that the correct process is running in
      * that domain.
      *
      * @param domain
      *  The domain or SELinux context to check.
      * @param executable
      *  The path of the executable or application package name.
      */
     private void assertDomainZeroOrOne(String domain, String executable)
             throws FileNotFoundException {
         List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
         if (procs == null) {
             /* not on all devices */
             return;
         }

         String msg = "Expected 1 process in SELinux domain \"" + domain + "\""
                 + " Found: \"" + procs + "\"";
         assertEquals(msg, 1, procs.size());

         msg = "Expected executable \"" + executable + "\" in SELinux domain \"" + domain + "\""
                 + "Found: \"" + procs.get(0) + "\"";
         assertEquals(msg, executable, procs.get(0).procTitle);
     }

     /**
      * Asserts that a domain must exist, and that the cardinality is greater
      * than or equal to 1.
      *
      * @param domain
      *  The domain or SELinux context to check.
      * @param executables
      *  The path of the allowed executables or application package names.
      */
     private void assertDomainN(String domain, String... executables)
             throws FileNotFoundException {
         List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
         String msg = "Expected 1 or more processes in SELinux domain \"" + domain + "\""
                 + " Found \"" + procs + "\"";
         assertNotNull(msg, procs);

         Set<String> execList = new HashSet<String>(Arrays.asList(executables));

         for (ProcessDetails p : procs) {
             msg = "Expected one of \"" + execList + "\" in SELinux domain \"" + domain + "\""
                 + " Found: \"" + p + "\"";
             assertTrue(msg, execList.contains(p.procTitle));
         }
     }

     /**
      * Asserts that a domain, if it exists, is only running the listed executables.
      *
      * @param domain
      *  The domain or SELinux context to check.
      * @param executables
      *  The path of the allowed executables or application package names.
      */
     private void assertDomainHasExecutable(String domain, String... executables)
             throws FileNotFoundException {
         List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
         if (procs == null) {
             return; // domain doesn't exist
         }

         Set<String> execList = new HashSet<String>(Arrays.asList(executables));

         for (ProcessDetails p : procs) {
             String msg = "Expected one of \"" + execList + "\" in SELinux domain \""
                 + domain + "\"" + " Found: \"" + p + "\"";
             assertTrue(msg, execList.contains(p.procTitle));
         }
     }

     /* Init is always there */
     public void testInitDomain() throws FileNotFoundException {
         assertDomainOne("u:r:init:s0", "/init");
     }

     /* Ueventd is always there */
     public void testUeventdDomain() throws FileNotFoundException {
         assertDomainOne("u:r:ueventd:s0", "/sbin/ueventd");
     }

     /* Devices always have healthd */
     public void testHealthdDomain() throws FileNotFoundException {
         assertDomainOne("u:r:healthd:s0", "/sbin/healthd");
     }

     /* Servicemanager is always there */
     public void testServicemanagerDomain() throws FileNotFoundException {
         assertDomainOne("u:r:servicemanager:s0", "/system/bin/servicemanager");
     }

     /* Vold is always there */
     public void testVoldDomain() throws FileNotFoundException {
         assertDomainOne("u:r:vold:s0", "/system/bin/vold");
     }

     /* netd is always there */
     public void testNetdDomain() throws FileNotFoundException {
         assertDomainOne("u:r:netd:s0", "/system/bin/netd");
     }

     /* Debuggerd is always there */
     public void testDebuggerdDomain() throws FileNotFoundException {
         assertDomainN("u:r:debuggerd:s0", "/system/bin/debuggerd", "/system/bin/debuggerd64");
     }

     /* Surface flinger is always there */
     public void testSurfaceflingerDomain() throws FileNotFoundException {
         assertDomainOne("u:r:surfaceflinger:s0", "/system/bin/surfaceflinger");
     }

     /* Zygote is always running */
     public void testZygoteDomain() throws FileNotFoundException {
         assertDomainN("u:r:zygote:s0", "zygote", "zygote64");
     }

     /* drm server is always present */
     public void testDrmServerDomain() throws FileNotFoundException {
         assertDomainZeroOrOne("u:r:drmserver:s0", "/system/bin/drmserver");
     }

     /* Media server is always running */
     public void testMediaserverDomain() throws FileNotFoundException {
         assertDomainN("u:r:mediaserver:s0", "media.log", "/system/bin/mediaserver");
     }

     /* Installd is always running */
     public void testInstalldDomain() throws FileNotFoundException {
         assertDomainOne("u:r:installd:s0", "/system/bin/installd");
     }

     /* keystore is always running */
     public void testKeystoreDomain() throws FileNotFoundException {
         assertDomainOne("u:r:keystore:s0", "/system/bin/keystore");
     }

     /* System server better be running :-P */
     public void testSystemServerDomain() throws FileNotFoundException {
         assertDomainOne("u:r:system_server:s0", "system_server");
     }

     /*
      * Some OEMs do not use sdcardd so transient. Other OEMs have multiple sdcards
      * so they run the daemon multiple times.
      */
     public void testSdcarddDomain() throws FileNotFoundException {
         assertDomainHasExecutable("u:r:sdcardd:s0", "/system/bin/sdcard");
     }

     /* Watchdogd may or may not be there */
     public void testWatchdogdDomain() throws FileNotFoundException {
         assertDomainZeroOrOne("u:r:watchdogd:s0", "/sbin/watchdogd");
     }

     /* Wifi may be off so cardinality of 0 or 1 is ok */
     public void testWpaDomain() throws FileNotFoundException {
         assertDomainZeroOrOne("u:r:wpa:s0", "/system/bin/wpa_supplicant");
     }

     /*
      * Nothing should be running in this domain, cardinality test is all thats
      * needed
      */
     public void testInitShellDomain() throws FileNotFoundException {
         assertDomainEmpty("u:r:init_shell:s0");
     }

     /*
      * Nothing should be running in this domain, cardinality test is all thats
      * needed
      */
     public void testRecoveryDomain() throws FileNotFoundException {
         assertDomainEmpty("u:r:recovery:s0");
     }

     /*
      * Nothing should be running in this domain, cardinality test is all thats
      * needed
      */
     public void testSuDomain() throws FileNotFoundException {
         assertDomainEmpty("u:r:su:s0");
     }

     /*
      * Their will at least be some kernel thread running and all kthreads should
      * be in kernel context.
      */
     public void testKernelDomain() throws FileNotFoundException {
         String domain = "u:r:kernel:s0";
         List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
         assertNotNull(procs);
         for (ProcessDetails p : procs) {
             assertTrue("Non Kernel thread \"" + p + "\" found!", p.isKernel());
         }
     }

     private static class ProcessDetails {
         public String label;
         public String procTitle;
         public long vSize;
         public int pid;

         private ProcessDetails(String procTitle, String label, long vSize, int pid) {
             this.label = label;
             this.procTitle = procTitle;
             this.vSize = vSize;
             this.pid = pid;
         }

         @Override
         public String toString() {
             return "pid: \"" + pid + "\"\tproctitle: \"" + procTitle + "\"\tlabel: \"" + label
                     + "\"\tvsize: " + vSize;
         }

         public boolean isKernel() {
             return vSize == 0;
         }

         private static long getVsizeFromStat(String stat) {
             // Get the vSize, item #23 from the stat file
             //                   1        2             3   4    5    6    7      8    9   10   11
             String pattern = "^\\d+ \\(\\p{Print}*\\) \\w \\d+ \\d+ \\d+ \\d+ -?\\d+ \\d+ \\d+ \\d+ "
                 //  12   13   14   15   16   17     18     19   20   21   22    23
                 + "\\d+ \\d+ \\d+ \\d+ \\d+ \\d+ -?\\d+ -?\\d+ \\d+ \\d+ \\d+ (\\d+) .*$";

             Pattern p = Pattern.compile(pattern);
             Matcher m = p.matcher(stat);
             assertTrue("failed match: \"" + stat + "\"", m.matches());
             return Long.parseLong(m.group(1));
         }

         private static HashMap<String, ArrayList<ProcessDetails>> getProcessMap()
                 throws FileNotFoundException {

             HashMap<String, ArrayList<ProcessDetails>> map = new HashMap<String, ArrayList<ProcessDetails>>();

             File root = new File("/proc");
             if (!root.isDirectory()) {
                 throw new FileNotFoundException("/proc is not a directory!");
             }

             for (File f : root.listFiles()) {

                 // We only want the pid directory entries
                 if (!f.isDirectory()) {
                     continue;
                 }

                 int pid;
                 try {
                     pid = Integer.parseInt(f.getName());
                 } catch (NumberFormatException e) {
                     continue;
                 }

                 try {
                     ProcessDetails p = getProcessDetails(pid, f);
                     ArrayList<ProcessDetails> l = map.get(p.label);
                     if (l == null) {
                         l = new ArrayList<ProcessDetails>();
                         map.put(p.label, l);
                     }
                     l.add(p);
                 } catch (FileNotFoundException e) {
                     // sometimes processes go away while the test is running.
                     // Don't freak out if this happens
                 }
             }
             return map;
         }

         private static ProcessDetails getProcessDetails(int pid, File f) throws FileNotFoundException {
             Scanner tmp = null;
             String context;
             long vSize;
             try {
                 tmp = new Scanner(new File(f, "attr/current"));
                 // Get the context via attr/current
                 context = tmp.next();
                 context = context.trim();
             } finally {
                 if (tmp != null) {
                     tmp.close();
                     tmp = null;
                 }
             }

             try {
                 // Get the vSize, item #23 from the stat file
                 tmp = new Scanner(new File(f, "stat"));
                 String x = tmp.nextLine();
                 vSize = getVsizeFromStat(x);
             } finally {
                 if (tmp != null) {
                     tmp.close();
                     tmp = null;
                 }
             }

             StringBuilder sb = new StringBuilder();
             try {
                 tmp = new Scanner(new File(f, "cmdline"));

                 // Java's scanner tends to return oddly when handling
                 // long binary blobs. Probably some caching optimization.
                 while (tmp.hasNext()) {
                     sb.append(tmp.next().replace('\0', ' '));
                 }
             } finally {
                 if (tmp != null) {
                     tmp.close();
                 }
             }

             // At this point we build up a valid proctitle, then split
             // on whitespace to get the left portion. Which is either
             // package name or process executable path. This avoids
             // the comm 16 char width limitation and is limited to PAGE_SIZE
             String cmdline = sb.toString().trim();
             cmdline = cmdline.split("\\s+")[0];

             return new ProcessDetails(cmdline, context, vSize, pid);
         }

     }
 }
	/*
	* Copyright (C) 2014 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.
	*/

	package android.security.cts;

	import junit.framework.TestCase;
	import java.io.BufferedReader;
	import java.io.File;
	import java.io.IOException;
	import java.io.FileNotFoundException;
	import java.io.InputStreamReader;
	import java.lang.Runtime;
	import java.text.ParseException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;
	import java.util.Scanner;
	import java.util.Set;

	/**
	* Verify that the processes running within an SELinux domain are sane.
	*
	* TODO: Author the tests for the app contexts.
	*
	*/
	public class SELinuxDomainTest extends TestCase {

	/**
	* Asserts that no processes are running in a domain.
	*
	* @param domain
	* The domain or SELinux context to check.
	*/
	private void assertDomainEmpty(String domain) throws FileNotFoundException {
	List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
	String msg = "Expected no processes in SELinux domain \"" + domain + "\""
	+ " Found: \"" + procs + "\"";
	assertNull(msg, procs);
	}

	/**
	* Asserts that a domain exists and that only one, well defined, process is
	* running in that domain.
	*
	* @param domain
	* The domain or SELinux context to check.
	* @param executable
	* The path of the executable or application package name.
	*/
	private void assertDomainOne(String domain, String executable) throws FileNotFoundException {
	List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
	String msg = "Expected 1 process in SELinux domain \"" + domain + "\""
	+ " Found \"" + procs + "\"";
	assertNotNull(msg, procs);
	assertEquals(msg, 1, procs.size());

	msg = "Expected executable \"" + executable + "\" in SELinux domain \"" + domain + "\""
	+ "Found: \"" + procs + "\"";
	assertEquals(msg, executable, procs.get(0).procTitle);
	}

	/**
	* Asserts that a domain may exist. If a domain exists, the cardinality of
	* the domain is verified to be 1 and that the correct process is running in
	* that domain.
	*
	* @param domain
	* The domain or SELinux context to check.
	* @param executable
	* The path of the executable or application package name.
	*/
	private void assertDomainZeroOrOne(String domain, String executable)
	throws FileNotFoundException {
	List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
	if (procs == null) {
	/* not on all devices */
	return;
	}

	String msg = "Expected 1 process in SELinux domain \"" + domain + "\""
	+ " Found: \"" + procs + "\"";
	assertEquals(msg, 1, procs.size());

	msg = "Expected executable \"" + executable + "\" in SELinux domain \"" + domain + "\""
	+ "Found: \"" + procs.get(0) + "\"";
	assertEquals(msg, executable, procs.get(0).procTitle);
	}

	/**
	* Asserts that a domain must exist, and that the cardinality is greater
	* than or equal to 1.
	*
	* @param domain
	* The domain or SELinux context to check.
	* @param executables
	* The path of the allowed executables or application package names.
	*/
	private void assertDomainN(String domain, String... executables)
	throws FileNotFoundException {
	List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
	String msg = "Expected 1 or more processes in SELinux domain \"" + domain + "\""
	+ " Found \"" + procs + "\"";
	assertNotNull(msg, procs);

	Set<String> execList = new HashSet<String>(Arrays.asList(executables));

	for (ProcessDetails p : procs) {
	msg = "Expected one of \"" + execList + "\" in SELinux domain \"" + domain + "\""
	+ " Found: \"" + p + "\"";
	assertTrue(msg, execList.contains(p.procTitle));
	}
	}

	/**
	* Asserts that a domain, if it exists, is only running the listed executables.
	*
	* @param domain
	* The domain or SELinux context to check.
	* @param executables
	* The path of the allowed executables or application package names.
	*/
	private void assertDomainHasExecutable(String domain, String... executables)
	throws FileNotFoundException {
	List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
	if (procs == null) {
	return; // domain doesn't exist
	}

	Set<String> execList = new HashSet<String>(Arrays.asList(executables));

	for (ProcessDetails p : procs) {
	String msg = "Expected one of \"" + execList + "\" in SELinux domain \""
	+ domain + "\"" + " Found: \"" + p + "\"";
	assertTrue(msg, execList.contains(p.procTitle));
	}
	}

	/* Init is always there */
	public void testInitDomain() throws FileNotFoundException {
	assertDomainOne("u:r:init:s0", "/init");
	}

	/* Ueventd is always there */
	public void testUeventdDomain() throws FileNotFoundException {
	assertDomainOne("u:r:ueventd:s0", "/sbin/ueventd");
	}

	/* Devices always have healthd */
	public void testHealthdDomain() throws FileNotFoundException {
	assertDomainOne("u:r:healthd:s0", "/sbin/healthd");
	}

	/* Servicemanager is always there */
	public void testServicemanagerDomain() throws FileNotFoundException {
	assertDomainOne("u:r:servicemanager:s0", "/system/bin/servicemanager");
	}

	/* Vold is always there */
	public void testVoldDomain() throws FileNotFoundException {
	assertDomainOne("u:r:vold:s0", "/system/bin/vold");
	}

	/* netd is always there */
	public void testNetdDomain() throws FileNotFoundException {
	assertDomainOne("u:r:netd:s0", "/system/bin/netd");
	}

	/* Debuggerd is always there */
	public void testDebuggerdDomain() throws FileNotFoundException {
	assertDomainN("u:r:debuggerd:s0", "/system/bin/debuggerd", "/system/bin/debuggerd64");
	}

	/* Surface flinger is always there */
	public void testSurfaceflingerDomain() throws FileNotFoundException {
	assertDomainOne("u:r:surfaceflinger:s0", "/system/bin/surfaceflinger");
	}

	/* Zygote is always running */
	public void testZygoteDomain() throws FileNotFoundException {
	assertDomainN("u:r:zygote:s0", "zygote", "zygote64");
	}

	/* drm server is always present */
	public void testDrmServerDomain() throws FileNotFoundException {
	assertDomainZeroOrOne("u:r:drmserver:s0", "/system/bin/drmserver");
	}

	/* Media server is always running */
	public void testMediaserverDomain() throws FileNotFoundException {
	assertDomainN("u:r:mediaserver:s0", "media.log", "/system/bin/mediaserver");
	}

	/* Installd is always running */
	public void testInstalldDomain() throws FileNotFoundException {
	assertDomainOne("u:r:installd:s0", "/system/bin/installd");
	}

	/* keystore is always running */
	public void testKeystoreDomain() throws FileNotFoundException {
	assertDomainOne("u:r:keystore:s0", "/system/bin/keystore");
	}

	/* System server better be running :-P */
	public void testSystemServerDomain() throws FileNotFoundException {
	assertDomainOne("u:r:system_server:s0", "system_server");
	}

	/*
	* Some OEMs do not use sdcardd so transient. Other OEMs have multiple sdcards
	* so they run the daemon multiple times.
	*/
	public void testSdcarddDomain() throws FileNotFoundException {
	assertDomainHasExecutable("u:r:sdcardd:s0", "/system/bin/sdcard");
	}

	/* Watchdogd may or may not be there */
	public void testWatchdogdDomain() throws FileNotFoundException {
	assertDomainZeroOrOne("u:r:watchdogd:s0", "/sbin/watchdogd");
	}

	/* Wifi may be off so cardinality of 0 or 1 is ok */
	public void testWpaDomain() throws FileNotFoundException {
	assertDomainZeroOrOne("u:r:wpa:s0", "/system/bin/wpa_supplicant");
	}

	/*
	* Nothing should be running in this domain, cardinality test is all thats
	* needed
	*/
	public void testInitShellDomain() throws FileNotFoundException {
	assertDomainEmpty("u:r:init_shell:s0");
	}

	/*
	* Nothing should be running in this domain, cardinality test is all thats
	* needed
	*/
	public void testRecoveryDomain() throws FileNotFoundException {
	assertDomainEmpty("u:r:recovery:s0");
	}

	/*
	* Nothing should be running in this domain, cardinality test is all thats
	* needed
	*/
	public void testSuDomain() throws FileNotFoundException {
	assertDomainEmpty("u:r:su:s0");
	}

	/*
	* Their will at least be some kernel thread running and all kthreads should
	* be in kernel context.
	*/
	public void testKernelDomain() throws FileNotFoundException {
	String domain = "u:r:kernel:s0";
	List<ProcessDetails> procs = ProcessDetails.getProcessMap().get(domain);
	assertNotNull(procs);
	for (ProcessDetails p : procs) {
	assertTrue("Non Kernel thread \"" + p + "\" found!", p.isKernel());
	}
	}

	private static class ProcessDetails {
	public String label;
	public String procTitle;
	public long vSize;
	public int pid;

	private ProcessDetails(String procTitle, String label, long vSize, int pid) {
	this.label = label;
	this.procTitle = procTitle;
	this.vSize = vSize;
	this.pid = pid;
	}

	@Override
	public String toString() {
	return "pid: \"" + pid + "\"\tproctitle: \"" + procTitle + "\"\tlabel: \"" + label
	+ "\"\tvsize: " + vSize;
	}

	public boolean isKernel() {
	return vSize == 0;
	}

	private static long getVsizeFromStat(String stat) {
	// Get the vSize, item #23 from the stat file
	// 1 2 3 4 5 6 7 8 9 10 11
	String pattern = "^\\d+ \\(\\p{Print}*\\) \\w \\d+ \\d+ \\d+ \\d+ -?\\d+ \\d+ \\d+ \\d+ "
	// 12 13 14 15 16 17 18 19 20 21 22 23
	+ "\\d+ \\d+ \\d+ \\d+ \\d+ \\d+ -?\\d+ -?\\d+ \\d+ \\d+ \\d+ (\\d+) .*$";

	Pattern p = Pattern.compile(pattern);
	Matcher m = p.matcher(stat);
	assertTrue("failed match: \"" + stat + "\"", m.matches());
	return Long.parseLong(m.group(1));
	}

	private static HashMap<String, ArrayList<ProcessDetails>> getProcessMap()
	throws FileNotFoundException {

	HashMap<String, ArrayList<ProcessDetails>> map = new HashMap<String, ArrayList<ProcessDetails>>();

	File root = new File("/proc");
	if (!root.isDirectory()) {
	throw new FileNotFoundException("/proc is not a directory!");
	}

	for (File f : root.listFiles()) {

	// We only want the pid directory entries
	if (!f.isDirectory()) {
	continue;
	}

	int pid;
	try {
	pid = Integer.parseInt(f.getName());
	} catch (NumberFormatException e) {
	continue;
	}

	try {
	ProcessDetails p = getProcessDetails(pid, f);
	ArrayList<ProcessDetails> l = map.get(p.label);
	if (l == null) {
	l = new ArrayList<ProcessDetails>();
	map.put(p.label, l);
	}
	l.add(p);
	} catch (FileNotFoundException e) {
	// sometimes processes go away while the test is running.
	// Don't freak out if this happens
	}
	}
	return map;
	}

	private static ProcessDetails getProcessDetails(int pid, File f) throws FileNotFoundException {
	Scanner tmp = null;
	String context;
	long vSize;
	try {
	tmp = new Scanner(new File(f, "attr/current"));
	// Get the context via attr/current
	context = tmp.next();
	context = context.trim();
	} finally {
	if (tmp != null) {
	tmp.close();
	tmp = null;
	}
	}

	try {
	// Get the vSize, item #23 from the stat file
	tmp = new Scanner(new File(f, "stat"));
	String x = tmp.nextLine();
	vSize = getVsizeFromStat(x);
	} finally {
	if (tmp != null) {
	tmp.close();
	tmp = null;
	}
	}

	StringBuilder sb = new StringBuilder();
	try {
	tmp = new Scanner(new File(f, "cmdline"));

	// Java's scanner tends to return oddly when handling
	// long binary blobs. Probably some caching optimization.
	while (tmp.hasNext()) {
	sb.append(tmp.next().replace('\0', ' '));
	}
	} finally {
	if (tmp != null) {
	tmp.close();
	}
	}

	// At this point we build up a valid proctitle, then split
	// on whitespace to get the left portion. Which is either
	// package name or process executable path. This avoids
	// the comm 16 char width limitation and is limited to PAGE_SIZE
	String cmdline = sb.toString().trim();
	cmdline = cmdline.split("\\s+")[0];

	return new ProcessDetails(cmdline, context, vSize, pid);
	}

	}
	}