1: /* Bit values & structures for resource limits.  4.4 BSD/generic GNU version.
    2:    Copyright (C) 1994,1996,1997,1998,2006 Free Software Foundation, Inc.
    3:    This file is part of the GNU C Library.
    4: 
    5:    The GNU C Library is free software; you can redistribute it and/or
    6:    modify it under the terms of the GNU Lesser General Public
    7:    License as published by the Free Software Foundation; either
    8:    version 2.1 of the License, or (at your option) any later version.
    9: 
   10:    The GNU C Library is distributed in the hope that it will be useful,
   11:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   12:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   13:    Lesser General Public License for more details.
   14: 
   15:    You should have received a copy of the GNU Lesser General Public
   16:    License along with the GNU C Library; if not, write to the Free
   17:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   18:    02111-1307 USA.  */
   19: 
   20: #ifndef _SYS_RESOURCE_H
   21: # error "Never use <bits/resource.h> directly; include <sys/resource.h> instead."
   22: #endif
   23: 
   24: #include <bits/types.h>
   25: 
   26: /* These are the values for 4.4 BSD and GNU.  Earlier BSD systems have a
   27:    subset of these kinds of resource limit.  In systems where `getrlimit'
   28:    and `setrlimit' are not system calls, these are the values used by the C
   29:    library to emulate them.  */
   30: 
   31: /* Kinds of resource limit.  */
   32: enum __rlimit_resource
   33:   {
   34:     /* Per-process CPU limit, in seconds.  */
   35:     RLIMIT_CPU,
   36: #define RLIMIT_CPU      RLIMIT_CPU
   37:     /* Largest file that can be created, in bytes.  */
   38:     RLIMIT_FSIZE,
   39: #define RLIMIT_FSIZE    RLIMIT_FSIZE
   40:     /* Maximum size of data segment, in bytes.  */
   41:     RLIMIT_DATA,
   42: #define RLIMIT_DATA     RLIMIT_DATA
   43:     /* Maximum size of stack segment, in bytes.  */
   44:     RLIMIT_STACK,
   45: #define RLIMIT_STACK    RLIMIT_STACK
   46:     /* Largest core file that can be created, in bytes.  */
   47:     RLIMIT_CORE,
   48: #define RLIMIT_CORE     RLIMIT_CORE
   49:     /* Largest resident set size, in bytes.
   50:        This affects swapping; processes that are exceeding their
   51:        resident set size will be more likely to have physical memory
   52:        taken from them.  */
   53:     RLIMIT_RSS,
   54: #define RLIMIT_RSS      RLIMIT_RSS
   55:     /* Locked-in-memory address space.  */
   56:     RLIMIT_MEMLOCK,
   57: #define RLIMIT_MEMLOCK  RLIMIT_MEMLOCK
   58:     /* Number of processes.  */
   59:     RLIMIT_NPROC,
   60: #define RLIMIT_NPROC    RLIMIT_NPROC
   61:     /* Number of open files.  */
   62:     RLIMIT_OFILE,
   63:     RLIMIT_NOFILE = RLIMIT_OFILE, /* Another name for the same thing.  */
   64: #define RLIMIT_OFILE    RLIMIT_OFILE
   65: #define RLIMIT_NOFILE   RLIMIT_NOFILE
   66:     /* Maximum size of all socket buffers.  */
   67:     RLIMIT_SBSIZE,
   68: #define RLIMIT_SBSIZE   RLIMIT_SBSIZE
   69:     /* Maximum size in bytes of the process address space.  */
   70:     RLIMIT_AS,
   71:     RLIMIT_VMEM = RLIMIT_AS,    /* Another name for the same thing.  */
   72: #define RLIMIT_AS       RLIMIT_AS
   73: #define RLIMIT_VMEM     RLIMIT_AS
   74: 
   75:     RLIMIT_NLIMITS,             /* Number of limit flavors.  */
   76:     RLIM_NLIMITS = RLIMIT_NLIMITS /* Traditional name for same.  */
   77:   };
   78: 
   79: /* Value to indicate that there is no limit.  */
   80: #ifndef __USE_FILE_OFFSET64
   81: # define RLIM_INFINITY 0x7fffffff
   82: #else
   83: # define RLIM_INFINITY 0x7fffffffffffffffLL
   84: #endif
   85: 
   86: #ifdef __USE_LARGEFILE64
   87: # define RLIM64_INFINITY 0x7fffffffffffffffLL
   88: #endif
   89: 
   90: 
   91: /* Type for resource quantity measurement.  */
   92: #ifndef __USE_FILE_OFFSET64
   93: typedef __rlim_t rlim_t;
   94: #else
   95: typedef __rlim64_t rlim_t;
   96: #endif
   97: #ifdef __USE_LARGEFILE64
   98: typedef __rlim64_t rlim64_t;
   99: #endif
  100: 
  101: struct rlimit
  102:   {
  103:     /* The current (soft) limit.  */
  104:     rlim_t rlim_cur;
  105:     /* The hard limit.  */
  106:     rlim_t rlim_max;
  107:   };
  108: 
  109: #ifdef __USE_LARGEFILE64
  110: struct rlimit64
  111:   {
  112:     /* The current (soft) limit.  */
  113:     rlim64_t rlim_cur;
  114:     /* The hard limit.  */
  115:     rlim64_t rlim_max;
  116:  };
  117: #endif
  118: 
  119: /* Whose usage statistics do you want?  */
  120: enum __rusage_who
  121: /* The macro definitions are necessary because some programs want
  122:    to test for operating system features with #ifdef RUSAGE_SELF.
  123:    In ISO C the reflexive definition is a no-op.  */
  124:   {
  125:     /* The calling process.  */
  126:     RUSAGE_SELF = 0,
  127: #define RUSAGE_SELF     RUSAGE_SELF
  128:     /* All of its terminated child processes.  */
  129:     RUSAGE_CHILDREN = -1
  130: #define RUSAGE_CHILDREN RUSAGE_CHILDREN
  131:   };
  132: 
  133: #define __need_timeval
  134: #include <bits/time.h>           /* For `struct timeval'.  */
  135: 
  136: /* Structure which says how much of each resource has been used.  */
  137: struct rusage
  138:   {
  139:     /* Total amount of user time used.  */
  140:     struct timeval ru_utime;
  141:     /* Total amount of system time used.  */
  142:     struct timeval ru_stime;
  143:     /* Maximum resident set size (in kilobytes).  */
  144:     long int ru_maxrss;
  145:     /* Amount of sharing of text segment memory
  146:        with other processes (kilobyte-seconds).  */
  147:     long int ru_ixrss;
  148:     /* Amount of data segment memory used (kilobyte-seconds).  */
  149:     long int ru_idrss;
  150:     /* Amount of stack memory used (kilobyte-seconds).  */
  151:     long int ru_isrss;
  152:     /* Number of soft page faults (i.e. those serviced by reclaiming
  153:        a page from the list of pages awaiting reallocation.  */
  154:     long int ru_minflt;
  155:     /* Number of hard page faults (i.e. those that required I/O).  */
  156:     long int ru_majflt;
  157:     /* Number of times a process was swapped out of physical memory.  */
  158:     long int ru_nswap;
  159:     /* Number of input operations via the file system.  Note: This
  160:        and `ru_oublock' do not include operations with the cache.  */
  161:     long int ru_inblock;
  162:     /* Number of output operations via the file system.  */
  163:     long int ru_oublock;
  164:     /* Number of IPC messages sent.  */
  165:     long int ru_msgsnd;
  166:     /* Number of IPC messages received.  */
  167:     long int ru_msgrcv;
  168:     /* Number of signals delivered.  */
  169:     long int ru_nsignals;
  170:     /* Number of voluntary context switches, i.e. because the process
  171:        gave up the process before it had to (usually to wait for some
  172:        resource to be available).  */
  173:     long int ru_nvcsw;
  174:     /* Number of involuntary context switches, i.e. a higher priority process
  175:        became runnable or the current process used up its time slice.  */
  176:     long int ru_nivcsw;
  177:   };
  178: 
  179: /* Priority limits.  */
  180: #define PRIO_MIN        -20     /* Minimum priority a process can have.  */
  181: #define PRIO_MAX        20      /* Maximum priority a process can have.  */
  182: 
  183: /* The type of the WHICH argument to `getpriority' and `setpriority',
  184:    indicating what flavor of entity the WHO argument specifies.  */
  185: enum __priority_which
  186:   {
  187:     PRIO_PROCESS = 0,           /* WHO is a process ID.  */
  188:     PRIO_PGRP = 1,              /* WHO is a process group ID.  */
  189:     PRIO_USER = 2               /* WHO is a user ID.  */
  190:   };