# sd_pid_get_owner_uid

## NAME



           sd_pid_get_owner_uid, sd_pid_get_session, sd_pid_get_user_unit,
           sd_pid_get_unit, sd_pid_get_machine_name, sd_pid_get_slice,
           sd_pid_get_user_slice, sd_pid_get_cgroup, sd_pidfd_get_owner_uid,
           sd_pidfd_get_session, sd_pidfd_get_user_unit, sd_pidfd_get_unit,
           sd_pidfd_get_machine_name, sd_pidfd_get_slice,
           sd_pidfd_get_user_slice, sd_pidfd_get_cgroup,
           sd_peer_get_owner_uid, sd_peer_get_session, sd_peer_get_user_unit,
           sd_peer_get_unit, sd_peer_get_machine_name, sd_peer_get_slice,
           sd_peer_get_user_slice, sd_peer_get_cgroup - Determine the owner
           uid of the user unit or session, or the session, user unit, system
           unit, container/VM or slice that a specific PID or socket peer
           belongs to
    


## SYNOPSIS



           **#include <systemd/sd-login.h>**
    
           **int sd_pid_get_owner_uid(pid_t** _pid_**, uid_t ***_uid_**);**
    
           **int sd_pid_get_session(pid_t** _pid_**, char ****_session_**);**
    
           **int sd_pid_get_user_unit(pid_t** _pid_**, char ****_unit_**);**
    
           **int sd_pid_get_unit(pid_t** _pid_**, char ****_unit_**);**
    
           **int sd_pid_get_machine_name(pid_t** _pid_**, char ****_name_**);**
    
           **int sd_pid_get_slice(pid_t** _pid_**, char ****_slice_**);**
    
           **int sd_pid_get_user_slice(pid_t** _pid_**, char ****_slice_**);**
    
           **int sd_pid_get_cgroup(pid_t** _pid_**, char ****_cgroup_**);**
    
           **int sd_pidfd_get_owner_uid(int** _pidfd_**, uid_t ***_uid_**);**
    
           **int sd_pidfd_get_session(int** _pidfd_**, char ****_session_**);**
    
           **int sd_pidfd_get_user_unit(int** _pidfd_**, char ****_unit_**);**
    
           **int sd_pidfd_get_unit(int** _pidfd_**, char ****_unit_**);**
    
           **int sd_pidfd_get_machine_name(int** _pidfd_**, char ****_name_**);**
    
           **int sd_pidfd_get_slice(int** _pidfd_**, char ****_slice_**);**
    
           **int sd_pidfd_get_user_slice(int** _pidfd_**, char ****_slice_**);**
    
           **int sd_pidfd_get_cgroup(int** _pidfd_**, char ****_cgroup_**);**
    
           **int sd_peer_get_owner_uid(int** _fd_**, uid_t ***_uid_**);**
    
           **int sd_peer_get_session(int** _fd_**, char ****_session_**);**
    
           **int sd_peer_get_user_unit(int** _fd_**, char ****_unit_**);**
    
           **int sd_peer_get_unit(int** _fd_**, char ****_unit_**);**
    
           **int sd_peer_get_machine_name(int** _fd_**, char ****_name_**);**
    
           **int sd_peer_get_slice(int** _fd_**, char ****_slice_**);**
    
           **int sd_peer_get_user_slice(int** _fd_**, char ****_slice_**);**
    
           **int sd_peer_get_cgroup(int** _fd_**, char ****_cgroup_**);**
    


