tests/sdcard/sysutil.cpp - platform/system/extras - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *  * Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */

 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include "sysutil.h"

 namespace {
 const int kError = -1;
 // Max number of retries on EAGAIN and EINTR. Totally arbitrary.
 const int kMaxAttempts = 8;

 // How long to wait after a cache purge. A few seconds (arbitrary).
 const int kCachePurgeSleepDuration = 2; // seconds

 const bool kSilentIfMissing = false;

 const char *kKernelVersion = "/proc/version";
 const char *kScalingGovernorFormat = "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_governor";
 const char *kDropCaches = "/proc/sys/vm/drop_caches";
 const char *kSchedFeatures = "/sys/kernel/debug/sched_features";
 const char *kNewFairSleepers = "NEW_FAIR_SLEEPERS";
 const char *kNoNewFairSleepers = "NO_NEW_FAIR_SLEEPERS";
 const char *kNormalizedSleepers = "NORMALIZED_SLEEPER"; // no 's' at the end
 const char *kNoNormalizedSleepers = "NO_NORMALIZED_SLEEPER";

 const char *kDebugfsWarningMsg = "Did you 'adb root; adb shell mount -t debugfs none /sys/kernel/debug' ?";

 // TODO: Surely these file utility functions must exist already. A
 // quick grep did not turn up anything. Look harder later.

 void printErrno(const char *msg, const char *filename)
 {
     fprintf(stderr, "# %s %s %d %s\n", msg, filename, errno, strerror(errno));
 }

 // Read a C-string from a file.  If the buffer is too short, an error
 // message will be printed on stderr.
 // @param filename Of the file to read.
 // @param start    Buffer where the data should be written to.
 // @param size     The size of the buffer pointed by str. Must be >= 1.
 // @return The number of characters read (not including the trailing'\0' used
 //         to end the string) or -1 if there was an error.
 int readStringFromFile(const char *filename, char *const start, size_t size, bool must_exist=true)
 {
     if (NULL == start || size == 0)
     {
         return 0;
     }
     char *end = start;
     int fd = open(filename, O_RDONLY);

     if (fd < 0)
     {
         if (ENOENT != errno || must_exist)
         {
             printErrno("Failed to open", filename);
         }
         return kError;
     }

     bool eof = false;
     bool error = false;
     int attempts = 0;

     --size; // reserve space for trailing '\0'

     while (size > 0 && !error && !eof && attempts < kMaxAttempts)
     {
         ssize_t s;

         s = read(fd, end, size);

         if (s < 0)
         {
             error = EAGAIN != errno && EINTR != errno;
             if (error)
             {
                 printErrno("Failed to read", filename);
             }
         }
         else if (0 == s)
         {
             eof = true;
         }
         else
         {
             end += s;
             size -= s;
         }
         ++attempts;
     }

     close(fd);

     if (error)
     {
         return kError;
     }
     else
     {
         *end = '\0';
         if (!eof)
         {
             fprintf(stderr, "Buffer too small for %s\n", filename);
         }
         return end - start;
     }
 }

 // Write a C string ('\0' terminated) to a file.
 //
 int writeStringToFile(const char *filename, const char *start, bool must_exist=true)
 {
     int fd = open(filename, O_WRONLY);


     if (fd < 0)
     {
         if (ENOENT != errno || must_exist)
         {
             printErrno("Failed to open", filename);
         }
         return kError;
     }

     const size_t len = strlen(start);
     size_t size = len;
     bool error = false;
     int attempts = 0;

     while (size > 0 && !error && attempts < kMaxAttempts)
     {
         ssize_t s = write(fd, start, size);

         if (s < 0)
         {
             error = EAGAIN != errno && EINTR != errno;
             if (error)
             {
                 printErrno("Failed to write", filename);
             }
         }
         else
         {
             start += s;
             size -= s;
         }
         ++attempts;
     }
     close(fd);

     if (error)
     {
         return kError;
     }
     else
     {
         if (size > 0)
         {
             fprintf(stderr, "Partial write to %s (%d out of %d)\n",
                     filename, size, len);
         }
         return len - size;
     }
 }

 int writeIntToFile(const char *filename, long value)
 {
     char buffer[16] = {0,};
     sprintf(buffer, "%ld", value);
     return writeStringToFile(filename, buffer);
 }

 // @return a message describing the reason why the child exited. The
 // message is in a shared buffer, not thread safe, erased by
 // subsequent calls.
 const char *reasonChildExited(int status)
 {
     static char buffer[80];

     if (WIFEXITED(status))
     {
         snprintf(buffer, sizeof(buffer), "ok (%d)",  WEXITSTATUS(status));
     }
     else if (WIFSIGNALED(status))
     {
         snprintf(buffer, sizeof(buffer), "signaled (%d %s)",  WTERMSIG(status), strsignal(WTERMSIG(status)));
     }
     else
     {
         snprintf(buffer, sizeof(buffer), "stopped?");
     }
     return buffer;
 }


 }  // anonymous namespace

 namespace android {

 int kernelVersion(char *str, size_t size)
 {
     return readStringFromFile(kKernelVersion, str, size);
 }

 int pidOutOfMemoryAdj()
 {
     char filename[FILENAME_MAX];

     snprintf(filename, sizeof(filename), "/proc/%d/oom_adj", getpid());

     char value[16];
     if (readStringFromFile(filename, value, sizeof(value)) == -1)
     {
         return -127;
     }
     else
     {
         return atoi(value);
     }
 }

 void setPidOutOfMemoryAdj(int level)
 {
     char filename[FILENAME_MAX];

     snprintf(filename, sizeof(filename), "/proc/%d/oom_adj", getpid());
     writeIntToFile(filename, level);
 }

 void disableCpuScaling()
 {
     for (int cpu = 0; cpu < 16; ++cpu) // 16 cores mobile phones, abestos pockets recommended.
     {
         char governor[FILENAME_MAX];
         sprintf(governor, kScalingGovernorFormat, cpu);

         if (writeStringToFile(governor, "performance", kSilentIfMissing) < 0)
         {
             if (cpu > 0 && errno == ENOENT)
             {
                 break;  // cpu1 or above not found, ok since we have cpu0.
             }
             fprintf(stderr, "Failed to write to scaling governor file for cpu %d: %d %s",
                     cpu, errno, strerror(errno));
             break;
         }
     }
 }

 int schedFeatures(char *str, size_t size)
 {
     return readStringFromFile(kSchedFeatures, str, size);
 }

 bool newFairSleepers()
 {
     char value[256] = {0,};

     if (readStringFromFile(kSchedFeatures, value, sizeof(value)) == -1)
     {
         printErrno(kDebugfsWarningMsg, kSchedFeatures);
         return false;
     }
     return strstr(value, "NO_NEW_FAIR_SLEEPERS") == NULL;
 }

 void setNewFairSleepers(bool on)
 {
     int retcode;

     if (on)
     {
         retcode = writeStringToFile(kSchedFeatures, kNewFairSleepers);
     }
     else
     {
         retcode = writeStringToFile(kSchedFeatures, kNoNewFairSleepers);
     }
     if (retcode < 0)
     {
         fprintf(stderr, "# %s\n", kDebugfsWarningMsg);
     }
 }

 bool normalizedSleepers()
 {
     char value[256] = {0,};

     if (readStringFromFile(kSchedFeatures, value, sizeof(value)) == -1)
     {
         printErrno(kDebugfsWarningMsg, kSchedFeatures);
         return false;
     }
     return strstr(value, "NO_NEW_FAIR_SLEEPERS") == NULL;
 }

 void setNormalizedSleepers(bool on)
 {
     int retcode;

     if (on)
     {
         retcode = writeStringToFile(kSchedFeatures, kNormalizedSleepers);
     }
     else
     {
         retcode = writeStringToFile(kSchedFeatures, kNoNormalizedSleepers);
     }
     if (retcode < 0)
     {
         fprintf(stderr, "# %s\n", kDebugfsWarningMsg);
     }
 }

 pid_t forkOrExit()
 {
     pid_t childpid = fork();

     if (-1 == childpid)
     {
         fprintf(stderr, "Fork failed: %d %s", errno, strerror(errno));
         exit(EXIT_FAILURE);
     }
     return childpid;
 }

 void waitForChildrenOrExit(int num)
 {
     while (num > 0)
     {
         int status;
         pid_t pid = wait(&status);
         if (-1 == pid)
         {
             fprintf(stderr, "Wait failed\n");
         }
         else
         {
             if (!WIFEXITED(status))
             {
                 fprintf(stderr, "Child pid %d did not exit cleanly %s\n",
                         pid, reasonChildExited(status));
                 exit(EXIT_FAILURE);
             }
         }
         --num;
     }
 }

 // Sync and cache cleaning functions.  In the old hpux days I was told
 // to always call *sync twice. The same advice seems to be still true
 // today so *sync is called twice.
 // Also we wait 'a little' to give a chance to background threads to
 // purge their caches.
 void syncAndDropCaches(int code)
 {
     sync();
     sync();
     writeIntToFile(kDropCaches, code);
     sleep(kCachePurgeSleepDuration);
 }


 void fsyncAndDropCaches(int fd, int code)
 {
     fsync(fd);
     fsync(fd);
     writeIntToFile(kDropCaches, code);
     sleep(kCachePurgeSleepDuration);
 }


 void resetDirectory(const char *directory)
 {
     DIR *dir = opendir(directory);

     if (NULL != dir)
     {
         struct dirent *entry;
         char name_buffer[PATH_MAX];

         while((entry = readdir(dir)))
         {
             if (0 == strcmp(entry->d_name, ".")
                 || 0 == strcmp(entry->d_name, "..")
                 || 0 == strcmp(entry->d_name, "lost+found"))
             {
                 continue;
             }
             strcpy(name_buffer, directory);
             strcat(name_buffer, "/");
             strcat(name_buffer, entry->d_name);
             unlink(name_buffer);
         }
         closedir(dir);
     } else {
         mkdir(directory, S_IRWXU);
     }
 }


 // IPC
 bool writePidAndWaitForReply(int writefd, int readfd)
 {
     if (writefd > readfd)
     {
         fprintf(stderr, "Called with args in wrong order!!\n");
         return false;
     }
     pid_t pid = getpid();
     char *start = reinterpret_cast<char *>(&pid);
     size_t size = sizeof(pid);
     bool error = false;
     int attempts = 0;

     while (size > 0 && !error && attempts < kMaxAttempts)
     {
         ssize_t s = write(writefd, start, size);

         if (s < 0)
         {
             error = EAGAIN != errno && EINTR != errno;
             if (error)
             {
                 printErrno("Failed to write", "parent");
             }
         }
         else
         {
             start += s;
             size -= s;
         }
         ++attempts;
     }

     if (error || 0 != size)
     {
         return false;
     }

     bool eof = false;
     char dummy;
     size = sizeof(dummy);
     error = false;
     attempts = 0;

     while (size > 0 && !error && !eof && attempts < kMaxAttempts)
     {
         ssize_t s;

         s = read(readfd, &dummy, size);

         if (s < 0)
         {
             error = EAGAIN != errno && EINTR != errno;
             if (error)
             {
                 printErrno("Failed to read", "parent");
             }
         }
         else if (0 == s)
         {
             eof = true;
         }
         else
         {
             size -= s;
         }
         ++attempts;
     }
     if (error || 0 != size)
     {
         return false;
     }
     return true;
 }


 bool waitForChildrenAndSignal(int mProcessNb, int readfd, int writefd)
 {
     if (readfd > writefd)
     {
         fprintf(stderr, "Called with args in wrong order!!\n");
         return false;
     }

     bool error;
     int attempts;
     size_t size;

     for (int p = 0; p < mProcessNb; ++p)
     {
         bool eof = false;
         pid_t pid;
         char *end = reinterpret_cast<char *>(&pid);

         error = false;
         attempts = 0;
         size = sizeof(pid);

         while (size > 0 && !error && !eof && attempts < kMaxAttempts)
         {
             ssize_t s;

             s = read(readfd, end, size);

             if (s < 0)
             {
                 error = EAGAIN != errno && EINTR != errno;
                 if (error)
                 {
                     printErrno("Failed to read", "child");
                 }
             }
             else if (0 == s)
             {
                 eof = true;
             }
             else
             {
                 end += s;
                 size -= s;
             }
             ++attempts;
         }

         if (error || 0 != size)
         {
             return false;
         }
     }

     for (int p = 0; p < mProcessNb; ++p)
     {
         char dummy;

         error = false;
         attempts = 0;
         size = sizeof(dummy);

         while (size > 0 && !error && attempts < kMaxAttempts)
         {
             ssize_t s = write(writefd, &dummy, size);

             if (s < 0)
             {
                 error = EAGAIN != errno && EINTR != errno;
                 if (error)
                 {
                     printErrno("Failed to write", "child");
                 }
             }
             else
             {
                 size -= s;
             }
             ++attempts;
         }

         if (error || 0 != size)
         {
             return false;
         }
     }
     return true;
 }

 }  // namespace android
	/*
	* Copyright (C) 2009 The Android Open Source Project
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	*/

	#include <dirent.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	#include <unistd.h>
	#include "sysutil.h"

	namespace {
	const int kError = -1;
	// Max number of retries on EAGAIN and EINTR. Totally arbitrary.
	const int kMaxAttempts = 8;

	// How long to wait after a cache purge. A few seconds (arbitrary).
	const int kCachePurgeSleepDuration = 2; // seconds

	const bool kSilentIfMissing = false;

	const char *kKernelVersion = "/proc/version";
	const char *kScalingGovernorFormat = "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_governor";
	const char *kDropCaches = "/proc/sys/vm/drop_caches";
	const char *kSchedFeatures = "/sys/kernel/debug/sched_features";
	const char *kNewFairSleepers = "NEW_FAIR_SLEEPERS";
	const char *kNoNewFairSleepers = "NO_NEW_FAIR_SLEEPERS";
	const char *kNormalizedSleepers = "NORMALIZED_SLEEPER"; // no 's' at the end
	const char *kNoNormalizedSleepers = "NO_NORMALIZED_SLEEPER";

	const char *kDebugfsWarningMsg = "Did you 'adb root; adb shell mount -t debugfs none /sys/kernel/debug' ?";

	// TODO: Surely these file utility functions must exist already. A
	// quick grep did not turn up anything. Look harder later.

	void printErrno(const char msg, const char filename)
	{
	fprintf(stderr, "# %s %s %d %s\n", msg, filename, errno, strerror(errno));
	}

	// Read a C-string from a file. If the buffer is too short, an error
	// message will be printed on stderr.
	// @param filename Of the file to read.
	// @param start Buffer where the data should be written to.
	// @param size The size of the buffer pointed by str. Must be >= 1.
	// @return The number of characters read (not including the trailing'\0' used
	// to end the string) or -1 if there was an error.
	int readStringFromFile(const char filename, char const start, size_t size, bool must_exist=true)
	{
	if (NULL == start \|\| size == 0)
	{
	return 0;
	}
	char *end = start;
	int fd = open(filename, O_RDONLY);

	if (fd < 0)
	{
	if (ENOENT != errno \|\| must_exist)
	{
	printErrno("Failed to open", filename);
	}
	return kError;
	}

	bool eof = false;
	bool error = false;
	int attempts = 0;

	--size; // reserve space for trailing '\0'

	while (size > 0 && !error && !eof && attempts < kMaxAttempts)
	{
	ssize_t s;

	s = read(fd, end, size);

	if (s < 0)
	{
	error = EAGAIN != errno && EINTR != errno;
	if (error)
	{
	printErrno("Failed to read", filename);
	}
	}
	else if (0 == s)
	{
	eof = true;
	}
	else
	{
	end += s;
	size -= s;
	}
	++attempts;
	}

	close(fd);

	if (error)
	{
	return kError;
	}
	else
	{
	*end = '\0';
	if (!eof)
	{
	fprintf(stderr, "Buffer too small for %s\n", filename);
	}
	return end - start;
	}
	}

	// Write a C string ('\0' terminated) to a file.
	//
	int writeStringToFile(const char filename, const char start, bool must_exist=true)
	{
	int fd = open(filename, O_WRONLY);


	if (fd < 0)
	{
	if (ENOENT != errno \|\| must_exist)
	{
	printErrno("Failed to open", filename);
	}
	return kError;
	}

	const size_t len = strlen(start);
	size_t size = len;
	bool error = false;
	int attempts = 0;

	while (size > 0 && !error && attempts < kMaxAttempts)
	{
	ssize_t s = write(fd, start, size);

	if (s < 0)
	{
	error = EAGAIN != errno && EINTR != errno;
	if (error)
	{
	printErrno("Failed to write", filename);
	}
	}
	else
	{
	start += s;
	size -= s;
	}
	++attempts;
	}
	close(fd);

	if (error)
	{
	return kError;
	}
	else
	{
	if (size > 0)
	{
	fprintf(stderr, "Partial write to %s (%d out of %d)\n",
	filename, size, len);
	}
	return len - size;
	}
	}

	int writeIntToFile(const char *filename, long value)
	{
	char buffer[16] = {0,};
	sprintf(buffer, "%ld", value);
	return writeStringToFile(filename, buffer);
	}

	// @return a message describing the reason why the child exited. The
	// message is in a shared buffer, not thread safe, erased by
	// subsequent calls.
	const char *reasonChildExited(int status)
	{
	static char buffer[80];

	if (WIFEXITED(status))
	{
	snprintf(buffer, sizeof(buffer), "ok (%d)", WEXITSTATUS(status));
	}
	else if (WIFSIGNALED(status))
	{
	snprintf(buffer, sizeof(buffer), "signaled (%d %s)", WTERMSIG(status), strsignal(WTERMSIG(status)));
	}
	else
	{
	snprintf(buffer, sizeof(buffer), "stopped?");
	}
	return buffer;
	}


	} // anonymous namespace

	namespace android {

	int kernelVersion(char *str, size_t size)
	{
	return readStringFromFile(kKernelVersion, str, size);
	}

	int pidOutOfMemoryAdj()
	{
	char filename[FILENAME_MAX];

	snprintf(filename, sizeof(filename), "/proc/%d/oom_adj", getpid());

	char value[16];
	if (readStringFromFile(filename, value, sizeof(value)) == -1)
	{
	return -127;
	}
	else
	{
	return atoi(value);
	}
	}

	void setPidOutOfMemoryAdj(int level)
	{
	char filename[FILENAME_MAX];

	snprintf(filename, sizeof(filename), "/proc/%d/oom_adj", getpid());
	writeIntToFile(filename, level);
	}

	void disableCpuScaling()
	{
	for (int cpu = 0; cpu < 16; ++cpu) // 16 cores mobile phones, abestos pockets recommended.
	{
	char governor[FILENAME_MAX];
	sprintf(governor, kScalingGovernorFormat, cpu);

	if (writeStringToFile(governor, "performance", kSilentIfMissing) < 0)
	{
	if (cpu > 0 && errno == ENOENT)
	{
	break; // cpu1 or above not found, ok since we have cpu0.
	}
	fprintf(stderr, "Failed to write to scaling governor file for cpu %d: %d %s",
	cpu, errno, strerror(errno));
	break;
	}
	}
	}

	int schedFeatures(char *str, size_t size)
	{
	return readStringFromFile(kSchedFeatures, str, size);
	}

	bool newFairSleepers()
	{
	char value[256] = {0,};

	if (readStringFromFile(kSchedFeatures, value, sizeof(value)) == -1)
	{
	printErrno(kDebugfsWarningMsg, kSchedFeatures);
	return false;
	}
	return strstr(value, "NO_NEW_FAIR_SLEEPERS") == NULL;
	}

	void setNewFairSleepers(bool on)
	{
	int retcode;

	if (on)
	{
	retcode = writeStringToFile(kSchedFeatures, kNewFairSleepers);
	}
	else
	{
	retcode = writeStringToFile(kSchedFeatures, kNoNewFairSleepers);
	}
	if (retcode < 0)
	{
	fprintf(stderr, "# %s\n", kDebugfsWarningMsg);
	}
	}

	bool normalizedSleepers()
	{
	char value[256] = {0,};

	if (readStringFromFile(kSchedFeatures, value, sizeof(value)) == -1)
	{
	printErrno(kDebugfsWarningMsg, kSchedFeatures);
	return false;
	}
	return strstr(value, "NO_NEW_FAIR_SLEEPERS") == NULL;
	}

	void setNormalizedSleepers(bool on)
	{
	int retcode;

	if (on)
	{
	retcode = writeStringToFile(kSchedFeatures, kNormalizedSleepers);
	}
	else
	{
	retcode = writeStringToFile(kSchedFeatures, kNoNormalizedSleepers);
	}
	if (retcode < 0)
	{
	fprintf(stderr, "# %s\n", kDebugfsWarningMsg);
	}
	}

	pid_t forkOrExit()
	{
	pid_t childpid = fork();

	if (-1 == childpid)
	{
	fprintf(stderr, "Fork failed: %d %s", errno, strerror(errno));
	exit(EXIT_FAILURE);
	}
	return childpid;
	}

	void waitForChildrenOrExit(int num)
	{
	while (num > 0)
	{
	int status;
	pid_t pid = wait(&status);
	if (-1 == pid)
	{
	fprintf(stderr, "Wait failed\n");
	}
	else
	{
	if (!WIFEXITED(status))
	{
	fprintf(stderr, "Child pid %d did not exit cleanly %s\n",
	pid, reasonChildExited(status));
	exit(EXIT_FAILURE);
	}
	}
	--num;
	}
	}

	// Sync and cache cleaning functions. In the old hpux days I was told
	// to always call *sync twice. The same advice seems to be still true
	// today so *sync is called twice.
	// Also we wait 'a little' to give a chance to background threads to
	// purge their caches.
	void syncAndDropCaches(int code)
	{
	sync();
	sync();
	writeIntToFile(kDropCaches, code);
	sleep(kCachePurgeSleepDuration);
	}


	void fsyncAndDropCaches(int fd, int code)
	{
	fsync(fd);
	fsync(fd);
	writeIntToFile(kDropCaches, code);
	sleep(kCachePurgeSleepDuration);
	}


	void resetDirectory(const char *directory)
	{
	DIR *dir = opendir(directory);

	if (NULL != dir)
	{
	struct dirent *entry;
	char name_buffer[PATH_MAX];

	while((entry = readdir(dir)))
	{
	if (0 == strcmp(entry->d_name, ".")
	\|\| 0 == strcmp(entry->d_name, "..")
	\|\| 0 == strcmp(entry->d_name, "lost+found"))
	{
	continue;
	}
	strcpy(name_buffer, directory);
	strcat(name_buffer, "/");
	strcat(name_buffer, entry->d_name);
	unlink(name_buffer);
	}
	closedir(dir);
	} else {
	mkdir(directory, S_IRWXU);
	}
	}


	// IPC
	bool writePidAndWaitForReply(int writefd, int readfd)
	{
	if (writefd > readfd)
	{
	fprintf(stderr, "Called with args in wrong order!!\n");
	return false;
	}
	pid_t pid = getpid();
	char start = reinterpret_cast<char >(&pid);
	size_t size = sizeof(pid);
	bool error = false;
	int attempts = 0;

	while (size > 0 && !error && attempts < kMaxAttempts)
	{
	ssize_t s = write(writefd, start, size);

	if (s < 0)
	{
	error = EAGAIN != errno && EINTR != errno;
	if (error)
	{
	printErrno("Failed to write", "parent");
	}
	}
	else
	{
	start += s;
	size -= s;
	}
	++attempts;
	}

	if (error \|\| 0 != size)
	{
	return false;
	}

	bool eof = false;
	char dummy;
	size = sizeof(dummy);
	error = false;
	attempts = 0;

	while (size > 0 && !error && !eof && attempts < kMaxAttempts)
	{
	ssize_t s;

	s = read(readfd, &dummy, size);

	if (s < 0)
	{
	error = EAGAIN != errno && EINTR != errno;
	if (error)
	{
	printErrno("Failed to read", "parent");
	}
	}
	else if (0 == s)
	{
	eof = true;
	}
	else
	{
	size -= s;
	}
	++attempts;
	}
	if (error \|\| 0 != size)
	{
	return false;
	}
	return true;
	}



	bool waitForChildrenAndSignal(int mProcessNb, int readfd, int writefd)
	{
	if (readfd > writefd)
	{
	fprintf(stderr, "Called with args in wrong order!!\n");
	return false;
	}

	bool error;
	int attempts;
	size_t size;

	for (int p = 0; p < mProcessNb; ++p)
	{
	bool eof = false;
	pid_t pid;
	char end = reinterpret_cast<char >(&pid);

	error = false;
	attempts = 0;
	size = sizeof(pid);

	while (size > 0 && !error && !eof && attempts < kMaxAttempts)
	{
	ssize_t s;

	s = read(readfd, end, size);

	if (s < 0)
	{
	error = EAGAIN != errno && EINTR != errno;
	if (error)
	{
	printErrno("Failed to read", "child");
	}
	}
	else if (0 == s)
	{
	eof = true;
	}
	else
	{
	end += s;
	size -= s;
	}
	++attempts;
	}

	if (error \|\| 0 != size)
	{
	return false;
	}
	}

	for (int p = 0; p < mProcessNb; ++p)
	{
	char dummy;

	error = false;
	attempts = 0;
	size = sizeof(dummy);

	while (size > 0 && !error && attempts < kMaxAttempts)
	{
	ssize_t s = write(writefd, &dummy, size);

	if (s < 0)
	{
	error = EAGAIN != errno && EINTR != errno;
	if (error)
	{
	printErrno("Failed to write", "child");
	}
	}
	else
	{
	size -= s;
	}
	++attempts;
	}

	if (error \|\| 0 != size)
	{
	return false;
	}
	}
	return true;
	}

	} // namespace android