src/util/os_priority.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2002, 2003, 2004, 2005, 2006 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file util/os/priority.c
  23  * @brief Methods to set process priority
  24  * @author Nils Durner
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_os_lib.h"
  30
  31 /**
  32  * Set our process priority
  33  */
  34 int
  35 GNUNET_OS_set_process_priority (pid_t proc,
  36                                 enum GNUNET_SCHEDULER_Priority eprio)
  37 {
  38   int prio = 0;
  39
  40   GNUNET_assert (eprio < GNUNET_SCHEDULER_PRIORITY_COUNT);
  41   if (eprio == GNUNET_SCHEDULER_PRIORITY_KEEP)
  42     return GNUNET_OK;
  43   /* convert to MINGW/Unix values */
  44   switch (eprio)
  45     {
  46     case GNUNET_SCHEDULER_PRIORITY_DEFAULT:
  47 #ifdef MINGW
  48       prio = NORMAL_PRIORITY_CLASS;
  49 #else
  50       prio = 0;
  51 #endif
  52       break;
  53     case GNUNET_SCHEDULER_PRIORITY_HIGH:
  54 #ifdef MINGW
  55       prio = ABOVE_NORMAL_PRIORITY_CLASS;
  56 #else
  57       prio = -5;
  58 #endif
  59       break;
  60     case GNUNET_SCHEDULER_PRIORITY_BACKGROUND:
  61 #ifdef MINGW
  62       prio = BELOW_NORMAL_PRIORITY_CLASS;
  63 #else
  64       prio = 10;
  65 #endif
  66       break;
  67     case GNUNET_SCHEDULER_PRIORITY_UI:
  68     case GNUNET_SCHEDULER_PRIORITY_URGENT:
  69 #ifdef MINGW
  70       prio = HIGH_PRIORITY_CLASS;
  71 #else
  72       prio = -10;
  73 #endif
  74       break;
  75     case GNUNET_SCHEDULER_PRIORITY_IDLE:
  76 #ifdef MINGW
  77       prio = IDLE_PRIORITY_CLASS;
  78 #else
  79       prio = 19;
  80 #endif
  81       break;
  82     default:
  83       GNUNET_assert (0);
  84       return GNUNET_SYSERR;
  85     }
  86   /* Set process priority */
  87 #ifdef MINGW
  88   SetPriorityClass (GetCurrentProcess (), prio);
  89 #else
  90   if (proc == getpid ())
  91     {
  92       errno = 0;
  93       if ((-1 == nice (prio)) && (errno != 0))
  94         {
  95           GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
  96                                GNUNET_ERROR_TYPE_BULK, "nice");
  97           return GNUNET_SYSERR;
  98         }
  99     }
 100   else
 101     {
 102       if (0 != setpriority (PRIO_PROCESS, proc, prio))
 103
 104         {
 105           GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
 106                                GNUNET_ERROR_TYPE_BULK, "setpriority");
 107           return GNUNET_SYSERR;
 108         }
 109     }
 110 #endif
 111   return GNUNET_OK;
 112 }
 113
 114
 115
 116 /**
 117  * Start a process.
 118  *
 119  * @param filename name of the binary
 120  * @param ... NULL-terminated list of arguments to the process
 121  * @return process ID of the new process, -1 on error
 122  */
 123 pid_t
 124 GNUNET_OS_start_process (const char *filename, ...)
 125 {
 126   va_list ap;
 127
 128 #ifndef MINGW
 129   pid_t ret;
 130   char **argv;
 131   int argc;
 132
 133   ret = fork ();
 134   if (ret != 0)
 135     {
 136       if (ret == -1)
 137         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
 138       return ret;
 139     }
 140   argc = 0;
 141   va_start (ap, filename);
 142   while (NULL != va_arg (ap, char *))
 143       argc++;
 144   va_end (ap);
 145   argv = GNUNET_malloc (sizeof (char *) * (argc + 1));
 146   argc = 0;
 147   va_start (ap, filename);
 148   while (NULL != (argv[argc] = va_arg (ap, char *)))
 149       argc++;
 150   va_end (ap);
 151   execvp (filename, argv);
 152   GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
 153   exit (1);
 154 #else
 155   char *arg;
 156   unsigned int cmdlen;
 157   char *cmd, *idx;
 158   STARTUPINFO start;
 159   PROCESS_INFORMATION proc;
 160
 161   cmdlen = 0;
 162   va_start (ap, filename);
 163   while (NULL != (arg = va_arg (ap, char *)))
 164     cmdlen = cmdlen + strlen (arg) + 3;
 165   va_end (ap);
 166
 167   cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
 168   va_start (ap, filename);
 169   while (NULL != (arg = va_arg (ap, char *)))
 170     idx += sprintf (idx, "\"%s\" ", arg);
 171   va_end (ap);
 172
 173   memset (&start, 0, sizeof(start));
 174   start.cb = sizeof(start);
 175
 176   if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
 177       NULL, &start, &proc))
 178   {
 179     SetErrnoFromWinError (GetLastError ());
 180     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
 181     return -1;
 182   }
 183   CloseHandle (proc.hProcess);
 184   CloseHandle (proc.hThread);
 185
 186   GNUNET_free(cmd);
 187
 188   return proc.dwProcessId;
 189 #endif
 190 }
 191
 192
 193
 194
 195 /**
 196  * Start a process.
 197  *
 198  * @param filename name of the binary
 199  * @param argv NULL-terminated list of arguments to the process
 200  * @return process ID of the new process, -1 on error
 201  */
 202 pid_t
 203 GNUNET_OS_start_process_v (const char *filename, char *const argv[])
 204 {
 205 #ifndef MINGW
 206   pid_t ret;
 207
 208   ret = fork ();
 209   if (ret != 0)
 210     {
 211       if (ret == -1)
 212         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
 213       return ret;
 214     }
 215   execvp (filename, argv);
 216   GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
 217   exit (1);
 218 #else
 219   char **arg;
 220   unsigned int cmdlen;
 221   char *cmd, *idx;
 222   STARTUPINFO start;
 223   PROCESS_INFORMATION proc;
 224
 225   cmdlen = 0;
 226   arg = argv;
 227   while (*arg)
 228   {
 229     cmdlen = cmdlen + strlen (*arg) + 3;
 230     arg++;
 231   }
 232
 233   cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
 234   arg = argv;
 235   while (*arg)
 236   {
 237     idx += sprintf (idx, "\"%s\" ", *arg);
 238     arg++;
 239   }
 240
 241   memset (&start, 0, sizeof(start));
 242   start.cb = sizeof(start);
 243
 244   if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
 245       NULL, &start, &proc))
 246   {
 247     SetErrnoFromWinError (GetLastError ());
 248     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
 249     return -1;
 250   }
 251   CloseHandle (proc.hProcess);
 252   CloseHandle (proc.hThread);
 253
 254   GNUNET_free(cmd);
 255
 256   return proc.dwProcessId;
 257 #endif
 258 }
 259
 260
 261
 262
 263
 264
 265 /* end of os_priority.c */