GNUnet  0.20.0
os_priority.c File Reference

Methods to set process priority. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "disk.h"
#include <unistr.h>
Include dependency graph for os_priority.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_OS_Process
 
struct  GNUNET_OS_CommandHandle
 Handle to a command. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "util-os-priority", __VA_ARGS__)
 
#define LOG_STRERROR(kind, syscall)    GNUNET_log_from_strerror (kind, "util-os-priority", syscall)
 
#define LOG_STRERROR_FILE(kind, syscall, filename)    GNUNET_log_from_strerror_file (kind, "util-os-priority", syscall, filename)
 
#define GNUNET_OS_CONTROL_PIPE   "GNUNET_OS_CONTROL_PIPE"
 

Functions

static void shutdown_pch (void *cls)
 This handler is called on shutdown to remove the pch. More...
 
static void parent_control_handler (void *cls)
 This handler is called when there are control data to be read on the pipe. More...
 
void GNUNET_OS_install_parent_control_handler (void *cls)
 Connects this process to its parent via pipe; essentially, the parent control handler will read signal numbers from the GNUNET_OS_CONTROL_PIPE (as given in an environment variable) and raise those signals. More...
 
struct GNUNET_OS_ProcessGNUNET_OS_process_current ()
 Get process structure for current process. More...
 
int GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
 Sends a signal to the process. More...
 
pid_t GNUNET_OS_process_get_pid (struct GNUNET_OS_Process *proc)
 Get the pid of the process in question. More...
 
void GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc)
 Cleans up process structure contents (OS-dependent) and deallocates it. More...
 
static void open_dev_null (int target_fd, int flags)
 Open '/dev/null' and make the result the given file descriptor. More...
 
static struct GNUNET_OS_Processstart_process (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const int *lsocks, const char *filename, char *const argv[])
 Start a process. More...
 
struct GNUNET_OS_ProcessGNUNET_OS_start_process_vap (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename, char *const argv[])
 Start a process. More...
 
struct GNUNET_OS_ProcessGNUNET_OS_start_process_va (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename, va_list va)
 Start a process. More...
 
struct GNUNET_OS_ProcessGNUNET_OS_start_process (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename,...)
 Start a process. More...
 
struct GNUNET_OS_ProcessGNUNET_OS_start_process_v (enum GNUNET_OS_InheritStdioFlags std_inheritance, const int *lsocks, const char *filename, char *const argv[])
 Start a process. More...
 
struct GNUNET_OS_ProcessGNUNET_OS_start_process_s (enum GNUNET_OS_InheritStdioFlags std_inheritance, const int *lsocks, const char *filename,...)
 Start a process. More...
 
static enum GNUNET_GenericReturnValue process_status (struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code, int options)
 Retrieve the status of a process, waiting on it if dead. More...
 
enum GNUNET_GenericReturnValue GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
 Retrieve the status of a process. More...
 
enum GNUNET_GenericReturnValue GNUNET_OS_process_wait_status (struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
 Retrieve the status of a process, waiting on it if dead. More...
 
enum GNUNET_GenericReturnValue GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
 Wait for a process to terminate. More...
 
void GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
 Stop/kill a command. More...
 
static void cmd_read (void *cls)
 Read from the process and call the line processor. More...
 
struct GNUNET_OS_CommandHandleGNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls, struct GNUNET_TIME_Relative timeout, const char *binary,...)
 Run the given command line and call the given function for each line of the output. More...
 

Variables

static struct GNUNET_OS_Process current_process
 Handle for 'this' process. More...
 
static struct GNUNET_SCHEDULER_Taskpch
 Handle for the parent_control_handler() Task. More...
 
static struct GNUNET_SCHEDULER_Taskspch
 Handle for the shutdown_pch() Task. More...
 

Detailed Description

Methods to set process priority.

Author
Nils Durner

Definition in file os_priority.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "util-os-priority", __VA_ARGS__)

Definition at line 33 of file os_priority.c.

◆ LOG_STRERROR

#define LOG_STRERROR (   kind,
  syscall 
)     GNUNET_log_from_strerror (kind, "util-os-priority", syscall)

Definition at line 35 of file os_priority.c.

◆ LOG_STRERROR_FILE

#define LOG_STRERROR_FILE (   kind,
  syscall,
  filename 
)     GNUNET_log_from_strerror_file (kind, "util-os-priority", syscall, filename)

