src/planetlab.c

   1 /* Copyright 2005 Princeton University
   2
   3 Redistribution and use in source and binary forms, with or without
   4 modification, are permitted provided that the following conditions
   5 are met:
   6
   7     * Redistributions of source code must retain the above copyright
   8       notice, this list of conditions and the following disclaimer.
   9
  10     * Redistributions in binary form must reproduce the above
  11       copyright notice, this list of conditions and the following
  12       disclaimer in the documentation and/or other materials provided
  13       with the distribution.
  14
  15     * Neither the name of the copyright holder nor the names of its
  16       contributors may be used to endorse or promote products derived
  17       from this software without specific prior written permission.
  18
  19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PRINCETON
  23 UNIVERSITY OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  24 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  25 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  26 OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  27 AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
  29 WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #  include <config.h>
  36 #endif
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <stdint.h>
  42 #include <stdarg.h>
  43 #include <unistd.h>
  44 #include <ctype.h>
  45 #include <sys/resource.h>
  46 #include <sys/types.h>
  47 #include <fcntl.h>
  48 #define _GNU_SOURCE
  49 #include <sched.h>
  50
  51 #include "vserver.h"
  52 #include "planetlab.h"
  53
  54 /* defined in netns.c */
  55 extern uint32_t get_space_flag(xid_t);
  56
  57 #ifndef VC_NXC_RAW_SOCKET
  58 #  define VC_NXC_RAW_SOCKET     0x00000200ull
  59 #endif
  60 #ifndef VC_NXC_RAW_SEND
  61 #  define VC_NXC_RAW_SEND       0x00000400ull
  62 #endif
  63 #ifndef VC_NXF_LBACK_ALLOW
  64 #  define VC_NXF_LBACK_ALLOW    0x00000400ull
  65 #endif
  66
  67 static int
  68 create_context(xid_t ctx, uint64_t bcaps, uint32_t unshare_flags)
  69 {
  70   struct vc_ctx_caps   vc_caps;
  71   struct vc_net_flags  vc_nf;
  72   struct vc_net_caps   vc_ncaps;
  73
  74   /* Create network context */
  75   if (vc_net_create(ctx) == VC_NOCTX) {
  76     if (errno == EEXIST)
  77       goto tag;
  78     return -1;
  79   }
  80
  81   /* Make the network context persistent */
  82   vc_nf.mask = vc_nf.flagword = VC_NXF_PERSISTENT | VC_NXF_LBACK_ALLOW;
  83   if (vc_set_nflags(ctx, &vc_nf))
  84     return -1;
  85
  86   /* Give it raw sockets capabilities */
  87   vc_ncaps.ncaps = vc_ncaps.cmask = VC_NXC_RAW_ICMP | VC_NXC_RAW_SOCKET;
  88   if (vc_set_ncaps(ctx, &vc_ncaps))
  89     return -1;
  90
  91 tag:
  92   /* Create tag context */
  93   if (vc_tag_create(ctx) == VC_NOCTX)
  94     return -1;
  95
  96   /*
  97    * Create context info - this sets the STATE_SETUP and STATE_INIT flags.
  98    */
  99   if (vc_ctx_create(ctx, 0) == VC_NOCTX)
 100     return -1;
 101
 102   if (unshare_flags != 0) {
 103       unshare(unshare_flags);
 104       unshare_flags |= vc_get_space_mask();
 105 #ifdef VC_VXC_NAMESPACE
 106       /* this is a hack to make util-vserver-pl compile with
 107          util-vserver-0.30.216, which changes the signature for
 108          vc_{set,enter}_namespace functions. */
 109       vc_set_namespace(ctx, unshare_flags, NULL);
 110 #else
 111       vc_set_namespace(ctx, unshare_flags);
 112 #endif
 113   }
 114
 115   /* Set capabilities - these don't take effect until SETUP flag is unset */
 116   vc_caps.bcaps = bcaps;
 117   vc_caps.bmask = ~0ULL;  /* currently unused */
 118   vc_caps.ccaps = 0;      /* don't want any of these */
 119   vc_caps.cmask = ~0ULL;
 120   if (vc_set_ccaps(ctx, &vc_caps))
 121     return -1;
 122
 123   if (pl_setsched(ctx, 0, 1) < 0) {
 124     PERROR("pl_setsched(%u)", ctx);
 125     exit(1);
 126   }
 127
 128   return 0;
 129 }
 130
 131 int
 132 pl_setup_done(xid_t ctx)
 133 {
 134   struct vc_ctx_flags  vc_flags;
 135
 136   /* unset SETUP flag - this allows other processes to migrate */
 137   /* set the PERSISTENT flag - so the context doesn't vanish */
 138   /* Don't clear the STATE_INIT flag, as that would make us the init task. */
 139   vc_flags.mask = VC_VXF_STATE_SETUP|VC_VXF_PERSISTENT;
 140   vc_flags.flagword = VC_VXF_PERSISTENT;
 141   if (vc_set_cflags(ctx, &vc_flags))
 142     return -1;
 143
 144   return 0;
 145 }
 146
 147 #define RETRY_LIMIT  10
 148
 149 int
 150 pl_chcontext(xid_t ctx, uint64_t bcaps, const struct sliver_resources *slr)
 151 {
 152   int  retry_count = 0;
 153   int  net_migrated = 0;
 154
 155   if (pl_set_ulimits(slr) != 0)
 156     return -1;
 157
 158   for (;;)
 159     {
 160       struct vc_ctx_flags  vc_flags;
 161
 162       if (vc_get_cflags(ctx, &vc_flags))
 163         {
 164         uint32_t unshare_flags;
 165           if (errno != ESRCH)
 166             return -1;
 167
 168        /* Unshare the net namespace if the slice if requested in the local slice configuration */
 169         unshare_flags = get_space_flag(ctx);
 170
 171           /* context doesn't exist - create it */
 172           if (create_context(ctx, bcaps, unshare_flags))
 173             {
 174               if (errno == EEXIST)
 175                 /* another process beat us in a race */
 176                 goto migrate;
 177               if (errno == EBUSY)
 178                 /* another process is creating - poll the SETUP flag */
 179                 continue;
 180               return -1;
 181             }
 182
 183           /* created context and migrated to it i.e., we're done */
 184           return 1;
 185         }
 186
 187       /* check the SETUP flag */
 188       if (vc_flags.flagword & VC_VXF_STATE_SETUP)
 189         {
 190           /* context is still being setup - wait a while then retry */
 191           if (retry_count++ >= RETRY_LIMIT)
 192             {
 193               errno = EBUSY;
 194               return -1;
 195             }
 196           sleep(1);
 197           continue;
 198         }
 199
 200       /* context has been setup */
 201     migrate:
 202       if (net_migrated || !vc_net_migrate(ctx))
 203         {
 204         uint32_t unshare_flags;
 205       /* Unshare the net namespace if the slice if requested in the local slice configuration */
 206       unshare_flags = get_space_flag(ctx);
 207       if (unshare_flags != 0) {
 208           unshare_flags |=vc_get_space_mask();
 209 #ifdef VC_VXC_NAMESPACE
 210           /* this is a hack to make util-vserver-pl compile with
 211              util-vserver-0.30.216, which changes the signature for
 212              vc_{set,enter}_namespace functions. */
 213           vc_enter_namespace(ctx, unshare_flags, NULL);
 214 #else
 215           vc_enter_namespace(ctx, unshare_flags);
 216 #endif
 217       }
 218
 219           if (!vc_tag_migrate(ctx) && !vc_ctx_migrate(ctx, 0))
 220             break;  /* done */
 221           net_migrated = 1;
 222         }
 223
 224       /* context disappeared - retry */
 225     }
 226
 227   return 0;
 228 }
 229
 230 /* it's okay for a syscall to fail because the context doesn't exist */
 231 #define VC_SYSCALL(x)                           \
 232 do                                              \
 233 {                                               \
 234   if (x)                                        \
 235     return errno == ESRCH ? 0 : -1;             \
 236 }                                               \
 237 while (0)
 238
 239 int
 240 pl_setsched(xid_t ctx, uint32_t cpu_min, uint32_t cpu_share)
 241 {
 242   struct vc_set_sched  vc_sched;
 243   struct vc_ctx_flags  vc_flags;
 244
 245   vc_sched.set_mask = (VC_VXSM_FILL_RATE | VC_VXSM_INTERVAL | VC_VXSM_TOKENS |
 246                        VC_VXSM_TOKENS_MIN | VC_VXSM_TOKENS_MAX | VC_VXSM_MSEC |
 247                        VC_VXSM_FILL_RATE2 | VC_VXSM_INTERVAL2 | VC_VXSM_FORCE);
 248   vc_sched.fill_rate = cpu_min; /* percent reserved */
 249   vc_sched.interval = 100;
 250   vc_sched.fill_rate2 = cpu_share; /* best-effort fair share of unreserved */
 251   vc_sched.interval2 = 1000;  /* milliseconds */
 252   vc_sched.tokens = 100;     /* initial allocation of tokens */
 253   vc_sched.tokens_min = 50;  /* need this many tokens to run */
 254   vc_sched.tokens_max = 100;  /* max accumulated number of tokens */
 255
 256   if (cpu_share) {
 257     if (cpu_share == (uint32_t)VC_LIM_KEEP)
 258       vc_sched.set_mask &= ~(VC_VXSM_FILL_RATE|VC_VXSM_FILL_RATE2);
 259     else
 260       vc_sched.set_mask |= VC_VXSM_IDLE_TIME;
 261   }
 262
 263   VC_SYSCALL(vc_set_sched(ctx, &vc_sched));
 264
 265   vc_flags.mask = VC_VXF_SCHED_FLAGS;
 266   vc_flags.flagword = VC_VXF_SCHED_HARD;
 267   VC_SYSCALL(vc_set_cflags(ctx, &vc_flags));
 268
 269   return 0;
 270 }
 271
 272 enum {
 273   TYPE_LONG = 1,
 274   TYPE_PERS = 2,
 275 };
 276
 277 struct pl_resources {
 278   char *name;
 279   unsigned type;
 280   union {
 281     unsigned long long *limit;
 282     unsigned long int *personality;
 283   };
 284 };
 285
 286 #define WHITESPACE(buffer,index,len)     \
 287   while(isspace((int)buffer[index])) \
 288         if (index < len) index++; else goto out;
 289
 290 #define VSERVERCONF "/etc/vservers/"
 291
 292 void
 293 pl_get_limits(const char *context, struct sliver_resources *slr)
 294 {
 295   FILE *fb;
 296   int cwd;
 297   struct pl_resources *r;
 298
 299   struct pl_resources sliver_list[] = {
 300     {"sched/fill-rate2", TYPE_LONG, &slr->vs_cpu},
 301
 302     {"rlimits/nproc.hard", TYPE_LONG, &slr->vs_nproc.hard},
 303     {"rlimits/nproc.soft", TYPE_LONG, &slr->vs_nproc.soft},
 304     {"rlimits/nproc.min", TYPE_LONG, &slr->vs_nproc.min},
 305
 306     {"rlimits/rss.hard", TYPE_LONG, &slr->vs_rss.hard},
 307     {"rlimits/rss.soft", TYPE_LONG, &slr->vs_rss.soft},
 308     {"rlimits/rss.min", TYPE_LONG, &slr->vs_rss.min},
 309
 310     {"rlimits/as.hard", TYPE_LONG, &slr->vs_as.hard},
 311     {"rlimits/as.soft", TYPE_LONG, &slr->vs_as.soft},
 312     {"rlimits/as.min", TYPE_LONG, &slr->vs_as.min},
 313
 314     {"rlimits/nofile.hard", TYPE_LONG, &slr->vs_nofile.hard},
 315     {"rlimits/nofile.soft", TYPE_LONG, &slr->vs_nofile.soft},
 316     {"rlimits/nofile.min", TYPE_LONG, &slr->vs_nofile.min},
 317
 318     {"rlimits/memlock.hard", TYPE_LONG, &slr->vs_memlock.hard},
 319     {"rlimits/memlock.soft", TYPE_LONG, &slr->vs_memlock.soft},
 320     {"rlimits/memlock.min", TYPE_LONG, &slr->vs_memlock.min},
 321
 322     {"personality", TYPE_PERS, &slr->personality},
 323
 324     {0,0}
 325   };
 326
 327   size_t len = strlen(VSERVERCONF) + strlen(context) + NULLBYTE_SIZE;
 328   char *conf = (char *)malloc(len);
 329   sprintf(conf, "%s%s", VSERVERCONF, context);
 330
 331   slr->vs_rss.hard = VC_LIM_KEEP;
 332   slr->vs_rss.soft = VC_LIM_KEEP;
 333   slr->vs_rss.min = VC_LIM_KEEP;
 334
 335   slr->vs_as.hard = VC_LIM_KEEP;
 336   slr->vs_as.soft = VC_LIM_KEEP;
 337   slr->vs_as.min = VC_LIM_KEEP;
 338
 339   slr->vs_nproc.hard = VC_LIM_KEEP;
 340   slr->vs_nproc.soft = VC_LIM_KEEP;
 341   slr->vs_nproc.min = VC_LIM_KEEP;
 342
 343   slr->vs_nofile.hard = VC_LIM_KEEP;
 344   slr->vs_nofile.soft = VC_LIM_KEEP;
 345   slr->vs_nofile.min = VC_LIM_KEEP;
 346
 347   slr->vs_memlock.hard = VC_LIM_KEEP;
 348   slr->vs_memlock.soft = VC_LIM_KEEP;
 349   slr->vs_memlock.min = VC_LIM_KEEP;
 350
 351   slr->personality = 0;
 352
 353   cwd = open(".", O_RDONLY);
 354   if (cwd == -1) {
 355     perror("cannot get a handle on .");
 356     goto out;
 357   }
 358   if (chdir(conf) == -1) {
 359     fprintf(stderr, "cannot chdir to ");
 360     perror(conf);
 361     goto out_fd;
 362   }
 363
 364   for (r = &sliver_list[0]; r->name; r++) {
 365     char buf[1000];
 366     fb = fopen(r->name, "r");
 367     if (fb == NULL)
 368       continue;
 369     if (fgets(buf, sizeof(buf), fb) != NULL) {
 370       len=strlen(buf);
 371       /* remove trailing newline */
 372       if (buf[len-1] == '\n') {
 373         buf[len-1]='\0';
 374         len --;
 375       }
 376       if (r->type == TYPE_LONG) {
 377         int val;
 378         char *res=0;
 379         errno=0;
 380         val = strtol(buf,&res,0);
 381         if ( !( (val==0 && res) || (errno!=0) ) )
 382           *r->limit = val;
 383       } else if ( (r->type == TYPE_PERS) && isalpha(*buf)) {
 384         unsigned long int res;
 385         res = vc_str2personalitytype(buf,len);
 386         if (res != VC_BAD_PERSONALITY) {
 387           *r->personality = res;
 388         }
 389       }
 390     }
 391
 392     fclose(fb);
 393   }
 394
 395   (void)fchdir(cwd);
 396 out_fd:
 397   close(cwd);
 398 out:
 399   free(conf);
 400 }
 401
 402 int
 403 adjust_lim(const struct vc_rlimit *vcr, struct rlimit *lim)
 404 {
 405   int adjusted = 0;
 406   if (vcr->min != VC_LIM_KEEP) {
 407     if (vcr->min > lim->rlim_cur) {
 408       lim->rlim_cur = vcr->min;
 409       adjusted = 1;
 410     }
 411     if (vcr->min > lim->rlim_max) {
 412       lim->rlim_max = vcr->min;
 413       adjusted = 1;
 414     }
 415   }
 416
 417   if (vcr->soft != VC_LIM_KEEP) {
 418     switch (vcr->min != VC_LIM_KEEP) {
 419     case 1:
 420       if (vcr->soft < vcr->min)
 421         break;
 422     case 0:
 423         lim->rlim_cur = vcr->soft;
 424         adjusted = 1;
 425     }
 426   }
 427
 428   if (vcr->hard != VC_LIM_KEEP) {
 429     switch (vcr->min != VC_LIM_KEEP) {
 430     case 1:
 431       if (vcr->hard < vcr->min)
 432         break;
 433     case 0:
 434         lim->rlim_max = vcr->hard;
 435         adjusted = 1;
 436     }
 437   }
 438   return adjusted;
 439 }
 440
 441 static inline void
 442 set_one_ulimit(int resource, const struct vc_rlimit *limit)
 443 {
 444   struct rlimit lim;
 445   getrlimit(resource, &lim);
 446   adjust_lim(limit, &lim);
 447   setrlimit(resource, &lim);
 448 }
 449
 450 static inline int
 451 set_personality(unsigned long int personality_arg)
 452 {
 453   if (personality_arg == 0)
 454     return 0;
 455   if (personality(personality_arg) < 0) {
 456     return -1;
 457   }
 458   return 0;
 459 }
 460
 461 int
 462 pl_set_ulimits(const struct sliver_resources *slr)
 463 {
 464   if (!slr)
 465     return 0;
 466
 467   set_one_ulimit(RLIMIT_RSS, &slr->vs_rss);
 468   set_one_ulimit(RLIMIT_AS, &slr->vs_as);
 469   set_one_ulimit(RLIMIT_NPROC, &slr->vs_nproc);
 470   set_one_ulimit(RLIMIT_NOFILE, &slr->vs_nofile);
 471   set_one_ulimit(RLIMIT_MEMLOCK, &slr->vs_memlock);
 472   return set_personality(slr->personality);
 473 }