## DESCRIPTION



           **sd_pid_get_owner_uid()** may be used to determine the Unix UID (user
           identifier) which owns the login session or systemd user unit of a
           process identified by the specified PID. For processes which are
           not part of a login session and not managed by a user manager,
           this function will fail with **-ENODATA**.
    
           **sd_pid_get_session()** may be used to determine the login session
           identifier of a process identified by the specified process
           identifier. The session identifier is a short string, suitable for
           usage in file system paths. Please note the login session may be
           limited to a stub process or two. User processes may instead be
           started from their systemd user manager, e.g. GUI applications
           started using DBus activation, as well as service processes which
           are shared between multiple logins of the same user. For processes
           which are not part of a login session, this function will fail
           with **-ENODATA**. The returned string needs to be freed with the libc
           free(3) call after use.
    
           **sd_pid_get_user_unit()** may be used to determine the systemd user
           unit (i.e. user service or scope unit) identifier of a process
           identified by the specified PID. The unit name is a short string,
           suitable for usage in file system paths. For processes which are
           not managed by a user manager, this function will fail with
           **-ENODATA**. The returned string needs to be freed with the libc
           free(3) call after use.
    
           **sd_pid_get_unit()** may be used to determine the systemd system unit
           (i.e. system service or scope unit) identifier of a process
           identified by the specified PID. The unit name is a short string,
           suitable for usage in file system paths. Note that not all
           processes are part of a system unit/service. For processes not
           being part of a systemd system unit, this function will fail with
           **-ENODATA**. (More specifically, this call will not work for kernel
           threads.) The returned string needs to be freed with the libc
           free(3) call after use.
    
           **sd_pid_get_machine_name()** may be used to determine the name of the
           VM or container is a member of. The machine name is a short
           string, suitable for usage in file system paths. The returned
           string needs to be freed with the libc free(3) call after use. For
           processes not part of a VM or container, this function fails with
           **-ENODATA**.
    
           **sd_pid_get_slice()** may be used to determine the slice unit the
           process is a member of. See systemd.slice(5) for details about
           slices. The returned string needs to be freed with the libc
           free(3) call after use.
    
           Similarly, **sd_pid_get_user_slice()** returns the user slice (as
           managed by the user's systemd instance) of a process.
    
           **sd_pid_get_cgroup()** returns the control group path of the
           specified process, relative to the root of the hierarchy. Returns
           the path without trailing slash, except for processes located in
           the root control group, where "/" is returned. To find the actual
           control group path in the file system, the returned path needs to
           be prefixed with /sys/fs/cgroup/.
    
           If the _pid_ parameter of any of these functions is passed as 0, the
           operation is executed for the calling process.
    
           The **sd_pidfd_get_owner_uid()** , **sd_pidfd_get_session()** ,
           **sd_pidfd_get_user_unit()** , **sd_pidfd_get_unit()** ,
           **sd_pidfd_get_machine_name()** , **sd_pidfd_get_slice()** ,
           **sd_pidfd_get_user_slice()** and **sd_pidfd_get_cgroup()** calls operate
           similarly to their PID counterparts, but accept a **PIDFD** instead of
           a **PID** , which means they are not subject to recycle race conditions
           as the process is pinned by the file descriptor during the whole
           duration of the invocation. Note that these require a kernel that
           supports **PIDFD**. A suitable file descriptor may be acquired via
           pidfd_open(2).
    
           The **sd_peer_get_owner_uid()** , **sd_peer_get_session()** ,
           **sd_peer_get_user_unit()** , **sd_peer_get_unit()** ,
           **sd_peer_get_machine_name()** , **sd_peer_get_slice()** ,
           **sd_peer_get_user_slice()** and **sd_peer_get_cgroup()** calls operate
           similarly to their PID counterparts, but accept a connected
           **AF_UNIX** socket and retrieve information about the connected peer
           process. Note that these fields are retrieved via /proc/, and
           hence are not suitable for authorization purposes, as they are
           subject to races.
    


## RETURN VALUE



           On success, these calls return 0 or a positive integer. On
           failure, these calls return a negative errno-style error code.
    
       **Errors**
           Returned errors may indicate the following problems:
    
           **-ESRCH**
               The specified PID does not refer to a running process.
    
           **-EBADF**
               The specified file descriptor is invalid.
    
           **-ENODATA**
               The given field is not specified for the described process or
               peer.
    
           **-EINVAL**
               An input parameter was invalid (out of range, or **NULL** , where
               that is not accepted).
    
           **-ENOMEM**
               Memory allocation failed.
    


## NOTES



           Functions described here are available as a shared library, which
           can be compiled against and linked to with the
           **libsystemd pkg-config**(1) file.
    
           Note that the login session identifier as returned by
           **sd_pid_get_session()** is completely unrelated to the process
           session identifier as returned by getsid(2).
    


* * *