Definition at line 38 of file os_priority.c.

◆ GNUNET_OS_CONTROL_PIPE

#define GNUNET_OS_CONTROL_PIPE   "GNUNET_OS_CONTROL_PIPE"

Definition at line 41 of file os_priority.c.

Function Documentation

◆ shutdown_pch()

static void shutdown_pch ( void *  cls)
static

This handler is called on shutdown to remove the pch.

Parameters
clsthe struct GNUNET_DISK_FileHandle of the control pipe

Definition at line 81 of file os_priority.c.

82 {
83  struct GNUNET_DISK_FileHandle *control_pipe = cls;
84 
86  pch = NULL;
87  GNUNET_DISK_file_close (control_pipe);
88  control_pipe = NULL;
89 }
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1308
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
static struct GNUNET_SCHEDULER_Task * pch
Handle for the parent_control_handler() Task.
Definition: os_priority.c:67
Handle used to access files (and pipes).

References GNUNET_DISK_file_close(), GNUNET_SCHEDULER_cancel(), and pch.

Referenced by GNUNET_OS_install_parent_control_handler().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ parent_control_handler()

static void parent_control_handler ( void *  cls)
static

This handler is called when there are control data to be read on the pipe.

Parameters
clsthe struct GNUNET_DISK_FileHandle of the control pipe

Definition at line 98 of file os_priority.c.

99 {
100  struct GNUNET_DISK_FileHandle *control_pipe = cls;
101  char sig;
102  char *pipe_fd;
103  ssize_t ret;
104 
105  pch = NULL;
106  ret = GNUNET_DISK_file_read (control_pipe, &sig, sizeof(sig));
107  if (sizeof(sig) != ret)
108  {
109  if (-1 == ret)
110  LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
111  LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing control pipe\n");
112  GNUNET_DISK_file_close (control_pipe);
113  control_pipe = NULL;
115  spch = NULL;
116  return;
117  }
118  pipe_fd = getenv (GNUNET_OS_CONTROL_PIPE);
119  GNUNET_assert ((NULL == pipe_fd) || (strlen (pipe_fd) <= 0));
121  "Got control code %d from parent via pipe %s\n",
122  sig,
123  pipe_fd);
125  control_pipe,
127  control_pipe);
128  GNUNET_SIGNAL_raise ((int) sig);
129 }
char * getenv()
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:622
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1656
void GNUNET_SIGNAL_raise(const int sig)
Raise the given signal by calling the installed signal handlers.
Definition: signal.c:98
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_OS_CONTROL_PIPE
Definition: os_priority.c:41
static void parent_control_handler(void *cls)
This handler is called when there are control data to be read on the pipe.
Definition: os_priority.c:98
static struct GNUNET_SCHEDULER_Task * spch
Handle for the shutdown_pch() Task.
Definition: os_priority.c:72
#define LOG(kind,...)
Definition: os_priority.c:33
#define LOG_STRERROR(kind, syscall)
Definition: os_priority.c:35

