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 <fcntl.h>
  47 #define _GNU_SOURCE
  48 #include <sched.h>
  49
  50 #include "vserver.h"
  51 #include "planetlab.h"
  52
  53 #ifndef VC_NXC_RAW_SOCKET
  54 #  define VC_NXC_RAW_SOCKET     0x00000200ull
  55 #endif
  56 #ifndef VC_NXC_RAW_SEND
  57 #  define VC_NXC_RAW_SEND       0x00000400ull
  58 #endif
  59 #ifndef VC_NXF_LBACK_ALLOW
  60 #  define VC_NXF_LBACK_ALLOW    0x00000400ull
  61 #endif
  62
  63 static int
  64 create_context(xid_t ctx, uint64_t bcaps, uint32_t unshare_flags)
  65 {
  66   struct vc_ctx_caps   vc_caps;
  67   struct vc_net_flags  vc_nf;
  68   struct vc_net_caps   vc_ncaps;
  69   uint32_t unshare_mask;
  70
  71   /* Create network context */
  72   if (vc_net_create(ctx) == VC_NOCTX) {
  73     if (errno == EEXIST)
  74       goto tag;
  75     return -1;
  76   }
  77
  78   /* Make the network context persistent */
  79   vc_nf.mask = vc_nf.flagword = VC_NXF_PERSISTENT | VC_NXF_LBACK_ALLOW;
  80   if (vc_set_nflags(ctx, &vc_nf))
  81     return -1;
  82
  83   /* Give it raw sockets capabilities */
  84   vc_ncaps.ncaps = vc_ncaps.cmask = VC_NXC_RAW_ICMP | VC_NXC_RAW_SOCKET;
  85   if (vc_set_ncaps(ctx, &vc_ncaps))
  86     return -1;
  87
  88 tag:
  89   /* Create tag context */
  90   if (vc_tag_create(ctx) == VC_NOCTX)
  91     return -1;
  92
  93 process:
  94
  95   /*
  96    * Create context info - this sets the STATE_SETUP and STATE_INIT flags.
  97    */
  98   if (vc_ctx_create(ctx, 0) == VC_NOCTX)
  99     return -1;
 100
 101     if (unshare_mask != 0) {
 102       unshare(unshare_mask);
 103       vc_set_namespace(ctx, unshare_mask);
 104   }
 105
 106   /* Set capabilities - these don't take effect until SETUP flag is unset */
 107   vc_caps.bcaps = bcaps;
 108   vc_caps.bmask = ~0ULL;  /* currently unused */
 109   vc_caps.ccaps = 0;      /* don't want any of these */
 110   vc_caps.cmask = ~0ULL;
 111   if (vc_set_ccaps(ctx, &vc_caps))
 112     return -1;
 113
 114   if (pl_setsched(ctx, 0, 1) < 0) {
 115     PERROR("pl_setsched(%u)", ctx);
 116     exit(1);
 117   }
 118
 119   return 0;
 120 }
 121
 122 int
 123 pl_setup_done(xid_t ctx)
 124 {
 125   struct vc_ctx_flags  vc_flags;
 126
 127   /* unset SETUP flag - this allows other processes to migrate */
 128   /* set the PERSISTENT flag - so the context doesn't vanish */
 129   /* Don't clear the STATE_INIT flag, as that would make us the init task. */
 130   vc_flags.mask = VC_VXF_STATE_SETUP|VC_VXF_PERSISTENT;
 131   vc_flags.flagword = VC_VXF_PERSISTENT;
 132   if (vc_set_cflags(ctx, &vc_flags))
 133     return -1;
 134
 135   return 0;
 136 }
 137
 138 #define RETRY_LIMIT  10
 139
 140 int
 141 pl_chcontext(xid_t ctx, uint64_t bcaps, const struct sliver_resources *slr)
 142 {
 143   int  retry_count = 0;
 144   int  net_migrated = 0;
 145
 146   if (pl_set_ulimits(slr) != 0)
 147     return -1;
 148
 149   for (;;)
 150     {
 151       struct vc_ctx_flags  vc_flags;
 152
 153       if (vc_get_cflags(ctx, &vc_flags))
 154         {
 155         uint32_t unshare_mask;
 156           if (errno != ESRCH)
 157             return -1;
 158
 159        /* Unshare the net namespace if the slice if requested in the local slice configuration */
 160         unshare_mask = get_space_flag(ctx);
 161
 162           /* context doesn't exist - create it */
 163           if (create_context(ctx, bcaps, unshare_mask))
 164             {
 165               if (errno == EEXIST)
 166                 /* another process beat us in a race */
 167                 goto migrate;
 168               if (errno == EBUSY)
 169                 /* another process is creating - poll the SETUP flag */
 170                 continue;
 171               return -1;
 172             }
 173
 174           /* created context and migrated to it i.e., we're done */
 175           return 1;
 176         }
 177
 178       /* check the SETUP flag */
 179       if (vc_flags.flagword & VC_VXF_STATE_SETUP)
 180         {
 181           /* context is still being setup - wait a while then retry */
 182           if (retry_count++ >= RETRY_LIMIT)
 183             {
 184               errno = EBUSY;
 185               return -1;
 186             }
 187           sleep(1);
 188           continue;
 189         }
 190
 191       /* context has been setup */
 192     migrate:
 193       if (net_migrated || !vc_net_migrate(ctx))
 194         {
 195         uint32_t unshare_mask;
 196       /* Unshare the net namespace if the slice if requested in the local slice configuration */
 197       unshare_mask = get_space_flag(ctx);
 198       if (unshare_mask != 0) {
 199           vc_enter_namespace(ctx, unshare_mask);
 200           unshare(unshare_mask);
 201       }
 202
 203           if (!vc_tag_migrate(ctx) && !vc_ctx_migrate(ctx, 0))
 204             break;  /* done */
 205           net_migrated = 1;
 206         }
 207
 208       /* context disappeared - retry */
 209     }
 210
 211   return 0;
 212 }
 213
 214 /* it's okay for a syscall to fail because the context doesn't exist */
 215 #define VC_SYSCALL(x)                           \
 216 do                                              \
 217 {                                               \
 218   if (x)                                        \
 219     return errno == ESRCH ? 0 : -1;             \
 220 }                                               \
 221 while (0)
 222
 223 int
 224 pl_setsched(xid_t ctx, uint32_t cpu_min, uint32_t cpu_share)
 225 {
 226   struct vc_set_sched  vc_sched;
 227   struct vc_ctx_flags  vc_flags;
 228
 229   vc_sched.set_mask = (VC_VXSM_FILL_RATE | VC_VXSM_INTERVAL | VC_VXSM_TOKENS |
 230                        VC_VXSM_TOKENS_MIN | VC_VXSM_TOKENS_MAX | VC_VXSM_MSEC |
 231                        VC_VXSM_FILL_RATE2 | VC_VXSM_INTERVAL2 | VC_VXSM_FORCE);
 232   vc_sched.fill_rate = cpu_min; /* percent reserved */
 233   vc_sched.interval = 100;
 234   vc_sched.fill_rate2 = cpu_share; /* best-effort fair share of unreserved */
 235   vc_sched.interval2 = 1000;  /* milliseconds */
 236   vc_sched.tokens = 100;     /* initial allocation of tokens */
 237   vc_sched.tokens_min = 50;  /* need this many tokens to run */
 238   vc_sched.tokens_max = 100;  /* max accumulated number of tokens */
 239
 240   if (cpu_share) {
 241     if (cpu_share == (uint32_t)VC_LIM_KEEP)
 242       vc_sched.set_mask &= ~(VC_VXSM_FILL_RATE|VC_VXSM_FILL_RATE2);
 243     else
 244       vc_sched.set_mask |= VC_VXSM_IDLE_TIME;
 245   }
 246
 247   VC_SYSCALL(vc_set_sched(ctx, &vc_sched));
 248
 249   vc_flags.mask = VC_VXF_SCHED_FLAGS;
 250   vc_flags.flagword = VC_VXF_SCHED_HARD;
 251   VC_SYSCALL(vc_set_cflags(ctx, &vc_flags));
 252
 253   return 0;
 254 }
 255
 256 enum {
 257   TYPE_LONG = 1,
 258   TYPE_PERS = 2,
 259 };
 260
 261 struct pl_resources {
 262         char *name;
 263         unsigned type;
 264   union {
 265     unsigned long long *limit;
 266     unsigned long int *personality;
 267   };
 268 };
 269
 270 #define WHITESPACE(buffer,index,len)     \
 271   while(isspace((int)buffer[index])) \
 272         if (index < len) index++; else goto out;
 273
 274 #define VSERVERCONF "/etc/vservers/"
 275
 276 void
 277 pl_get_limits(const char *context, struct sliver_resources *slr)
 278 {
 279   FILE *fb;
 280   int cwd;
 281   size_t len = strlen(VSERVERCONF) + strlen(context) + NULLBYTE_SIZE;
 282   char *conf = (char *)malloc(len + strlen("rlimits/openfd.hard"));
 283   struct pl_resources *r;
 284   struct pl_resources sliver_list[] = {
 285     {"sched/fill-rate2", TYPE_LONG, &slr->vs_cpu},
 286
 287     {"rlimits/nproc.hard", TYPE_LONG, &slr->vs_nproc.hard},
 288     {"rlimits/nproc.soft", TYPE_LONG, &slr->vs_nproc.soft},
 289     {"rlimits/nproc.min", TYPE_LONG, &slr->vs_nproc.min},
 290
 291     {"rlimits/rss.hard", TYPE_LONG, &slr->vs_rss.hard},
 292     {"rlimits/rss.soft", TYPE_LONG, &slr->vs_rss.soft},
 293     {"rlimits/rss.min", TYPE_LONG, &slr->vs_rss.min},
 294
 295     {"rlimits/as.hard", TYPE_LONG, &slr->vs_as.hard},
 296     {"rlimits/as.soft", TYPE_LONG, &slr->vs_as.soft},
 297     {"rlimits/as.min", TYPE_LONG, &slr->vs_as.min},
 298
 299     {"rlimits/openfd.hard", TYPE_LONG, &slr->vs_openfd.hard},
 300     {"rlimits/openfd.soft", TYPE_LONG, &slr->vs_openfd.soft},
 301     {"rlimits/openfd.min", TYPE_LONG, &slr->vs_openfd.min},
 302
 303     {"personality", TYPE_PERS, &slr->personality},
 304
 305     {0,0}
 306   };
 307
 308   sprintf(conf, "%s%s", VSERVERCONF, context);
 309
 310   slr->vs_rss.hard = VC_LIM_KEEP;
 311   slr->vs_rss.soft = VC_LIM_KEEP;
 312   slr->vs_rss.min = VC_LIM_KEEP;
 313
 314   slr->vs_as.hard = VC_LIM_KEEP;
 315   slr->vs_as.soft = VC_LIM_KEEP;
 316   slr->vs_as.min = VC_LIM_KEEP;
 317
 318   slr->vs_nproc.hard = VC_LIM_KEEP;
 319   slr->vs_nproc.soft = VC_LIM_KEEP;
 320   slr->vs_nproc.min = VC_LIM_KEEP;
 321
 322   slr->vs_openfd.hard = VC_LIM_KEEP;
 323   slr->vs_openfd.soft = VC_LIM_KEEP;
 324   slr->vs_openfd.min = VC_LIM_KEEP;
 325
 326   slr->personality = 0;
 327
 328   cwd = open(".", O_RDONLY);
 329   if (cwd == -1) {
 330     perror("cannot get a handle on .");
 331     goto out;
 332   }
 333   if (chdir(conf) == -1) {
 334     fprintf(stderr, "cannot chdir to ");
 335     perror(conf);
 336     goto out_fd;
 337   }
 338
 339   for (r = &sliver_list[0]; r->name; r++) {
 340     char buf[1000];
 341     fb = fopen(r->name, "r");
 342     if (fb == NULL)
 343       continue;
 344     if (fgets(buf, sizeof(buf), fb) != NULL) {
 345       len=strlen(buf);
 346       /* remove trailing newline */
 347       if (buf[len-1] == '\n') {
 348         buf[len-1]='\0';
 349         len --;
 350       }
 351       if ( (r->type == TYPE_LONG) && isdigit(*buf)) {
 352         *r->limit = atoi(buf);
 353       } else if ( (r->type == TYPE_PERS) && isalpha(*buf)) {
 354         unsigned long int res;
 355         res = vc_str2personalitytype(buf,len);
 356         if (res != VC_BAD_PERSONALITY) {
 357           *r->personality = res;
 358         }
 359       }
 360     }
 361
 362     fclose(fb);
 363   }
 364
 365   fchdir(cwd);
 366 out_fd:
 367   close(cwd);
 368 out:
 369   free(conf);
 370 }
 371
 372 int
 373 adjust_lim(const struct vc_rlimit *vcr, struct rlimit *lim)
 374 {
 375   int adjusted = 0;
 376   if (vcr->min != VC_LIM_KEEP) {
 377     if (vcr->min > lim->rlim_cur) {
 378       lim->rlim_cur = vcr->min;
 379       adjusted = 1;
 380     }
 381     if (vcr->min > lim->rlim_max) {
 382       lim->rlim_max = vcr->min;
 383       adjusted = 1;
 384     }
 385   }
 386
 387   if (vcr->soft != VC_LIM_KEEP) {
 388     switch (vcr->min != VC_LIM_KEEP) {
 389     case 1:
 390       if (vcr->soft < vcr->min)
 391         break;
 392     case 0:
 393         lim->rlim_cur = vcr->soft;
 394         adjusted = 1;
 395     }
 396   }
 397
 398   if (vcr->hard != VC_LIM_KEEP) {
 399     switch (vcr->min != VC_LIM_KEEP) {
 400     case 1:
 401       if (vcr->hard < vcr->min)
 402         break;
 403     case 0:
 404         lim->rlim_max = vcr->hard;
 405         adjusted = 1;
 406     }
 407   }
 408   return adjusted;
 409 }
 410
 411 static inline void
 412 set_one_ulimit(int resource, const struct vc_rlimit *limit)
 413 {
 414   struct rlimit lim;
 415   getrlimit(resource, &lim);
 416   adjust_lim(limit, &lim);
 417   setrlimit(resource, &lim);
 418 }
 419
 420 static inline int
 421 set_personality(unsigned long int personality_arg)
 422 {
 423   if (personality_arg == 0)
 424     return 0;
 425   if (personality(personality_arg) < 0) {
 426     return -1;
 427   }
 428   return 0;
 429 }
 430
 431 int
 432 pl_set_ulimits(const struct sliver_resources *slr)
 433 {
 434   if (!slr)
 435     return 0;
 436
 437   set_one_ulimit(RLIMIT_RSS, &slr->vs_rss);
 438   set_one_ulimit(RLIMIT_AS, &slr->vs_as);
 439   set_one_ulimit(RLIMIT_NPROC, &slr->vs_nproc);
 440   set_one_ulimit(RLIMIT_NOFILE, &slr->vs_openfd);
 441   return set_personality(slr->personality);
 442 }