src/vlimit.c

   1 // $Id: vlimit.c 2403 2006-11-24 23:06:08Z dhozac $
   2
   3 // Copyright (C) 2003 Enrico Scholz <enrico.scholz@informatik.tu-chemnitz.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2, or (at your option)
   8 // any later version.
   9 //
  10 // This program 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
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 /*
  20         Set the global per context limit of a resource (memory, file handle).
  21         This utility can do it either for the current context or a selected
  22         one.
  23
  24         It uses the same options as ulimit, when possible
  25 */
  26 #ifdef HAVE_CONFIG_H
  27 #  include <config.h>
  28 #endif
  29 #include "compat.h"
  30
  31 #include "vserver.h"
  32 #include "internal.h"
  33 #include "util.h"
  34
  35 #include <getopt.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38 #include <assert.h>
  39 #include <stdbool.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <libgen.h>
  43 #include <sys/resource.h>
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #include <sys/stat.h>
  47 #include <ctype.h>
  48
  49 #define ENSC_WRAPPERS_PREFIX    "vlimit: "
  50 #define ENSC_WRAPPERS_UNISTD    1
  51 #define ENSC_WRAPPERS_VSERVER   1
  52 #include <wrappers.h>
  53
  54 #define CMD_HELP                0x1000
  55 #define CMD_VERSION             0x1001
  56 #define CMD_XID                 0x4000
  57 #define CMD_DIR                 0x8000
  58 #define CMD_MISSINGOK           0x8001
  59
  60 int             wrapper_exit_code = 255;
  61
  62 #ifndef RLIMIT_MSGQUEUE
  63 #  define RLIMIT_MSGQUEUE       12
  64 #endif
  65
  66 #define NUMLIM(X) \
  67 { #X, required_argument, 0, 2048|X }
  68 #define OPT_RESLIM(RES,V) \
  69   { #RES, required_argument, 0, 2048|RLIMIT_##V }
  70 #define OPT_VLIMIT(RES,V) \
  71   { #RES, required_argument, 0, 2048|VC_VLIMIT_##V }
  72
  73 static struct option const
  74 CMDLINE_OPTIONS[] = {
  75   { "help",      no_argument,       0, CMD_HELP },
  76   { "version",   no_argument,       0, CMD_VERSION },
  77   { "all",       no_argument,       0, 'a' },
  78   { "xid",       required_argument, 0, CMD_XID },
  79   { "dir",       required_argument, 0, CMD_DIR },
  80   { "missingok", no_argument,       0, CMD_MISSINGOK },
  81   NUMLIM( 0), NUMLIM( 1), NUMLIM( 2), NUMLIM( 3),
  82   NUMLIM( 4), NUMLIM( 5), NUMLIM( 6), NUMLIM( 7),
  83   NUMLIM( 8), NUMLIM( 9), NUMLIM(10), NUMLIM(11),
  84   NUMLIM(12), NUMLIM(13), NUMLIM(14), NUMLIM(15),
  85   NUMLIM(16), NUMLIM(17), NUMLIM(18), NUMLIM(19),
  86   NUMLIM(20), NUMLIM(21), NUMLIM(22), NUMLIM(23),
  87   NUMLIM(24), NUMLIM(25), NUMLIM(26), NUMLIM(27),
  88   NUMLIM(28), NUMLIM(29), NUMLIM(30), NUMLIM(31),
  89   OPT_RESLIM(cpu,      CPU),
  90   OPT_RESLIM(fsize,    FSIZE),
  91   OPT_RESLIM(data,     DATA),
  92   OPT_RESLIM(stack,    STACK),
  93   OPT_RESLIM(core,     CORE),
  94   OPT_RESLIM(rss,      RSS),
  95   OPT_RESLIM(nproc,    NPROC),
  96   OPT_RESLIM(nofile,   NOFILE),
  97   OPT_RESLIM(memlock,  MEMLOCK),
  98   OPT_RESLIM(as,       AS),
  99   OPT_RESLIM(locks,    LOCKS),
 100   OPT_RESLIM(msgqueue, MSGQUEUE),
 101   OPT_VLIMIT(nsock,    NSOCK),
 102   OPT_VLIMIT(openfd,   OPENFD),
 103   OPT_VLIMIT(anon,     ANON),
 104   OPT_VLIMIT(shmem,    SHMEM),
 105   OPT_VLIMIT(semary,   SEMARY),
 106   OPT_VLIMIT(nsems,    NSEMS),
 107   OPT_VLIMIT(dentry,   DENTRY),
 108   { 0,0,0,0 }
 109 };
 110
 111 #define REV_RESLIM(X)   [RLIMIT_##X] = #X
 112 #define REV_VLIMIT(X)   [VC_VLIMIT_##X] = #X
 113 static char const * const LIMIT_STR[] = {
 114   REV_RESLIM(CPU),     REV_RESLIM(FSIZE),  REV_RESLIM(DATA),  REV_RESLIM(STACK),
 115   REV_RESLIM(CORE),    REV_RESLIM(RSS),    REV_RESLIM(NPROC), REV_RESLIM(NOFILE),
 116   REV_RESLIM(MEMLOCK), REV_RESLIM(AS),     REV_RESLIM(LOCKS), REV_RESLIM(MSGQUEUE),
 117   REV_VLIMIT(NSOCK),   REV_VLIMIT(OPENFD), REV_VLIMIT(ANON),  REV_VLIMIT(SHMEM),
 118   REV_VLIMIT(SEMARY),  REV_VLIMIT(NSEMS),  REV_VLIMIT(DENTRY),
 119 };
 120
 121 static void
 122 showHelp(int fd, char const *cmd, int res)
 123 {
 124   VSERVER_DECLARE_CMD(cmd);
 125
 126   WRITE_MSG(fd, "Usage:  ");
 127   WRITE_STR(fd, cmd);
 128   WRITE_MSG(fd,
 129             " [--xid|-c <xid>] [-nd] [-a|--all] [[-MSH] --(<resource>|<nr>) <value>]*\n"
 130             "               [--dir <pathname> [--missingok]] [--] [<program> <args>*]\n\n"
 131             "Options:\n"
 132             "    -c|--xid <xid>\n"
 133             "                ...  operate on context <xid>\n"
 134             "    -a|--all    ...  show all available limits\n"
 135             "    -n          ...  do not resolve limit-names\n"
 136             "    -d          ...  show limits in decimal\n"
 137             "    -M          ...  set Minimum limit\n"
 138             "    -S          ...  set Soft limit\n"
 139             "    -H          ...  set Hard limit (assumed by default, when neither\n"
 140             "                     M nor S was requested)\n"
 141             "    --dir <pathname>\n"
 142             "                ...  read limits from <pathname>/; allowed filenames are\n"
 143             "                     <resource> and <resource>.{min,soft,hard}. When a limit\n"
 144             "                     was set by the CLI already, the corresponding file\n"
 145             "                     will be ignored\n"
 146             "    --missingok ...  do not fail when <pathname> does not exist\n"
 147             "    --<resource>|<nr> <value>\n"
 148             "                ...  set specified (MSH) limit for <resource> to <value>\n\n"
 149             "Valid values for resource are cpu, fsize, data, stack, core, rss, nproc,\n"
 150             "nofile, memlock, as, locks, msgqueue, nsock, openfd, anon, shmem, semary,\n"
 151             "nsems, and dentry.\n\n"
 152             "Please report bugs to " PACKAGE_BUGREPORT "\n");
 153   exit(res);
 154 }
 155
 156 static void
 157 showVersion()
 158 {
 159   WRITE_MSG(1,
 160             "vlimit " VERSION " -- limits context-resources\n"
 161             "This program is part of " PACKAGE_STRING "\n\n"
 162             "Copyright (C) 2003 Enrico Scholz\n"
 163             VERSION_COPYRIGHT_DISCLAIMER);
 164   exit(0);
 165 }
 166
 167 static size_t
 168 fmtHex(char *ptr, vc_limit_t lim)
 169 {
 170   memcpy(ptr, "0x", 2);
 171   return utilvserver_fmt_xuint64(ptr+2, lim) + 2;
 172 }
 173
 174 static bool             do_resolve = true;
 175 static size_t           (*fmt_func)(char *, vc_limit_t) = fmtHex;
 176
 177 static void *
 178 appendLimit(char *ptr, bool do_it, vc_limit_t lim)
 179 {
 180   memcpy(ptr, "  ", 2);
 181   ptr += 2;
 182   if (do_it) {
 183     if (lim==VC_LIM_INFINITY) {
 184       memcpy(ptr, "inf", 3);
 185       ptr += 3;
 186     }
 187     else {
 188       ptr += (*fmt_func)(ptr, lim);
 189       *ptr = ' ';
 190     }
 191   }
 192   else {
 193     memcpy(ptr, "N/A", 3);
 194     ptr += 3;
 195   }
 196
 197   return ptr;
 198 }
 199
 200 static void
 201 showAll(int ctx)
 202 {
 203   struct vc_rlimit_mask mask;
 204   size_t                i;
 205
 206   if (vc_get_rlimit_mask(ctx, &mask)==-1) {
 207     perror("vc_get_rlimit_mask()");
 208     exit(wrapper_exit_code);
 209   }
 210
 211   for (i=0; i<32; ++i) {
 212     uint32_t            bitmask = (1<<i);
 213     struct vc_rlimit    limit;
 214     char                buf[128], *ptr=buf;
 215
 216     if (((mask.min|mask.soft|mask.hard) & bitmask)==0) continue;
 217     if (vc_get_rlimit(ctx, i, &limit)==-1) {
 218       perror("vc_get_rlimit()");
 219       continue;
 220     }
 221
 222     memset(buf, ' ', sizeof buf);
 223     if (do_resolve && i<DIM_OF(LIMIT_STR)) {
 224       size_t            l = strlen(LIMIT_STR[i]);
 225       memcpy(ptr, LIMIT_STR[i], l);
 226       ptr += l;
 227     }
 228     else {
 229       ptr += utilvserver_fmt_uint(ptr, i);
 230       *ptr = ' ';
 231     }
 232
 233     ptr  = appendLimit(buf+10, mask.min &bitmask, limit.min);
 234     ptr  = appendLimit(buf+30, mask.soft&bitmask, limit.soft);
 235     ptr  = appendLimit(buf+50, mask.hard&bitmask, limit.hard);
 236
 237     *ptr++ = '\n';
 238     Vwrite(1, buf, ptr-buf);
 239   }
 240 }
 241
 242 static void
 243 setLimits(int ctx, struct vc_rlimit const limits[], uint32_t mask)
 244 {
 245   size_t                i;
 246   for (i=0; i<32; ++i) {
 247     if ((mask & (1<<i))==0) continue;
 248     if (vc_set_rlimit(ctx, i, limits+i)) {
 249       perror("vc_set_rlimit()");
 250     }
 251   }
 252 }
 253
 254 static vc_limit_t
 255 readValue(int fd, char const *filename)
 256 {
 257   char          buf[128];
 258   size_t        len = Eread(fd, buf, sizeof(buf)-1);
 259   vc_limit_t    res;
 260
 261   buf[len] = '\0';
 262
 263   if (!vc_parseLimit(buf, &res)) {
 264     WRITE_MSG(2, "Invalid limit in '");
 265     WRITE_STR(2, filename);
 266     WRITE_STR(2, "'\n");
 267     exit(wrapper_exit_code);
 268   }
 269
 270   return res;
 271 }
 272
 273 static bool
 274 readFile(char const *file, char *base, char const *suffix,
 275          vc_limit_t *limit)
 276 {
 277   int           fd;
 278
 279   strcpy(base, suffix);
 280   fd = open(file, O_RDONLY);
 281   if (fd!=-1) {
 282     *limit = readValue(fd, file);
 283     Eclose(fd);
 284   }
 285
 286   return fd!=-1;
 287 }
 288
 289 static void
 290 readFromDir(struct vc_rlimit limits[32], uint_least32_t *mask,
 291             char const *pathname, bool missing_ok)
 292 {
 293   struct stat           st;
 294   size_t                i;
 295   size_t                l_pathname = strlen(pathname);
 296   char                  buf[l_pathname + sizeof("/memlock.hard") + 32];
 297
 298   if (stat(pathname, &st)==-1) {
 299     if (errno==ENOENT && missing_ok) return;
 300     PERROR_Q("vlimit: fstat", pathname);
 301     exit(wrapper_exit_code);
 302   }
 303
 304   memcpy(buf, pathname, l_pathname);
 305   if (l_pathname>0 && pathname[l_pathname-1]!='/')
 306     buf[l_pathname++] = '/';
 307
 308   for (i=0; i<DIM_OF(LIMIT_STR); ++i) {
 309     size_t      l_res;
 310     char *      ptr   = buf+l_pathname;
 311
 312     // ignore unimplemented limits
 313     if (LIMIT_STR[i]==0) continue;
 314
 315     // ignore limits set on cli already
 316     if (*mask & (1<<i)) continue;
 317
 318     l_res = strlen(LIMIT_STR[i]);
 319     memcpy(ptr, LIMIT_STR[i], l_res+1);
 320     while (*ptr) {
 321       *ptr = tolower(*ptr);
 322       ++ptr;
 323     }
 324
 325     if (readFile(buf, ptr, "", &limits[i].min)) {
 326       limits[i].soft = limits[i].hard = limits[i].min;
 327       *mask |= (1<<i);
 328     }
 329
 330     if (readFile(buf, ptr, ".min",  &limits[i].min))
 331       *mask |= (1<<i);
 332
 333     if (readFile(buf, ptr, ".soft", &limits[i].soft))
 334       *mask |= (1<<i);
 335
 336     if (readFile(buf, ptr, ".hard", &limits[i].hard))
 337       *mask |= (1<<i);
 338   }
 339 }
 340
 341 int main (int argc, char *argv[])
 342 {
 343   // overall used limits
 344   uint32_t              lim_mask = 0;
 345   int                   set_mask = 0;
 346   struct vc_rlimit      limits[32];
 347   bool                  show_all   = false;
 348   xid_t                 ctx        = VC_NOCTX;
 349   char const *          dir        = 0;
 350   bool                  missing_ok = false;
 351
 352   {
 353     size_t              i;
 354     for (i=0; i<32; ++i) {
 355       limits[i].min  = VC_LIM_KEEP;
 356       limits[i].soft = VC_LIM_KEEP;
 357       limits[i].hard = VC_LIM_KEEP;
 358     }
 359   }
 360
 361   while (1) {
 362     int         c = getopt_long(argc, argv, "+MSHndac:", CMDLINE_OPTIONS, 0);
 363     if (c==-1) break;
 364
 365     if (2048<=c && c<2048+32) {
 366       int               id  = c-2048;
 367       vc_limit_t        val;
 368
 369       if (!vc_parseLimit(optarg, &val)) {
 370         WRITE_MSG(2, "Can not parse limit '");
 371         WRITE_STR(2, optarg);
 372         WRITE_STR(2, "'\n");
 373         exit(wrapper_exit_code);
 374       }
 375
 376       if (set_mask==0)  set_mask=4;
 377
 378       if (set_mask & 1) limits[id].min  = val;
 379       if (set_mask & 2) limits[id].soft = val;
 380       if (set_mask & 4) limits[id].hard = val;
 381
 382       lim_mask |= (1<<id);
 383       set_mask  = 0;
 384     }
 385     else switch (c) {
 386       case CMD_HELP     :  showHelp(1, argv[0], 0);
 387       case CMD_VERSION  :  showVersion();
 388       case 'a'          :  show_all   = true;            break;
 389       case 'n'          :  do_resolve = false;           break;
 390       case CMD_DIR      :  dir        = optarg;          break;
 391       case CMD_MISSINGOK:  missing_ok = true;            break;
 392       case CMD_XID      :  /*@fallthrough@*/
 393       case 'c'          :  ctx = Evc_xidopt2xid(optarg,true);   break;
 394       case 'd'          :  fmt_func   = utilvserver_fmt_uint64; break;
 395       case 'M'          :
 396       case 'S'          :
 397       case 'H'          :
 398         switch (c) {
 399           case 'M'      :  set_mask |= 1; break;
 400           case 'S'      :  set_mask |= 2; break;
 401           case 'H'      :  set_mask |= 4; break;
 402           default       :  assert(false);
 403         }
 404         break;
 405
 406       default           :
 407         WRITE_MSG(2, "Try '");
 408         WRITE_STR(2, argv[0]);
 409         WRITE_MSG(2, " --help' for more information.\n");
 410         exit(wrapper_exit_code) ;
 411         break;
 412     }
 413   }
 414
 415   if (ctx==VC_NOCTX)
 416     ctx = Evc_get_task_xid(0);
 417
 418   if (dir)
 419     readFromDir(limits, &lim_mask, dir, missing_ok);
 420
 421   setLimits(ctx, limits, lim_mask);
 422   if (show_all) showAll(ctx);
 423
 424   if (optind<argc)
 425     EexecvpD(argv[optind], argv+optind);
 426
 427   return EXIT_SUCCESS;
 428 }