References getenv(), GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_read(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OS_CONTROL_PIPE, GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_cancel(), GNUNET_SIGNAL_raise(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, LOG_STRERROR, pch, ret, and spch.

Referenced by GNUNET_OS_install_parent_control_handler().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ open_dev_null()

static void open_dev_null ( int  target_fd,
int  flags 
)
static

Open '/dev/null' and make the result the given file descriptor.

Parameters
target_fddesired FD to point to /dev/null
flagsopen flags (O_RDONLY, O_WRONLY)

Definition at line 277 of file os_priority.c.

279 {
280  int fd;
281 
282  fd = open ("/dev/null", flags);
283  if (-1 == fd)
284  {
285  GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", "/dev/null");
286  return;
287  }
288  if (fd == target_fd)
289  return;
290  if (-1 == dup2 (fd, target_fd))
291  {
293  GNUNET_break (0 == close (fd));
294  return;
295  }
296  GNUNET_break (0 == close (fd));
297 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...

References GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_strerror, and GNUNET_log_strerror_file.

Referenced by start_process().

Here is the caller graph for this function:

◆ start_process()

static struct GNUNET_OS_Process* start_process ( enum GNUNET_OS_InheritStdioFlags  std_inheritance,
struct GNUNET_DISK_PipeHandle pipe_stdin,
struct GNUNET_DISK_PipeHandle pipe_stdout,
struct GNUNET_DISK_PipeHandle pipe_stderr,
const int *  lsocks,
const char *  filename,
char *const  argv[] 
)
static

Start a process.

Parameters
std_inheritancea set of GNUNET_OS_INHERIT_STD_* flags controlling which std handles of the parent are inherited by the child. pipe_stdin and pipe_stdout take priority over std_inheritance (when they are non-NULL).
pipe_stdinpipe to use to send input to child process (or NULL)
pipe_stdoutpipe to use to get output from child process (or NULL)
pipe_stderrpipe to use for stderr for child process (or NULL)
lsocksarray of listen sockets to dup systemd-style (or NULL); must be NULL on platforms where dup is not supported
filenamename of the binary
argvNULL-terminated list of arguments to the process
Returns
process ID of the new process, -1 on error

Definition at line 317 of file os_priority.c.

324 {
325  pid_t ret;
326  char fds[16];
327  struct GNUNET_OS_Process *gnunet_proc;
328  struct GNUNET_DISK_FileHandle *childpipe_read;
329  struct GNUNET_DISK_FileHandle *childpipe_write;
330  int childpipe_read_fd;
331  int i;
332  int j;
333  int k;
334  int tgt;
335  int flags;
336  int *lscp;
337  unsigned int ls;
338  int fd_stdout_write;
339  int fd_stdout_read;
340  int fd_stderr_write;
341  int fd_stderr_read;
342  int fd_stdin_read;
343  int fd_stdin_write;
344 
345  if (GNUNET_SYSERR ==
347  return NULL; /* not executable */
348  if (0 != (std_inheritance & GNUNET_OS_USE_PIPE_CONTROL))
349  {
350  struct GNUNET_DISK_PipeHandle *childpipe;
351  int dup_childpipe_read_fd = -1;
352 
354  if (NULL == childpipe)
355  return NULL;
356  childpipe_read =
358  childpipe_write =
360  GNUNET_DISK_pipe_close (childpipe);
361  if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
362  (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read,
363  &childpipe_read_fd,
364  sizeof(int))) ||
365  (-1 == (dup_childpipe_read_fd = dup (childpipe_read_fd))))
366  {
367  if (NULL != childpipe_read)
368  GNUNET_DISK_file_close (childpipe_read);
369  if (NULL != childpipe_write)
370  GNUNET_DISK_file_close (childpipe_write);
371  if (0 <= dup_childpipe_read_fd)
372  GNUNET_break (0 == close (dup_childpipe_read_fd));
373  return NULL;
374  }
375  childpipe_read_fd = dup_childpipe_read_fd;
376  GNUNET_DISK_file_close (childpipe_read);
377  }
378  else
379  {
380  childpipe_write = NULL;
381  childpipe_read_fd = -1;
382  }
383  if (NULL != pipe_stdin)
384  {
385  GNUNET_assert (
386  GNUNET_OK ==
389  &fd_stdin_read,
390  sizeof(int)));
391  GNUNET_assert (
392  GNUNET_OK ==
395  &fd_stdin_write,
396  sizeof(int)));
397  }
398  if (NULL != pipe_stdout)
399  {
400  GNUNET_assert (
401  GNUNET_OK ==
404  &fd_stdout_write,
405  sizeof(int)));
406  GNUNET_assert (
407  GNUNET_OK ==
410  &fd_stdout_read,
411  sizeof(int)));
412  }
413  if (NULL != pipe_stderr)
414  {
415  GNUNET_assert (
416  GNUNET_OK ==
419  &fd_stderr_read,
420  sizeof(int)));
421  GNUNET_assert (
422  GNUNET_OK ==
425  &fd_stderr_write,
426  sizeof(int)));
427  }
428  lscp = NULL;
429  ls = 0;
430  if (NULL != lsocks)
431  {
432  i = 0;
433  while (-1 != (k = lsocks[i++]))
434  GNUNET_array_append (lscp, ls, k);
435  GNUNET_array_append (lscp, ls, -1);
436  }
437 #if DARWIN
438  /* see https://web.archive.org/web/20150924082249/gnunet.org/vfork */
439  ret = vfork ();
440 #else
441  ret = fork ();
442 #endif
443  if (-1 == ret)
444  {
445  int eno = errno;
447  GNUNET_array_grow (lscp, ls, 0);
448  if (NULL != childpipe_write)
449  GNUNET_DISK_file_close (childpipe_write);
450  if (0 <= childpipe_read_fd)
451  GNUNET_break (0 == close (childpipe_read_fd));
452  errno = eno;
453  return NULL;
454  }
455  if (0 != ret)
456  {
457  unsetenv (GNUNET_OS_CONTROL_PIPE);
458  gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
459  gnunet_proc->pid = ret;
460  gnunet_proc->control_pipe = childpipe_write;
461  if (0 != (std_inheritance & GNUNET_OS_USE_PIPE_CONTROL))
462  {
463  GNUNET_break (0 == close (childpipe_read_fd));
464  }
465  GNUNET_array_grow (lscp, ls, 0);
466  return gnunet_proc;
467  }
468  if (0 <= childpipe_read_fd)
469  {
470  char fdbuf[100];
471 #ifndef DARWIN
472  /* due to vfork, we must NOT free memory on DARWIN! */
473  GNUNET_DISK_file_close (childpipe_write);
474 #endif
475  snprintf (fdbuf, 100, "%x", childpipe_read_fd);
476  setenv (GNUNET_OS_CONTROL_PIPE, fdbuf, 1);
477  }
478  else
479  unsetenv (GNUNET_OS_CONTROL_PIPE);
480  if (NULL != pipe_stdin)
481  {
482  GNUNET_break (0 == close (fd_stdin_write));
483  if (-1 == dup2 (fd_stdin_read, 0))
485  GNUNET_break (0 == close (fd_stdin_read));
486  }
487  else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_IN))
488  {
489  GNUNET_break (0 == close (0));
490  open_dev_null (0, O_RDONLY);
491  }
492  if (NULL != pipe_stdout)
493  {
494  GNUNET_break (0 == close (fd_stdout_read));
495  if (-1 == dup2 (fd_stdout_write, 1))
497  GNUNET_break (0 == close (fd_stdout_write));
498  }
499  else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_OUT))
500  {
501  GNUNET_break (0 == close (1));
502  open_dev_null (1, O_WRONLY);
503  }
504  if (NULL != pipe_stderr)
505  {
506  GNUNET_break (0 == close (fd_stderr_read));
507  if (-1 == dup2 (fd_stderr_write, 2))
509  GNUNET_break (0 == close (fd_stderr_write));
510  }
511  else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_ERR))
512  {
513  GNUNET_break (0 == close (2));
514  open_dev_null (2, O_WRONLY);
515  }
516  if (NULL != lscp)
517  {
518  /* read systemd documentation... */
519  i = 0;
520  tgt = 3;
521  while (-1 != lscp[i])
522  {
523  j = i + 1;
524  while (-1 != lscp[j])
525  {
526  if (lscp[j] == tgt)
527  {
528  /* dup away */
529  k = dup (lscp[j]);
530  GNUNET_assert (-1 != k);
531  GNUNET_assert (0 == close (lscp[j]));
532  lscp[j] = k;
533  break;
534  }
535  j++;
536  }
537  if (lscp[i] != tgt)
538  {
539  /* Bury any existing FD, no matter what; they should all be closed
540  * on exec anyway and the important ones have been dup'ed away */
541  GNUNET_break (0 == close (tgt));
542  GNUNET_assert (-1 != dup2 (lscp[i], tgt));
543  }
544  /* unset close-on-exec flag */
545  flags = fcntl (tgt, F_GETFD);
546  GNUNET_assert (flags >= 0);
547  flags &= ~FD_CLOEXEC;
548  fflush (stderr);
549  (void) fcntl (tgt, F_SETFD, flags);
550  tgt++;
551  i++;
552  }
553  GNUNET_snprintf (fds, sizeof(fds), "%u", i);
554  setenv ("LISTEN_FDS", fds, 1);
555  }
556 #ifndef DARWIN
557  /* due to vfork, we must NOT free memory on DARWIN! */
558  GNUNET_array_grow (lscp, ls, 0);
559 #endif
560  execvp (filename, argv);
562  _exit (1);
563 }
enum GNUNET_GenericReturnValue GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh, void *dst, size_t dst_len)
Retrieve OS file handle.
Definition: disk.c:1634
static char * filename
static struct GNUNET_NETWORK_Handle * ls
Listen socket for STUN processing.
Definition: gnunet-nat.c:85
struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Detaches one of the ends from the pipe.
Definition: disk.c:1560
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1587
const struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd n)
Get the handle to a particular pipe end.
Definition: disk.c:1617
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(enum GNUNET_DISK_PipeFlags pf)
Creates an interprocess channel.
Definition: disk.c:1444
@ GNUNET_DISK_PF_NONE
No special options, use non-blocking read/write operations.
@ GNUNET_DISK_PIPE_END_WRITE
The writing-end of a pipe.
@ GNUNET_DISK_PIPE_END_READ
The reading-end of a pipe.
@ GNUNET_OK
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
enum GNUNET_GenericReturnValue GNUNET_OS_check_helper_binary(const char *binary, bool check_suid, const char *params)
Check whether an executable exists and possibly if the suid bit is set on the file.
@ GNUNET_OS_INHERIT_STD_IN
When this flag is set, the child process will inherit stdin of the parent.
Definition: gnunet_os_lib.h:83
@ GNUNET_OS_INHERIT_STD_OUT
When this flag is set, the child process will inherit stdout of the parent.
Definition: gnunet_os_lib.h:89
@ GNUNET_OS_INHERIT_STD_ERR
When this flag is set, the child process will inherit stderr of the parent.
Definition: gnunet_os_lib.h:95
@ GNUNET_OS_USE_PIPE_CONTROL
Should a pipe be used to send signals to the child?
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: os_priority.c:38
static void open_dev_null(int target_fd, int flags)
Open '/dev/null' and make the result the given file descriptor.
Definition: os_priority.c:277
Handle used to manage a pipe.
Definition: disk.c:68
pid_t pid
PID of the process.
Definition: os_priority.c:49
struct GNUNET_DISK_FileHandle * control_pipe
Pipe we use to signal the process.
Definition: os_priority.c:55

