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  * Retrieve the status of a process
 262  * @param proc process ID
 263  * @param type status type
 264  * @param code return code/signal number
 265  * @return GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise
 266  */
 267 int
 268 GNUNET_OS_process_status (pid_t proc, enum GNUNET_OS_ProcessStatusType *type,
 269     unsigned long *code)
 270 {
 271 #ifndef MINGW
 272   int status;
 273   int ret;
 274
 275   GNUNET_assert (0 != proc);
 276   ret = waitpid (proc, &status, WNOHANG);
 277   if ( (0 == ret) ||
 278        ( (-1 == ret) &&
 279          (ECHILD == errno) ) )
 280     {
 281       *type = GNUNET_OS_PROCESS_RUNNING;
 282       *code = 0;
 283       return GNUNET_NO;
 284     }
 285   if (proc != ret)
 286     {
 287       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
 288       return GNUNET_SYSERR;
 289     }
 290   if (WIFEXITED (status))
 291   {
 292     *type = GNUNET_OS_PROCESS_EXITED;
 293     *code = WEXITSTATUS (status);
 294   }
 295   else if (WIFSIGNALED (status))
 296   {
 297     *type = GNUNET_OS_PROCESS_SIGNALED;
 298     *code = WTERMSIG (status);
 299   }
 300   else if (WIFSTOPPED (status))
 301   {
 302     *type = GNUNET_OS_PROCESS_SIGNALED;
 303     *code = WSTOPSIG (status);
 304   }
 305   else if (WIFCONTINUED (status))
 306   {
 307     *type = GNUNET_OS_PROCESS_RUNNING;
 308     *code = 0;
 309   }
 310   else
 311   {
 312     *type = GNUNET_OS_PROCESS_UNKNOWN;
 313     *code = 0;
 314   }
 315 #else
 316   HANDLE h;
 317   DWORD c;
 318
 319   h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
 320   if (INVALID_HANDLE_VALUE == h)
 321   {
 322     SetErrnoFromWinError (GetLastError ());
 323     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "OpenProcess");
 324     return GNUNET_SYSERR;
 325   }
 326
 327   c = GetExitCodeProcess (proc, &c);
 328   if (STILL_ACTIVE == c)
 329   {
 330     *type = GNUNET_OS_PROCESS_RUNNING;
 331     *code = 0;
 332     CloseHandle (h);
 333     return GNUNET_NO;
 334   }
 335   *type = GNUNET_OS_PROCESS_EXITED;
 336   *code = c;
 337   CloseHandle (h);
 338 #endif
 339
 340   return GNUNET_OK;
 341 }
 342
 343 /**
 344  * Wait for a process
 345  * @param proc process ID to wait for
 346  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
 347  */
 348 int
 349 GNUNET_OS_process_wait (pid_t proc)
 350 {
 351 #ifndef MINGW
 352   if (proc != waitpid (proc, NULL, 0))
 353     return GNUNET_SYSERR;
 354
 355   return GNUNET_OK;
 356 #else
 357   HANDLE h;
 358   DWORD c;
 359   int ret;
 360
 361   h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
 362   if (INVALID_HANDLE_VALUE == h)
 363   {
 364     SetErrnoFromWinError (GetLastError ());
 365     return GNUNET_SYSERR;
 366   }
 367
 368   if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
 369   {
 370     SetErrnoFromWinError (GetLastError ());
 371     ret = GNUNET_SYSERR;
 372   }
 373   else
 374     ret = GNUNET_OK;
 375
 376   CloseHandle (h);
 377
 378   return ret;
 379 #endif
 380 }
 381
 382
 383 /* end of os_priority.c */