Provided by: manpages-es_1.55-10_all bug

NOMBRE

       getrlimit,   getrusage,  setrlimit  -  devuelve/establece  el  límite  de  recursos  y  su
       utilización

SINOPSIS

       #include <sys/time.h>
       #include <sys/resource.h>
       #include <unistd.h>

       int getrlimit(int resource, struct rlimit *rlim);
       int getrusage(int who, struct rusage *usage);
       int setrlimit(int resource, const struct rlimit *rlim);

DESCRIPCIÓN

       getrlimit y setrlimit devuelve / establece el límite de recursos,  respectivamente.   Cada
       recurso  tiene  asociado  un  límite  flexible  y  otro estricto, tal como se define en la
       estructura rlimit (el argumento rlim de las rutinas getrlimit() y setrlimit()):

            struct rlimit {
                rlim_t rlim_cur;   /* Límite flexible (Soft limit) */
                rlim_t rlim_max;   /* Límite estricto (Hard limit)
                                      (tope para rlim_cur) */
            };

       El límite flexible es el valor que impone el núcleo para el recurso  correspondiente.   El
       límite  estricto  actúa  como  un tope para el límite flexible: un proceso no privilegiado
       puede solamente establecer su límite flexible a un valor comprendido entre 0 y  el  límite
       estricto,  y  (irreversiblemente)  menor  que su límite estricto.  Un proceso privilegiado
       puede hacer cualquier cambio sobre ambos valores límite.

       El valor RLIM_INFINITY no impone ningún límite sobre un recurso (tanto  en  la  estructura
       devuelta por getrlimit() como en la estructura pasada a setrlimit()).

       resource debe ser uno de los siguientes valores:

       RLIMIT_CPU
              Tiempo  de  CPU  en  segundos.  Cuando el proceso alcanza el límite flexible, se le
              envía una señal SIGXCPU.  La acción por defecto para  esta  señal  es  terminar  el
              proceso.   Sin  embargo, la señal puede ser atrapada, y el manejador puede devolver
              el control al programa principal.  Si el proceso  continúa  consumiendo  tiempo  de
              CPU,  se  le  enviará  SIGXCPU  una  vez por segundo hasta que se alcance el límite
              estricto, momento en el cual se le enviará la señal SIGKILL.   (Este  último  punto
              describe  el  comportamiento de Linux 2.2 y 2.4.  Las implementaciones varían en el
              tratamiento de los procesos que continúna consumiendo  tiempo  de  CPU  después  de
              alcanzar el límite flexible.  Las aplicaciones portables que necesiten atrapar esta
              señal deberían realizar una terminación ordenada  después  de  recibir  la  primera
              señal SIGXCPU.)

       RLIMIT_DATA
              El  tamaño  máximo  del  segmento  de  datos  del  proceso (datos inicializados, no
              inicializados y el montículo).  Este límite afecta  a  las  llamadas  a  brk()  and
              sbrk(),  que  fallan  con  el  error  ENOMEM al llegarse al límite flexible de este
              recurso.

       RLIMIT_FSIZE
              El tamaño máximo de los ficheros que puede crear  el  proceso.   Los  intentos  por
              sobrepasar este límite provocan la comunicación de una señal SIGXFSZ.  Por defecto,
              esta señal termina el proceso, pero un proceso  puede  atrapar  esta  señal  en  su
              lugar,  en  cuyo  caso  la llamada al sistema relevante (p.e., write(), truncate())
              falla con el error EFBIG.

       RLIMIT_LOCKS
              Un límite sobre el número combinado de bloqueos flock()  y  arrendamientos  fcntl()
              que este proceso puede establecer (Linux 2.4 y posteriores).

       RLIMIT_MEMLOCK
              El  número  máximo  de  bytes  de  memoria virtual que pueden ser bloqueados en RAM
              usando mlock() y mlockall().

       RLIMIT_NOFILE
              Especifica un valor que es el número máximo de descriptor de fichero que puede  ser
              abierto  por  este  proceso.   Los  intentos  de (open(), pipe(), dup(), etc.)  por
              exceder este límite provocarán el error EMFILE.

       RLIMIT_NPROC
              El número máximo de procesos que pueden ser creados por el identificador de usuario
              real  del  proceso  invocador.   Al alcanzar este límite, fork() falla con el error
              EAGAIN.

       RLIMIT_RSS
              Especifica el límite (en páginas) del conjunto residente del proceso (el número  de
              páginas  virtuales  residentes en RAM).  Este límite sólo tiene efecto en Linux 2.4
              en  adelante,  y  sólo  afecta   a   las   llamadas   a   madvise()   especificando
              MADVISE_WILLNEED.

       RLIMIT_STACK
              El  tamaño  máximo  de  la pila del proceso, en bytes.  Al alcanzar este límite, se
              genera una señal SIGSEGV.  Para manejar esta señal, un  proceso  debe  emplear  una
              pila de señales alternativa (sigaltstack(2)).

       RLIMIT_OFILE es el nombre BSD para RLIMIT_NOFILE.

       getrusage devuelve la utilización actual de los recursos, para un who de cualquiera de los
       siguientes, bien RUSAGE_SELF oo RUSAGE_CHILDREN.

            struct rusage {
                    struct timeval ru_utime; /* tiempo de usuario utilizado */
                    struct timeval ru_stime; /* tiempo de sistema utilizado */
                    long    ru_maxrss;       /* tamaño máximo de la parte
                                                establecida como residente */
                    long    ru_ixrss;        /* tamaño total de la memoria
                                                compartida */
                    long    ru_idrss;        /* tamaño total de la memoria
                                                no compartida */
                    long    ru_isrss;        /* tamaño de pila no compartido */
                    long    ru_minflt;       /* peticiones de página */
                    long    ru_majflt;       /* fallos de página */
                    long    ru_nswap;        /* intercambios */
                    long    ru_inblock;      /* operaciones de entrada de
                                                bloques */
                    long    ru_oublock;      /* operaciones de salida de
                                                bloques */
                    long    ru_msgsnd;       /* mensajes enviados */
                    long    ru_msgrcv;       /* mensajes recibidos */
                    long    ru_nsignals;     /* señales recibidas */
                    long    ru_nvcsw;        /* cambios de contexto
                                                voluntarios */
                    long    ru_nivcsw;       /* cambios de contexto
                                                involuntarios */
            };

