LXR toybox/toys/posix/ulimit.c

   1/* ulimit.c - Modify resource limits
   2 *
   3 * Copyright 2015 Rob Landley <rob@landley.net>
   4 *
   5 * See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ulimit.html
   6 * And man prlimit(2).
   7 *
   8 * Deviations from posix: The units on -f are supposed to be 512 byte
   9 * "blocks" (no other options are specified, and even hard drives don't
  10 * do that anymore). Bash uses 1024 byte blocks, so they don't care either.
  11 * We consistently use bytes everywhere we can.
  12 *
  13 * Deviations from bash: Sizes are in bytes (instead of -p 512 and -f 1024).
  14 * Bash's -p value has been wrong since 2010 (git 35f3d14dbbc5).
  15 * The kernel implementation of RLIMIT_LOCKS (-x) was removed from Linux in
  16 * 2003. Bash never implemented -b (it's in the help but unrecognized at
  17 * runtime). We support -P to affect processes other than us.
  18
  19USE_ULIMIT(NEWTOY(ulimit, ">1P#<1SHavutsrRqpnmlifedc[-SH][!apvutsrRqnmlifedc]", TOYFLAG_USR|TOYFLAG_BIN))
  20USE_ULIMIT(OLDTOY(prlimit, ulimit, TOYFLAG_USR|TOYFLAG_BIN))
  21
  22config ULIMIT
  23  bool "ulimit"
  24  default y
  25  help
  26    usage: ulimit [-P PID] [-SHRacdefilmnpqrstuv] [LIMIT]
  27
  28    Print or set resource limits for process number PID. If no LIMIT specified
  29    (or read-only -ap selected) display current value (sizes in bytes).
  30    Default is ulimit -P $PPID -Sf" (show soft filesize of your shell).
  31    
  32    -P  PID to affect (default $PPID)  -a  Show all limits
  33    -S  Set/show soft limit            -H  Set/show hard (maximum) limit
  34
  35    -c  Core file size (blocks)        -d  Process data segment (KiB)
  36    -e  Max scheduling priority        -f  File size (KiB)
  37    -i  Pending signal count           -l  Locked memory (KiB)
  38    -m  Resident Set Size (KiB)        -n  Number of open files
  39    -p  Pipe buffer (512 bytes)        -q  POSIX message queues
  40    -r  Max realtime priority          -R  Realtime latency (us)
  41    -s  Stack size (KiB)               -t  Total CPU time (s)
  42    -u  Maximum processes (this UID)   -v  Virtual memory size (KiB)
  43*/
  44
  45#define FOR_ulimit
  46#include "toys.h"
  47
  48GLOBALS(
  49  long P;
  50)
  51
  52// This is a linux kernel syscall added in 2.6.36 (git c022a0acad53) which
  53// glibc only exports a wrapper prototype for if you #define _FSF_HURD_RULZE.
  54int prlimit(pid_t pid, int resource, const struct rlimit *new_limit,
  55  struct rlimit *old_limit);
  56
  57// I'd like to sort the RLIMIT values 0-15, but mips, alpha and sparc
  58// override the asm-generic values for 5-9, and alphabetical order is nice for
  59// humans anyway.
  60void ulimit_main(void)
  61{
  62  struct rlimit rr;
  63  int i;
  64  // map and desc are in the same order as flags.
  65  // The Linux kernel implementation of RLIMIT_LOCKS (-x) was removed in 2003.
  66  char *flags="cdefilmnpqRrstuv";
  67  char map[] = {RLIMIT_CORE, RLIMIT_DATA, RLIMIT_NICE,
  68    RLIMIT_FSIZE, RLIMIT_SIGPENDING, RLIMIT_MEMLOCK,
  69    RLIMIT_RSS, RLIMIT_NOFILE, 0, RLIMIT_MSGQUEUE,
  70    RLIMIT_RTTIME, RLIMIT_RTPRIO, RLIMIT_STACK, RLIMIT_CPU, RLIMIT_NPROC,
  71    RLIMIT_AS};
  72  char *desc[]={"core dump size (blocks)", "data size (KiB)", "max nice",
  73    "file size (blocks)", "pending signals", "locked memory (KiB)",
  74    "RSS (KiB)", "open files", "pipe size (512 bytes)", "message queues",
  75    "RT time (us)", "RT priority", "stack (KiB)", "cpu time (s)", "processes",
  76    "address space (KiB)"};
  77
  78  if (!(toys.optflags&(FLAG_H-1))) toys.optflags |= FLAG_f;
  79  if ((FLAG(a)||FLAG(p)) && toys.optc) error_exit("can't set -ap");
  80
  81  // Fetch data
  82  if (!FLAG(P)) TT.P = getppid();
  83
  84  for (i=0; i<sizeof(map); i++) {
  85    int get = toys.optflags&(FLAG_a|(1<<i));
  86
  87    if (get && prlimit(TT.P, map[i], 0, &rr)) perror_exit("-%c", flags[i]);
  88    if (!toys.optc) {
  89      if (FLAG(a)) printf("-%c: %-25s ", flags[i], desc[i]);
  90      if (get) {
  91        if ((1<<i)&FLAG_p) {
  92          if (FLAG(H))
  93            xreadfile("/proc/sys/fs/pipe-max-size", toybuf, sizeof(toybuf));
  94          else {
  95            int pp[2];
  96
  97            xpipe(pp);
  98            sprintf(toybuf, "%d\n", fcntl(*pp, F_GETPIPE_SZ));
  99          }
 100          printf("%s", toybuf);
 101        } else {
 102          rlim_t rl = FLAG(H) ? rr.rlim_max : rr.rlim_cur;
 103
 104          if (rl == RLIM_INFINITY) printf("unlimited\n");
 105          else printf("%ld\n", (long)rl);
 106        }
 107      }
 108    }
 109    if (toys.optflags&(1<<i)) break;
 110  }
 111
 112  if (FLAG(a)||FLAG(p)) return;
 113
 114  if (toys.optc) {
 115    rlim_t val;
 116
 117    if (tolower(**toys.optargs) == 'u') val = RLIM_INFINITY;
 118    else val = atolx_range(*toys.optargs, 0, LONG_MAX);
 119
 120    if (FLAG(H)) rr.rlim_max = val;
 121    else rr.rlim_cur = val;
 122    if (prlimit(TT.P, map[i], &rr, 0)) perror_exit(0);
 123  }
 124}
 125