# getpriority

## NAME



           getpriority, setpriority - get/set program scheduling priority
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <sys/resource.h>**
    
           **int getpriority(int** _which_**, id_t** _who_**);**
           **int setpriority(int** _which_**, id_t** _who_**, int** _prio_**);**
    


## DESCRIPTION



           The scheduling priority of the process, process group, or user, as
           indicated by _which_ and _who_ is obtained with the **getpriority**() call
           and set with the **setpriority**() call.  The process attribute dealt
           with by these system calls is the same attribute (also known as
           the "nice" value) that is dealt with by nice(2).
    
           The value _which_ is one of **PRIO_PROCESS** , **PRIO_PGRP** , or **PRIO_USER** ,
           and _who_ is interpreted relative to _which_ (a process identifier for
           **PRIO_PROCESS** , process group identifier for **PRIO_PGRP** , and a user
           ID for **PRIO_USER**).  A zero value for _who_ denotes (respectively)
           the calling process, the process group of the calling process, or
           the real user ID of the calling process.
    
           The _prio_ argument is a value in the range -20 to 19 (but see NOTES
           below), with -20 being the highest priority and 19 being the
           lowest priority.  Attempts to set a priority outside this range
           are silently clamped to the range.  The default priority is 0;
           lower values give a process a higher scheduling priority.
    
           The **getpriority**() call returns the highest priority (lowest
           numerical value) enjoyed by any of the specified processes.  The
           **setpriority**() call sets the priorities of all of the specified
           processes to the specified value.
    
           Traditionally, only a privileged process could lower the nice
           value (i.e., set a higher priority).  However, since Linux 2.6.12,
           an unprivileged process can decrease the nice value of a target
           process that has a suitable **RLIMIT_NICE** soft limit; see
           getrlimit(2) for details.
    


## RETURN VALUE



           On success, **getpriority**() returns the calling thread's nice value,
           which may be a negative number.  On error, it returns -1 and sets
           _errno_ to indicate the error.
    
           Since a successful call to **getpriority**() can legitimately return
           the value -1, it is necessary to clear _errno_ prior to the call,
           then check _errno_ afterward to determine if -1 is an error or a
           legitimate value.
    
           **setpriority**() returns 0 on success.  On failure, it returns -1 and
           sets _errno_ to indicate the error.
    


## ERRORS



           **EACCES** The caller attempted to set a lower nice value (i.e., a
                  higher process priority), but did not have the required
                  privilege (on Linux: did not have the **CAP_SYS_NICE**
                  capability).
    
           **EINVAL** _which_ was not one of **PRIO_PROCESS** , **PRIO_PGRP** , or **PRIO_USER**.
    
           **EPERM** A process was located, but its effective user ID did not
                  match either the effective or the real user ID of the
                  caller, and was not privileged (on Linux: did not have the
                  **CAP_SYS_NICE** capability).  But see HISTORY below.
    
           **ESRCH** No process was located using the _which_ and _who_ values
                  specified.
    


## STANDARDS



           POSIX.1-2008.
    


## NOTES



           For further details on the nice value, see sched(7).
    
           _Note_ : the addition of the "autogroup" feature in Linux 2.6.38
           means that the nice value no longer has its traditional effect in
           many circumstances.  For details, see sched(7).
    
           A child created by fork(2) inherits its parent's nice value.  The
           nice value is preserved across execve(2).
    
       **C library/kernel differences**
           The getpriority system call returns nice values translated to the
           range 40..1, since a negative return value would be interpreted as
           an error.  The glibc wrapper function for **getpriority**() translates
           the value back according to the formula _unice = 20 - knice_ (thus,
           the 40..1 range returned by the kernel corresponds to the range
           -20..19 as seen by user space).
    


## BUGS



           According to POSIX, the nice value is a per-process setting.
           However, under the current Linux/NPTL implementation of POSIX
           threads, the nice value is a per-thread attribute: different
           threads in the same process can have different nice values.
           Portable applications should avoid relying on the Linux behavior,
           which may be made standards conformant in the future.
    


* * *