### Function

# GLib child_watch_source_new

since: 2.4

#### Declaration [src]

    GSource*
    g_child_watch_source_new (
      GPid pid
    )

#### Description [src]

Creates a new child_watch source.

The source will not initially be associated with any `GMainContext` and must be added to one with `g_source_attach()` before it will be executed.

Note that child watch sources can only be used in conjunction with `g_spawn...` when the `G_SPAWN_DO_NOT_REAP_CHILD` flag is used.

Note that on platforms where `GPid` must be explicitly closed (see `g_spawn_close_pid()`) `pid` must not be closed while the source is still active. Typically, you will want to call `g_spawn_close_pid()` in the callback function for the source.

On POSIX platforms, the following restrictions apply to this API due to limitations in POSIX process interfaces:

- `pid` must be a child of this process
- `pid` must be positive
- the application must not call `waitpid` with a non-positive first argument, for instance in another thread
- the application must not wait for `pid` to exit by any other mechanism, including `waitpid(pid, ...)` or a second child-watch source for the same `pid`
- the application must not ignore `SIGCHLD`
- Before 2.78, the application could not send a signal (`kill()`) to the watched `pid` in a race free manner. Since 2.78, you can do that while the associated `GMainContext` is acquired.
- Before 2.78, even after destroying the `GSource`, you could not be sure that `pid` wasn’t already reaped. Hence, it was also not safe to `kill()` or `waitpid()` on the process ID after the child watch source was gone. Destroying the source before it fired made it impossible to reliably reap the process.

If any of those conditions are not met, this and related APIs will not work correctly. This can often be diagnosed via a GLib warning stating that `ECHILD` was received by `waitpid`.

Calling `waitpid` for specific processes other than `pid` remains a valid thing to do.

Available since: 2.4

#### Parameters

`pid`

  Type: `GPid`

  Process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn’t have to be a child).

#### Return value

Type: `GSource`

The newly-created child watch source.

The caller of the function takes ownership of the data, and is responsible for freeing it.