VALOR DEVUELTO

       Si tiene éxito, devuelve cero. Si hay error, devuelve -1, y errno toma el  correspondiente
       valor.

ERRORES

       EFAULT rlim o usage apuntan fuera del espacio de direcciones accesible.

       EINVAL getrlimit  o  setrlimit  es llamado con un resource erróneo, o getrusage es llamado
              con un who erróneo.

       EPERM  Un  no-superusuario  intenta  utilizar  setrlimit()  para  incrementar  el   límite
              `flexible'  o  `estricto'  por encima del límite estricto actual, o un superusuario
              intenta incrementar RLIMIT_NOFILE por encima del máximo actual del núcleo.

CONFORME A

       SVr4, BSD 4.3

NOTA

       Incluir <sys/time.h> no es necesario actualmente, pero  incrementa  la  transportabilidad.
       (De hecho, struct timeval está definida en <sys/time.h>.)

       En Linux, si la acción asociada a SIGCHLD es SIG_IGN los usos del recurso por los procesos
       hijo son incluidos automáticamente en el valor devuelto por RUSAGE_CHILDREN, aunque  POSIX
       1003.1-2001 prohíbe ésto explícitamente.

       La  estructura  de  arriba  fue  tomada  de  BSD  4.3  Reno.   No  todos  los  campos  son
       significativos bajo Linux.  En  la  actualidad  (Linux  2.4)  sólo  los  campos  ru_utime,
       ru_stime, ru_minflt, ru_majflt, y ru_nswap son mantenidos.

VÉASE TAMBIÉN

       dup(2),  fcntl(2), fork(2), mlock(2), mlockall(2), mmap(2), open(2), quotactl(2), sbrk(2),
       wait3(2), wait4(2), malloc(3), ulimit(3), signal(7)