References GNUNET_OS_Process::control_pipe, filename, GNUNET_array_append, GNUNET_array_grow, GNUNET_assert, GNUNET_break, GNUNET_DISK_file_close(), GNUNET_DISK_internal_file_handle_(), GNUNET_DISK_PF_NONE, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_DISK_pipe_detach_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_ERROR, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_OS_check_helper_binary(), GNUNET_OS_CONTROL_PIPE, GNUNET_OS_INHERIT_STD_ERR, GNUNET_OS_INHERIT_STD_IN, GNUNET_OS_INHERIT_STD_OUT, GNUNET_OS_USE_PIPE_CONTROL, GNUNET_snprintf(), GNUNET_SYSERR, LOG_STRERROR, LOG_STRERROR_FILE, ls, open_dev_null(), GNUNET_OS_Process::pid, and ret.

Referenced by GNUNET_OS_start_process_v(), and GNUNET_OS_start_process_vap().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_status()

static enum GNUNET_GenericReturnValue process_status ( struct GNUNET_OS_Process proc,
enum GNUNET_OS_ProcessStatusType type,
unsigned long *  code,
int  options 
)
static

Retrieve the status of a process, waiting on it if dead.

Nonblocking version.

Parameters
procprocess ID
typestatus type
codereturn code/signal number
optionsWNOHANG if non-blocking is desired
Returns
GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise

Definition at line 659 of file os_priority.c.

794 {
795  int status;
796  int ret;
797 
798  GNUNET_assert (0 != proc);
799  ret = waitpid (proc->pid,
800  &status,
801  options);
802  if (ret < 0)
803  {
805  "waitpid");
806  return GNUNET_SYSERR;
807  }
808  if (0 == ret)
809  {
811  *code = 0;
812  return GNUNET_NO;
813  }
814  if (proc->pid != ret)
815  {
817  "waitpid");
818  return GNUNET_SYSERR;
819  }
820  if (WIFEXITED (status))
821  {
823  *code = WEXITSTATUS (status);
824  }
825  else if (WIFSIGNALED (status))
826  {
828  *code = WTERMSIG (status);
829  }
830  else if (WIFSTOPPED (status))
831  {
833  *code = WSTOPSIG (status);
834  }
835 #ifdef WIFCONTINUED
836  else if (WIFCONTINUED (status))
837  {
839  *code = 0;
840  }
841 #endif
842  else
843  {
845  *code = 0;
846  }
847 
848  return GNUNET_OK;
849 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
uint16_t status
See PRISM_STATUS_*-constants.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_OS_PROCESS_SIGNALED
The process was killed by a signal.
@ GNUNET_OS_PROCESS_EXITED
The process exited with a return code.
@ GNUNET_OS_PROCESS_UNKNOWN
The process is not known to the OS (or at least not one of our children).
@ GNUNET_OS_PROCESS_RUNNING
The process is still running.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

◆ cmd_read()

static void cmd_read ( void *  cls)
static

Read from the process and call the line processor.

Parameters
clsthe struct GNUNET_OS_CommandHandle *

Definition at line 962 of file os_priority.c.

963 {
964  struct GNUNET_OS_CommandHandle *cmd = cls;
965  const struct GNUNET_SCHEDULER_TaskContext *tc;
967  char *end;
968  ssize_t ret;
969 
970  cmd->rtask = NULL;
973  {
974  /* timeout */
975  proc = cmd->proc;
976  cmd->proc = NULL;
977  proc (cmd->proc_cls, NULL);
978  return;
979  }
980  ret = GNUNET_DISK_file_read (cmd->r,
981  &cmd->buf[cmd->off],
982  sizeof(cmd->buf) - cmd->off);
983  if (ret <= 0)
984  {
985  if ((cmd->off > 0) && (cmd->off < sizeof(cmd->buf)))
986  {
987  cmd->buf[cmd->off] = '\0';
988  cmd->proc (cmd->proc_cls, cmd->buf);
989  }
990  proc = cmd->proc;
991  cmd->proc = NULL;
992  proc (cmd->proc_cls, NULL);
993  return;
994  }
995  end = memchr (&cmd->buf[cmd->off], '\n', ret);
996  cmd->off += ret;
997  while (NULL != end)
998  {
999  *end = '\0';
1000  cmd->proc (cmd->proc_cls, cmd->buf);
1001  memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
1002  cmd->off -= (end + 1 - cmd->buf);
1003  end = memchr (cmd->buf, '\n', cmd->off);
1004  }
1005  cmd->rtask =
1007  cmd->timeout),
1008  cmd->r,
1009  &cmd_read,
1010  cmd);
1011 }
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
@ GNUNET_YES
int GNUNET_NETWORK_fdset_handle_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_DISK_FileHandle *h)
Check if a file handle is part of an fd set.
Definition: network.c:1129
void(* GNUNET_OS_LineProcessor)(void *cls, const char *line)
Type of a function to process a line of output.
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:752
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:405
static void cmd_read(void *cls)
Read from the process and call the line processor.
Definition: os_priority.c:962
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:431
Handle to a command.
Definition: os_priority.c:892
size_t off
Current read offset in buf.
Definition: os_priority.c:936
char buf[1024]
Buffer for the output.
Definition: os_priority.c:921
struct GNUNET_SCHEDULER_Task * rtask
Task reading from pipe.
Definition: os_priority.c:926
struct GNUNET_TIME_Absolute timeout
When to time out.
Definition: os_priority.c:931
void * proc_cls
Closure for proc.
Definition: os_priority.c:916
GNUNET_OS_LineProcessor proc
Function to call on each line of output.
Definition: os_priority.c:911
const struct GNUNET_DISK_FileHandle * r
Read-end of output pipe.
Definition: os_priority.c:906
Context information passed to each scheduler task.
const struct GNUNET_NETWORK_FDSet * read_ready
Set of file descriptors ready for reading; note that additional bits may be set that were not in the ...

References GNUNET_OS_CommandHandle::buf, end, GNUNET_DISK_file_read(), GNUNET_NETWORK_fdset_handle_isset(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_get_task_context(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, GNUNET_OS_CommandHandle::off, GNUNET_OS_CommandHandle::proc, GNUNET_OS_CommandHandle::proc_cls, GNUNET_OS_CommandHandle::r, GNUNET_SCHEDULER_TaskContext::read_ready, ret, GNUNET_OS_CommandHandle::rtask, tc, and GNUNET_OS_CommandHandle::timeout.

Referenced by GNUNET_OS_command_run().

Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ current_process

struct GNUNET_OS_Process current_process
static

Handle for 'this' process.

Definition at line 1 of file os_priority.c.

Referenced by GNUNET_OS_process_current().

◆ pch

◆ spch

struct GNUNET_SCHEDULER_Task* spch
static

Handle for the shutdown_pch() Task.

Definition at line 72 of file os_priority.c.

Referenced by GNUNET_OS_install_parent_control_handler(), and parent_control_handler().